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.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控制更新的步长。

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

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: 返回训练后的权重、偏置和真实系数，用于评估模型性能。