人工智能-深度学习-Torch框架-手动构建回归流程

from sklearn.datasets import make_regression
import math
import random
import torch

from sklearn.datasets import make_regression: 导入make_regression函数，用于生成回归数据集。
import math: 导入math模块，用于进行数学计算，例如向上取整。
import random: 导入random模块，用于随机打乱数据集。
import torch: 导入torch库，用于张量操作和神经网络训练。

构建数据集

def build_data():'''构建数据集'''noise = 14.6#噪声n_sample = 1000#样本数量X,y,coef = make_regression(n_samples=n_sample,n_features=4,coef=True)X = torch.tensor(X,dtype=torch.float64,requires_grad=True)y = torch.tensor(y,dtype=torch.float64,requires_grad=True)return X,y,coef

def build_data():: 定义一个名为build_data的函数，用于构建数据集。
noise = 14.6: 设置噪声水平为14.6，用于生成带有噪声的数据。
n_sample = 1000: 设置样本数量为1000，用于生成1000个样本。
X, y, coef = make_regression(n_samples=n_sample, n_features=4, coef=True): 使用make_regression生成回归数据集，包含1000个样本和4个特征，并返回真实系数。
X = torch.tensor(X, dtype=torch.float64, requires_grad=True): 将生成的特征矩阵X转换为PyTorch张量，数据类型为torch.float64，并设置requires_grad=True以启用梯度计算。
y = torch.tensor(y, dtype=torch.float64, requires_grad=True): 将生成的目标向量y转换为PyTorch张量，数据类型为torch.float64，并设置requires_grad=True以启用梯度计算。
return X, y, coef: 返回特征矩阵X、目标向量y和真实系数coef。

构建数据加载器

def data_loader(x,y):'''数据加载器'''#配置参数batch_size = 16#一个批次的数量n_sample = x.shape[0]#len(x)长度n_batches = math.ceil(n_sample/batch_size)#一轮的训练次数index = [i for i in range(n_sample)]random.shuffle(index)for i in range(0,n_batches):indexs = index[i*batch_size:min((i+1)*batch_size,n_sample)]yield x[indexs],y[indexs]

def data_loader(x, y):: 定义一个名为data_loader的函数，用于加载数据。
batch_size = 16: 设置每个批次的样本数量为16，用于控制每次训练的样本数量。
n_sample = x.shape[0]: 获取样本数量，用于计算批次数量。
n_batches = math.ceil(n_sample / batch_size): 计算每轮的批次数量，使用math.ceil向上取整，确保所有样本都能被处理。
index = [i for i in range(n_sample)]: 创建一个包含所有样本索引的列表，用于随机打乱样本顺序。
random.shuffle(index): 打乱样本索引，以随机化样本顺序，避免训练过程中的顺序偏差。
for i in range(0, n_batches):: 遍历每个批次，确保每个批次都能被处理。
indexs = index[i * batch_size:min((i + 1) * batch_size, n_sample)]: 获取当前批次的索引，确保最后一个批次也能被处理。
yield x[indexs], y[indexs]: 返回当前批次的特征矩阵和目标向量，使用yield生成一个生成器，用于按需加载数据。

构建模型函数

def myregreser(x,w,b):return x@w+b#一个容器中装着的是每一条样本数据的预测值

x@w+b 跟 y = x*w+b差不多，无需多言哈

def myregreser(x, w, b):: 定义一个名为myregreser的函数，用于计算线性回归模型的预测值。
return x @ w + b: 返回预测值，使用矩阵乘法@计算x和w的乘积，然后加上偏置b，实现线性回归模型.

构建损失函数

def MSE(y_pred,y_true):return torch.mean((y_pred-y_true)**2)

def MSE(y_pred, y_true):: 定义一个名为MSE的函数，用于计算均方误差（MSE）损失。
return torch.mean((y_pred - y_true) ** 2): 返回预测值和真实值之间的均方误差，用于衡量模型的预测精度。

把参数初始化

def  initialize(n_featrue):torch.manual_seed(666)w = torch.randn(n_featrue,requires_grad=True,dtype=torch.float64)# print(w)b = torch.tensor(14.5,requires_grad=True,dtype=torch.float64)return w,b

def initialize(n_feature):: 定义一个名为initialize的函数，用于初始化模型参数。
torch.manual_seed(666): 设置随机种子为666，以确保结果可重复，避免随机性带来的不确定性。
w = torch.randn(n_feature): 使用随机值初始化权重w，确保模型初始状态具有一定的随机性。
b = torch.tensor(14.5, requires_grad=True, dtype=torch.float64): 初始化偏置b，并设置requires_grad=True以启用梯度计算，确保偏置可以被优化。
return w, b: 返回初始化的权重和偏置。

构建梯度下降函数

def optim_step(w,b,dw,db,lr):
#更新梯度，朝着梯度下降的方向去更新梯度w.data = w.data-lr*dw.datab.data = b,data-lr*db.data

def optim_step(w, b, dw, db, lr):: 定义一个名为optim_step的函数，用于更新模型参数。
w.data = w.data - lr * dw.data: 更新权重w，沿着梯度下降的方向，使用学习率lr控制更新的步长。
b.data = b.data - lr * db.data: 更新偏置b，沿着梯度下降的方向，使用学习率lr控制更新的步长。

使用上面构建的函数进行实战训练

def train():#生成数据x,y,coef = build_data()#初始化参数w,b = initialize(x.shape[1])#定义训练参数lr = 0.01epoch = 100for i in range(epoch):loss_e = 0count = 0for batch_x,batch_y_true in data_loader(x,y):y_bacth_pred = myregreser(batch_x,w,b)loss = MSE(y_bacth_pred,batch_y_true)loss_e+=losscount+=1#梯度清零if w.grad is not None:w.data.zero_()if b.grad is not None:b.data.zero_()#反向传播（梯度计算）loss.backward()#梯度更行optim_step(w,b,w.grad,b.grad,lr)print(f'epoch:{i},loss:{loss_e/count}')return w,b,coef
if __name__=='__main__':w,b,coef = train()print(w,b)print(coef)print(torch.allclose(w,torch.tensor(coef)))

def train():: 定义一个名为train的函数，用于训练模型。
x, y, coef = build_data(): 生成数据集，获取特征矩阵x、目标向量y和真实系数coef。
w, b = initialize(x.shape[1]): 初始化模型参数，获取初始化的权重w和偏置b。
lr = 0.01: 设置学习率为0.01，控制参数更新的步长。
epoch = 100: 设置训练轮数为100，控制训练的迭代次数。
for i in range(epoch):: 外层循环，遍历每个训练轮，确保模型在多个轮次中进行训练。
loss_e = 0: 初始化每轮的总损失为0，用于累加每个批次的损失。
count = 0: 初始化批次计数为0，用于计算每轮的平均损失。
for batch_x, batch_y_true in data_loader(x, y):: 内层循环，遍历每个批次的数据，确保每个批次都能被处理。
y_batch_pred = myregreser(batch_x, w, b): 计算预测值，使用当前的权重和偏置进行预测。
loss = MSE(y_batch_pred, batch_y_true): 计算损失，使用均方误差衡量预测值和真实值之间的差异。
loss_e += loss: 累加损失，用于计算每轮的总损失。
count += 1: 计数批次数量，用于计算每轮的平均损失。
if w.grad is not None:: 检查权重w的梯度是否存在，确保梯度已经计算。
w.grad.zero_(): 清零权重w的梯度，避免梯度累积。
if b.grad is not None:: 检查偏置b的梯度是否存在，确保梯度已经计算。
b.grad.zero_(): 清零偏置b的梯度，避免梯度累积。
loss.backward(): 反向传播，计算梯度，用于更新模型参数。
optim_step(w, b, w.grad, b.grad, lr): 更新参数，沿着梯度下降的方向更新权重和偏置。
print(f'epoch:{i}, loss:{loss_e / count}'): 打印每轮的平均损失，用于监控训练过程。
return w, b, coef: 返回训练后的权重、偏置和真实系数，用于评估模型性能。