自动微分与手动构建模型实战
一、自动微分
1. 基础概念
自动微分模块 torch.autograd 负责自动计算张量操作的梯度，主要特点包括：
- 张量：
requires_grad=True的张量会追踪其所有操作，以便后续计算梯度。 - 计算图：动态创建计算图，记录操作。
- 反向传播：通过
.backward()计算梯度。 - 梯度访问：通过
.grad属性访问计算结果。
2. 计算梯度
2.1 标量梯度计算
import torch# 创建一个标量张量
x = torch.tensor(7.0, requires_grad=True)
y = x**2 + 2 * x + 7
# 计算梯度
y.backward()
# 查看梯度
print(x.grad) # 输出：tensor(16.)
解释：
requires_grad=True表示张量需要计算梯度。.backward()会对标量计算梯度。- 结果存储在
x.grad中。
2.2 向量梯度计算
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
y = x**2 + 2 * x + 7
z = y.mean() # 将向量变为标量
z.backward()
print(x.grad) # 输出向量的梯度
解释：
- 向量梯度需要通过
.mean()或.sum()将其变为标量。 .backward()自动传播计算各分量的梯度。
2.3 梯度清零
梯度会累加，清零可以防止影响下一次计算：
if x.grad is not None:x.grad.zero_()
二、手动构建模型实战
1. 数据处理
1.1 构建数据集
from sklearn.datasets import make_regression
import torch# 生成数据
X, y, coef = make_regression(n_samples=1000, n_features=5, noise=5, coef=True, random_state=0
)
X = torch.tensor(X, dtype=torch.float32)
y = torch.tensor(y, dtype=torch.float32)
1.2 数据加载器
import random, mathdef data_loader(x, y, batch_size=16):indices = list(range(x.shape[0]))random.shuffle(indices)num_batches = math.ceil(len(indices) / batch_size)for i in range(num_batches):start = i * batch_sizeend = min(start + batch_size, len(indices))yield x[indices[start:end]], y[indices[start:end]]
2. 模型与损失函数
2.1 模型函数
def linear_regression(x, w, b):return torch.matmul(x, w) + b
2.2 损失函数
def mean_squared_error(y_pred, y_true):return torch.mean((y_pred - y_true)**2)
3. 参数初始化与优化器
3.1 参数初始化
def initialize_params(n_features):w = torch.randn(n_features, requires_grad=True)b = torch.tensor(0.0, requires_grad=True)return w, b
3.2 优化器 (SGD)
def sgd(w, b, dw, db, lr, batch_size):w.data -= lr * dw / batch_sizeb.data -= lr * db / batch_size
4. 训练模型
训练函数
def train():X, y, coef = make_regression_data()w, b = initialize_params(X.shape[1])lr, epochs, batch_size = 0.01, 100, 16for epoch in range(epochs):total_loss = 0for X_batch, y_batch in data_loader(X, y, batch_size):y_pred = linear_regression(X_batch, w, b)loss = mean_squared_error(y_pred, y_batch)total_loss += loss.item()# 反向传播和参数更新loss.backward()w.grad.zero_()b.grad.zero_()sgd(w, b, w.grad, b.grad, lr, batch_size)print(f"Epoch {epoch + 1}, Loss: {total_loss}")
5. 总结
通过以上代码，展示了从数据处理、模型定义、训练过程到结果的完整实现。训练时通过反向传播和优化器不断调整参数，逐步减小误差。
最后是整个手动构建的代码
import math
import random
import torch
import numpy as np
from sklearn.datasets import make_regression
import pandas as pddef build_dataset():"""使用 sklearn 的 make_regression 方法来构建一个模拟的回归数据集。make_regression 方法的参数解释:- n_samples: 生成的样本数量，决定了数据集的规模。- n_features: 生成的特征数量，决定了数据维度。- noise: 添加到目标变量的噪声标准差，用于模拟真实世界数据的不完美。- coef: 如果为 True, 会返回生成数据的真实系数，用于了解特征与目标变量间的真实关系。- random_state: 随机数生成的种子，确保在多次运行中能够复现相同的结果。返回:- X: 生成的特征矩阵。- y: 生成的目标变量。- coef: 如果在调用时 coef 参数为 True，则还会返回真实系数。"""noise = random.randint(1, 3)bias = 14.5X, y, coef = make_regression(n_samples=1000, n_features=5, bias=bias, noise=noise, coef=True, random_state=0)# 数据转换为张量X = torch.tensor(X, dtype=torch.float32)y = torch.tensor(y, dtype=torch.float32)coef = torch.tensor(coef, dtype=torch.float32)bias = torch.tensor(bias, dtype=torch.float32)return X, y, coef, biasdef data_loader(x, y, batch_size=16):"""将数据集转换为迭代器，以便在训练过程中进行批量处理。"""# 获取样本数量num_samples = x.shape[0]# 构建数据索引indices = list(range(num_samples))# 打乱数据顺序random.shuffle(indices)# 计算总的批次数量：向上取整num_batches = math.ceil(num_samples / batch_size)for i in range(num_batches):start = i * batch_sizeend = min((i + 1) * batch_size, num_samples)# 开始切片数据train_X = x[indices[start:end]]train_y = y[indices[start:end]]# 异步响应数据集yield train_X, train_y# 构建模型函数：权重参数和偏执参数
# 初始化参数
def initialize_params(n_features):# 随机初始化权重w，并将偏置b初始化为0w = torch.randn(n_features, requires_grad=True, dtype=torch.float32)b = torch.tensor(0.0, requires_grad=True, dtype=torch.float32)return w, bdef linear_regression(x, w, b):return torch.matmul(x, w) + b# 构建模型函数：损失函数和优化器
def mean_squared_error(y_pred, y_true):return torch.mean((y_pred - y_true) ** 2)# 优化器（SGD，手动实现）
def sgd(w, b, dw, db, learning_rate, batch_size):w.data -= learning_rate * dw.data / batch_sizeb.data -= learning_rate * db.data / batch_sizereturn w, b# 训练函数
def train():# 1. 构建数据集X, y, coef, bias = build_dataset()# 2. 初始化模型参数w, b = initialize_params(X.shape[1])# 3. 定义训练参数learning_rate = 0.01epochs = 120batch_size = 16# 4. 开始训练for epoch in range(epochs):epoch_loss = 0num_batches = 0for train_X, train_y in data_loader(X, y, batch_size):num_batches += 1# 5. 前向传播y_pred = linear_regression(train_X, w, b)# 6. 计算损失loss = mean_squared_error(y_pred, train_y)# 9. 梯度清零if w.grad is not None:w.grad.zero_()if b.grad is not None:b.grad.zero_()# 7. 反向传播：会自动计算梯度loss.backward()# 8. 更新参数w, b = sgd(w, b, w.grad, b.grad, learning_rate, batch_size)# 10. 训练批次及损失率epoch_loss += loss.item()print(f"Epoch: {epoch}, Loss: {epoch_loss / num_batches}")return coef, bias, w, bif __name__ == "__main__":coef, bias, w, b = train()print(f"真实系数: {coef}")print(f"预测系数: {w}")print(f"真实偏置: {bias}")print(f"预测偏置: {b}")结果为：
Epoch: 0, Loss: 9141.109053354414
......
Epoch: 9, Loss: 2438.3174680679563
......
Epoch: 18, Loss: 643.4502219548301
......
Epoch: 31, Loss: 100.09944831000433
......
Epoch: 48, Loss: 9.588121845608665
......
Epoch: 64, Loss: 1.8927827449071974
......
Epoch: 119, Loss: 1.006377797278147
真实系数: tensor([41.2059, 66.4995, 10.7145, 60.1951, 25.9615])
预测系数: tensor([41.1517, 66.4983, 10.7523, 60.2103, 25.9089], requires_grad=True)
真实偏置: 14.5
预测偏置: 14.50900650024414
