动手学深度学习pytorch（二）-预备知识

预备知识

由于预备知识大多数都是各位已经掌握的，所以只记录了代码 with 注释。

• 首先简单介绍了Torch的基础用法
• 接着引入数据预处理。
• 然后介绍了线性代数、微积分、概率论等基础数学知识。
• 其中重点需要关注的是自动微分的使用。
• 一个tip是介绍查阅文档的方法。

数据操作

import torch  # 导入PyTorch库

x = torch.arange(12)  # 创建一个包含0到11的整型张量
x.shape  # 获取张量x的形状
x.nemel()  # 这里有拼写错误，应为x.numel()，获取张量x的元素总数
X = x.reshape(3, 4)  # 改变形状为3行4列

torch.zeros((2, 3, 4))  # 创建一个形状为2x3x4的零张量
torch.ones((2, 3, 4))  # 创建一个形状为2x3x4的1张量
torch.randn(3, 4)  # 创建一个形状为3x4的随机正态分布张量
torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])  # 从列表创建一个张量

x = torch.tensor([1.0, 2, 4, 8])  # 创建一个包含浮点数的张量
y = torch.tensor([2, 2, 2, 2])  # 创建一个整型张量
x + y, x-y, x * y, x / y, x ** y  # 执行张量之间的基本算术运算
torch.exp()  # 应该接收一个张量参数，计算张量的指数函数

X = torch.arange(12, dtype=torch.float32).reshape(3, 4)  # 创建一个形状为3x4的浮点型张量
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]], dtype=torch.float32)  # 创建另一个形状为3x4的浮点型张量
torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)  # 在指定维度上连接张量X和Y
X == Y  # 计算X和Y元素是否相等
X.sum()  # 计算张量X所有元素的和
X[-1]  # 获取张量X的最后一个元素
X[1:3]  # 获取张量X的第2到第3行
X[1, 2] = 9  # 将张量X第2行第3列的元素设置为9
X.numpy()  # 将张量X转换为NumPy数组

before = id(Y)  # 获取Y的内存地址
Y = Y + X  # 在原地修改Y，将Y和X相加
id(Y) == before  # 检查Y的内存地址是否改变（通常不会改变）

Z = torch.zeros_like(Y)  # 创建一个与Y形状相同的零张量
before = id(Z)  # 获取Z的内存地址
Z[:] = X + Y  # 将X和Y相加的结果赋值给Z
before == id(Z)  # 检查Z的内存地址是否改变（这里不会改变，因为[:]赋值是原地操作）

A = X.numpy()  # 将X转换为NumPy数组
B = torch.tensor(A)  # 将NumPy数组A转换为张量

a = torch.arange(3).reshape((3, 1))  # 创建一个形状为3x1的张量
b = torch.arange(2).reshape((1, 2))  # 创建一个形状为1x2的张量
a + b  # 计算张量a和b的和，这里会进行广播

数据预处理

import os  # 导入操作系统接口模块
# 创建一个新目录用于存储数据文件，如果目录已存在则不抛出错误
os.makedirs(os.path.join('..', 'data'), exist_ok=True)
# 构建数据文件的完整路径
data_file = os.path.join('..', 'data', 'house_tiny.csv')
# 打开文件用于写入，并写入CSV格式的数据
with open(data_file, 'w') as f:
    f.write('NumRooms,Alley,Price\n')  # 写入列名
    f.write('NA,Pave,127500\n')  # 写入数据样本，每行一个
    f.write('2,NA,106000\n')
    f.write('4,NA,178100\n')
    f.write('NA,NA,140000\n')
    
import pandas as pd  # 导入pandas库用于数据处理
# 读取CSV文件到DataFrame
data = pd.read_csv(data_file)
print(data)  # 打印DataFrame
# 分离输入和输出数据，其中输入是前两列，输出是第三列
inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]
# 使用均值填充输入数据中的缺失值
inputs = inputs.fillna(inputs.mean())
print(inputs)  # 打印处理后的输入数据
# 删除缺失值最多的列
nan_count = np.sum(data.isnull(), axis=0)  # 计算每列的缺失值数量
# data.drop(columns=[nan_count.idxmax()], inplace=True)  # 删除缺失值最多的列（注释掉未执行）
data.drop(columns=data.columns[np.argmax(nan_count)], inplace=True)  # 删除缺失值最多的列
# 获取输入数据的独热编码，同时处理缺失值
inputs = pd.get_dummies(inputs, dummy_na=True)
print(inputs)  # 打印独热编码后的输入数据
import torch  # 导入PyTorch库用于深度学习
import numpy as np  # 导入NumPy库用于数组操作
# 将DataFrame转换为NumPy数组，并进一步转换为PyTorch张量
X = torch.tensor(inputs.to_numpy(dtype=float))  # 输入数据
y = torch.tensor(outputs.to_numpy(dtype=float))  # 输出数据

线性代数

import torch  # 导入PyTorch库
# 创建一个包含20个元素的数组，并将其重塑为5行4列的张量
A = torch.arange(20).reshape(5, 4)
# 转置张量A
A.T  # 返回张量A的转置
# 重新创建一个包含20个元素的数组，并将其重塑为5行4列的张量
A = torch.arange(20).reshape(5, 4)
# 乘法运算，这里没有定义B，所以这行代码会引发错误
# A * B
# 计算张量A沿着第0轴（列）的总和
A_sum_axis0 = A.sum(axis=0)
# 计算张量A沿着第0轴（列）的累积和
A.cumsum(axis=0)
# 创建一个包含4个元素的数组，数据类型为float32
x = torch.arange(4, dtype=torch.float32)
# 创建一个包含4个元素的数组，数据类型为float32，所有元素为1
y = torch.ones(4, dtype=torch.float32)
# 计算两个一维张量的点积
torch.dot(x, y)
# 使用矩阵向量乘法（MVM）计算A和x的乘积
torch.mv(A, x)
# 创建一个包含4个元素的数组，数据类型为float32，所有元素为1
B = torch.ones(4, 3)
# 计算两个二维张量的矩阵乘积
torch.mm(A, B)
# 创建一个包含两个元素的数组，数据类型为float32
u = torch.tensor([3.0, -4.0])
# 计算向量u的欧几里得范数
torch.norm(u)
# 计算向量u的绝对值之和
torch.abs(u).sum()
# 计算一个大小为4x9的二维张量的欧几里得范数
torch.norm(torch.ones((4, 9)))

微积分

高数内容，此处pass

自动微分

import torch
# 创建一个包含4个元素的数组，数据类型为float，并设置requires_grad为True，表示这个张量需要进行梯度计算
x = torch.arange(4.0)
x.requires_grad_(True)
# 计算x的平方和，并设置其requires_grad为True
y = 2 * torch.dot(x, x)
y.requires_grad_(True)
# 对y进行反向传播，计算其梯度
y.backward()
# 打印x的梯度
x.grad
# 重置x的梯度
x.grad.zero_()
# 计算x的平方
y = x * x
# 将y转换为不可梯度计算的状态，并设置其requires_grad为False
u = y.detach()
u.requires_grad_(False)
# 计算u与x的乘积
z = u * x
# 对z进行反向传播，计算其梯度
z.sum().backward()
# 检查x的梯度是否等于2 * x
x.grad == 2 * x
# 重置x的梯度
x.grad.zero_()
# 对y进行反向传播，计算其梯度
y.sum().backward()
# 检查x的梯度是否等于2 * x
x.grad == 2 * x

概率

%matplotlib inline  # 设置matplotlib以交互方式显示图表
import torch
from torch.distributions import multinomial  # 导入multinomial分布类
from d2l import torch as d2l  # 导入d2l模块的torch子模块
# 创建一个均匀分布的概率向量
fair_probs = torch.ones([6]) / 6
# 使用multinomial分布生成随机样本
# 参数1：试验次数，参数2：每个试验的成功概率
multinomial.Multinomial(1, fair_probs).sample()  # 生成一个随机样本
multinomial.Multinomial(10, fair_probs).sample()  # 生成另一个随机样本
# 将结果存储为32位浮点数以进行除法
counts = multinomial.Multinomial(1000, fair_probs).sample()
counts / 1000  # 相对频率作为估计值
# 生成10次试验的500组随机样本
counts = multinomial.Multinomial(10, fair_probs).sample((500,))
# 计算累积计数
cum_counts = counts.cumsum(dim=0)
# 计算估计的概率
estimates = cum_counts / cum_counts.sum(dim=1, keepdims=True)
# 设置图表大小
d2l.set_figsize((6, 4.5))
# 绘制每个骰子出现次数的估计概率
for i in range(6):
    d2l.plt.plot(estimates[:, i].numpy(),
                 label=("P(die=" + str(i + 1) + ")"))
# 绘制理论概率线
d2l.plt.axhline(y=0.167, color='black', linestyle='dashed')
# 设置图表标签
d2l.plt.gca().set_xlabel('Groups of experiments')
d2l.plt.gca().set_ylabel('Estimated probability')
# 显示图例
d2l.plt.legend();

查阅文档

import torch
# 打印torch.distributions模块中的所有函数和方法
print(dir(torch.distributions))
# 打印torch.ones函数的帮助信息
help(torch.ones)