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

python 复制代码
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库,用于张量操作和神经网络训练。

构建数据集

python 复制代码
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

构建数据加载器

python 复制代码
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生成一个生成器,用于按需加载数据。

构建模型函数

python 复制代码
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 : 返回预测值,使用矩阵乘法@计算xw的乘积,然后加上偏置b,实现线性回归模型.

构建损失函数

python 复制代码
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) : 返回预测值和真实值之间的均方误差,用于衡量模型的预测精度。

把参数初始化

python 复制代码
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: 返回初始化的权重和偏置。

构建梯度下降函数

python 复制代码
def optim_step(w,b,dw,db,lr):
#更新梯度,朝着梯度下降的方向去更新梯度
    w.data = w.data-lr*dw.data
    b.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控制更新的步长。

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

python 复制代码
def train():
    #生成数据
    x,y,coef = build_data()
    #初始化参数
    w,b = initialize(x.shape[1])
    #定义训练参数
    lr = 0.01
    epoch = 100
    for i in range(epoch):
        loss_e = 0
        count = 0
        for 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+=loss
            count+=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: 返回训练后的权重、偏置和真实系数,用于评估模型性能。

相关推荐
ONEYAC唯样4 分钟前
“在中国,为中国” 英飞凌汽车业务正式发布中国本土化战略
大数据·人工智能
mozun20209 分钟前
产业观察:哈工大机器人公司2025.4.22
大数据·人工智能·机器人·创业创新·哈尔滨·名校
-一杯为品-12 分钟前
【深度学习】#9 现代循环神经网络
人工智能·rnn·深度学习
硅谷秋水14 分钟前
ORION:通过视觉-语言指令动作生成的一个整体端到端自动驾驶框架
人工智能·深度学习·机器学习·计算机视觉·语言模型·自动驾驶
Java中文社群36 分钟前
最火向量数据库Milvus安装使用一条龙!
java·人工智能·后端
亿牛云爬虫专家43 分钟前
深度学习在DOM解析中的应用:自动识别页面关键内容区块
深度学习·爬虫代理·dom·性能·代理ip·内容区块·东方财富吧
豆芽81944 分钟前
强化学习(Reinforcement Learning, RL)和深度学习(Deep Learning, DL)
人工智能·深度学习·机器学习·强化学习
山北雨夜漫步1 小时前
机器学习 Day14 XGboost(极端梯度提升树)算法
人工智能·算法·机器学习
yzx9910131 小时前
集成学习实际案例
人工智能·机器学习·集成学习
CodeJourney.1 小时前
DeepSeek与WPS的动态数据可视化图表构建
数据库·人工智能·信息可视化