企业官网建设流程全解析

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 运算符

按元素计算可分为两种类型：

1. 单输入函数：f:R→Rf: \mathbb{R} \rightarrow \mathbb{R}f:R→R，如torch.exp(x)、torch.log()、torch.sin()
2. 双输入函数：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 += Y

2.1.6 转换为其他python对象

1. 与NumPy数组互转：

   • tensor转numpy：X.numpy()
   • numpy转tensor：torch.tensor(array)

2. 张量转标量（仅适用于一维张量）：

   • 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)

示例对比

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=1n​ai​bi​
• 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=1n​bi2​​，实现：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=1m​aij2​​
• 实现：torch.norm(A)（与向量L2范数使用相同函数）

2.4 微积分

导数定义

函数可微的数学定义：
f′(x)=lim⁡h→0f(x+h)−f(x)hf'(x) = \lim_{h \to 0} \frac{f(x+h) - f(x)}{h}f′(x)=h→0lim​hf(x+h)−f(x)​
可微条件：函数在该点的左右导数存在且相等

函数类型与导数表示

复合函数求导

深度学习反向传播基于链式法则：

• 若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_()

关键注意事项

1. 计算图创建：每次前向传播会创建新的计算图，因此loss应在训练循环内部定义
2. 参数继承：模型参数（w,b）应在训练循环外初始化，在循环内更新
3. 梯度清零：每次参数更新后必须清零梯度，否则会累积上一轮的梯度
4. 内存优化：使用in-place操作（如w -= ...）减少内存消耗