2.1 数据操作
2.1.1 入门
Torch创建的tensor能够指定从磁盘提取后的存储地址，可以是内存或者显存。转移的命令为model.to("cuda")data.to("cuda")或者采用data.cuda()。如果需要使用显存运算，必须把模型参数和数据转移至显存中。Numpy创建的数组只能在cpu中，因为其存储只能在内存中。
基于torch创建tensor的简单操作：
- 成等差数列：
torch.arange(12) - 成满足正态分布的矩阵：
torch.randn((shape))（圆括号内表示shape的形状） - 成全一，一定形状的矩阵：
torch.ones(shape) - 成全零、一定形状的矩阵：
torch.zeros(shape)
查看tensor属性的命令：
- 形状和元素数量：
tensor.shape、tensor.numel()、tensor.ndim - 设备和数据类型：
tensor.device、tensor.dtype、tensor.is_cuda - 内存布局：
tensor.is_contiguous() - 计算图属性：
tensor.requires_grad（查看是否需要计算梯度）、tensor.grad（梯度值）、tensor.grad_fn（梯度函数）
改变tensor形状的方法：
new_tensor = old_tensor.reshape(shape)- 自动计算维度：
new_tensor = old_tensor.reshape((-1, wide))或new_tensor = old_tensor.reshape((long, -1))（-1表示自动计算该维度）
2.1.2 运算符
按元素计算可分为两种类型：
- 单输入函数：f:R→Rf: \mathbb{R} \rightarrow \mathbb{R}f:R→R，如
torch.exp(x)、torch.log()、torch.sin() - 双输入函数：f:R,R→Rf: \mathbb{R}, \mathbb{R} \rightarrow \mathbb{R}f:R,R→R，如
X+Y、X*Y、X/Y、X*torch.exp(Y)（要求两个tensor大小相同）
张量拼接：torch.cat((X,Y), dim=0/1)（需保证拼接维度外的其他维度相同）
张量求和：X.sum()（对所有元素求和）
2.1.3 tensor的广播机制
当两个数组维度不同时，广播机制会自动扩展维度较小的数组：
- 若数组形状为(a,b)(a,b)(a,b)和(c,d)(c,d)(c,d)，且a>ca > ca>c，则在dim=0轴复制行使形状匹配
- 若d>bd > bd>b，则在dim=1轴复制列使形状匹配
- 前提条件：非匹配维度必须满足其中一个为1或两者成倍数关系
2.1.4 索引与切片
索引和切片操作与Python列表类似，语法为tensor[start:end:step]。注意部分操作可能导致降维。
2.1.5 节省内存
避免创建新对象的内存优化方法：
- 原地修改方式1：
X[:] = X + Y - 原地修改方式2：
X += Y（推荐，更简洁）
对比示例：
Y=torch.arange(12)before=id(Y)Y=X+Y# 创建新对象，内存地址改变new=id(Y)print(before==new)# 输出FalseX[:]=X+Y# 原地修改，内存地址不变# 或 X += Y2.1.6 转换为其他python对象
与NumPy数组互转：
- tensor转numpy：
X.numpy() - numpy转tensor：
torch.tensor(array)
- tensor转numpy：
张量转标量（仅适用于一维张量）：
a.item()（推荐，返回Python标量）float(a)或int(a)（类型转换）
2.2 数据预处理
结合pandas进行数据预处理的完整流程：
步骤1：读取数据
importpandasaspd dataframe=pd.read_csv("文件路径.csv")步骤2：处理缺失值
# 提取特征列inputs=dataframe.iloc[:,0:2]# 用均值填充缺失值inputs.fillna(inputs.mean(),inplace=True)# 或删除含缺失值的行df.dropna(axis=0,how='any',inplace=True)# axis=0表示行，how='any'表示只要有缺失就删除步骤3：转换为tensor
importtorch# 先获取numpy数组，再转换为tensortensor_data=torch.tensor(inputs.values)2.3 线性代数
基本概念
数据存储维度体系：
- 标量（0维张量）：单个数值
- 向量（1维张量）：有方向的数组，长度即维度
- 矩阵（2维张量）：行×列的二维数组
- 高阶张量：三维及以上（如图像的通道×高×宽）
数学符号规范：
- 标量：小写字母，如x∈Rx \in \mathbb{R}x∈R或x∈{0,1}x \in \{0,1\}x∈{0,1}
- 向量：加粗小写字母，如x\mathbf{x}x，元素表示为xix_ixi（不加粗）
- 矩阵：加粗大写字母，如A\mathbf{A}A
2.3.1 张量算法的基本性质
- 一元运算：不改变张量形状，如
torch.abs()、torch.exp() - 二元运算：要求输入张量形状匹配，如
torch.add()、torch.mul()
2.3.2 求和降维
基本求和
- 全元素求和：
A.sum()（返回标量） - 指定维度求和：
A.sum(dim=0)（沿第0维求和，降维操作）
维度保持
- 使用
keepdims=True参数保持维度：A.sum(dim=0, keepdims=True) - 累积求和（不改变形状）：
A.cumsum(dim=0)
示例对比
| 操作 | 代码 | 输入形状 | 输出形状 |
|---|---|---|---|
| 全元素求和 | A.sum() | (3,4) | () |
| 按行求和 | A.sum(dim=0) | (3,4) | (4,) |
| 按列求和 | A.sum(dim=1) | (3,4) | (3,) |
| 保持维度求和 | A.sum(dim=0, keepdims=True) | (3,4) | (1,4) |
2.3.3 代数中的相乘规则
1. 向量点积
- 数学定义：a∈Rn,b∈Rn,aTb=∑i=1naibi\mathbf{a} \in \mathbb{R}^n, \mathbf{b} \in \mathbb{R}^n, \mathbf{a}^T\mathbf{b} = \sum_{i=1}^n a_i b_ia∈Rn,b∈Rn,aTb=∑i=1naibi
- PyTorch实现：
torch.dot(a, b)（要求a和b都是1维张量）
2. 矩阵-向量乘法
- 数学定义：A∈Rn×m,b∈Rm,Ab∈Rn\mathbf{A} \in \mathbb{R}^{n \times m}, \mathbf{b} \in \mathbb{R}^m, \mathbf{Ab} \in \mathbb{R}^nA∈Rn×m,b∈Rm,Ab∈Rn
- PyTorch实现：
torch.mv(A, b)
3. 矩阵-矩阵乘法
- 数学定义：A∈Rn×m,B∈Rm×p,AB∈Rn×p\mathbf{A} \in \mathbb{R}^{n \times m}, \mathbf{B} \in \mathbb{R}^{m \times p}, \mathbf{AB} \in \mathbb{R}^{n \times p}A∈Rn×m,B∈Rm×p,AB∈Rn×p
- PyTorch实现：
torch.mm(A, B)（要求A的列数等于B的行数）
2.3.4 范数
向量范数
- L1范数：∥a∥1=∑i=1n∣ai∣\|\mathbf{a}\|_1 = \sum_{i=1}^n |a_i|∥a∥1=∑i=1n∣ai∣，实现：
torch.sum(torch.abs(a)) - L2范数：∥b∥2=∑i=1nbi2\|\mathbf{b}\|_2 = \sqrt{\sum_{i=1}^n b_i^2}∥b∥2=∑i=1nbi2，实现：
torch.norm(b)
矩阵范数
- 弗罗贝尼乌斯范数（Frobenius norm）：∥A∥F=∑i=1n∑j=1maij2\|\mathbf{A}\|_F = \sqrt{\sum_{i=1}^n \sum_{j=1}^m a_{ij}^2}∥A∥F=∑i=1n∑j=1maij2
- 实现：
torch.norm(A)（与向量L2范数使用相同函数）
2.4 微积分
导数定义
函数可微的数学定义：
f′(x)=limh→0f(x+h)−f(x)hf'(x) = \lim_{h \to 0} \frac{f(x+h) - f(x)}{h}f′(x)=h→0limhf(x+h)−f(x)
可微条件：函数在该点的左右导数存在且相等
函数类型与导数表示
| 函数类型 | 数学表示 | 导数/偏导数表示 |
|---|---|---|
| 标量到标量 | f:R→Rf: \mathbb{R} \rightarrow \mathbb{R}f:R→R | dfdx\frac{df}{dx}dxdf或f′(x)f'(x)f′(x) |
| 向量到标量 | f:Rn→Rf: \mathbb{R}^n \rightarrow \mathbb{R}f:Rn→R | ∂f∂xi\frac{\partial f}{\partial x_i}∂xi∂f（偏导数） |
| 向量到向量 | f:Rn→Rmf: \mathbb{R}^n \rightarrow \mathbb{R}^mf:Rn→Rm | 雅可比矩阵J∈Rm×n\mathbf{J} \in \mathbb{R}^{m \times n}J∈Rm×n，其中Jij=∂fi∂xjJ_{ij} = \frac{\partial f_i}{\partial x_j}Jij=∂xj∂fi |
复合函数求导
深度学习反向传播基于链式法则：
- 若y=f(u),u=g(x)y = f(u), u = g(x)y=f(u),u=g(x)，则dydx=dydu⋅dudx\frac{dy}{dx} = \frac{dy}{du} \cdot \frac{du}{dx}dxdy=dudy⋅dxdu
- 多变量情况：∂y∂xi=∑j∂y∂uj⋅∂uj∂xi\frac{\partial y}{\partial x_i} = \sum_j \frac{\partial y}{\partial u_j} \cdot \frac{\partial u_j}{\partial x_i}∂xi∂y=∑j∂uj∂y⋅∂xi∂uj
2.5 自动微分
PyTorch的自动微分通过计算图实现，核心流程如下：
步骤1：初始化参数
w=torch.randn(2,requires_grad=True)# 随机初始化权重并开启梯度追踪b=torch.randn(1,requires_grad=True)# 随机初始化偏置并开启梯度追踪步骤2：构建计算图
# 假设X为输入特征，Y_true为真实标签Y_pred=torch.matmul(X,w)+b# 线性预测loss=torch.mean((Y_true-Y_pred)**2)# 均方误差损失步骤3：反向传播计算梯度
loss.backward()# 从loss开始反向传播计算梯度# 此时w.grad和b.grad中存储了对应的梯度值步骤4：参数更新（梯度下降）
learning_rate=0.01withtorch.no_grad():# 关闭梯度追踪以节省内存w-=w.grad*learning_rate b-=b.grad*learning_rate# 清零梯度（重要！否则梯度会累积）w.grad.zero_()b.grad.zero_()关键注意事项
- 计算图创建：每次前向传播会创建新的计算图，因此loss应在训练循环内部定义
- 参数继承：模型参数（w,b）应在训练循环外初始化，在循环内更新
- 梯度清零：每次参数更新后必须清零梯度，否则会累积上一轮的梯度
- 内存优化：使用
in-place操作（如w -= ...）减少内存消耗
)
