Pytorch实现线性回归模型

import torch
from sklearn.datasets import make_regression
import matplotlib.pyplot as plt
import random
def creat_data():
    x, y, coef = make_regression(n_samples=100, n_features=1, noise=10, coef=True, bias=14.5, random_state=0)
    # 所有的特征值X都是0,目标变量y的平均值也会是14.5（加上或减去由于noise参数引入的噪声）
    # coef：权重系数,表示线性回归模型中每个特征的权重,y_pred = x * coef + bias
    x = torch.tensor(x)
    y = torch.tensor(y)
    return x, y ,coef  # x , y 不是按顺序的, 而是随机顺序的
 
def data_loader(x, y, batch_size):
    data_len = len(y)
    data_index = list(range(data_len))
    random.shuffle(data_index)
    batch_number = data_len // batch_size
 
    for idx in range(batch_number):
        start = idx * batch_size
        end = start + batch_size
        batch_train_x = x[start: end]
        batch_train_y = y[start: end]
        yield batch_train_x, batch_train_y  # 相当于reutrn, 返回一个值,但是不会结束函数

# 假设函数
w = torch.tensor(0.1, requires_grad=True, dtype=torch.float64)
b = torch.tensor(0.0, requires_grad=True, dtype=torch.float64)
 
 
def linear_regression(x):
    return w * x + b
 
 
# 损失函数
def square_loss(y_pre, y_true):
    return (y_pre - y_true) ** 2
 
 
# 优化方法(梯度下降)
def sgd(lr=0.01):
    w.data = w.data - lr * w.grad.data / 16  # 批次样本的平均梯度值,梯度累积了16次
    b.data = b.data - lr * b.grad.data / 16

def train():
    # 加载数据集
    x, y, coef = creat_data()
    # 定义训练参数
    epochs = 100
    learning_rate = 0.01
    # 存储训练信息
    epochs_loss = []
    total_loss = 0.0
    train_samples = 0
 
    for _ in range(epochs):
        for train_x, train_y in data_loader(x, y, batch_size=16):
            y_pred = linear_regression(train_x)
            # 计算平方损失
            loss = square_loss(y_pred, train_y.reshape(-1, 1)).sum()  # 16个tensor(16行1列)
            # print(loss)
            total_loss += loss.item()
            train_samples += len(train_y)
 
            # 梯度清零
            if w.grad is not None:
                w.grad.data.zero_()
            if b.grad is not None:
                b.grad.data.zero_()
            # 自动微分
            loss.backward()  
 
            sgd(learning_rate)
            print('loss:%.10f' % (total_loss / train_samples))
        # 记录每一个epochs的平均损失
        epochs_loss.append(total_loss / train_samples)
    # 先绘制数据集散点图
    plt.scatter(x, y)
    # 绘制拟合的直线
    x = torch.linspace(x.min(), x.max(), 1000)
    y1 = torch.tensor([v * w + b for v in x])
    y2 = torch.tensor([v * coef + b for v in x])
    plt.plot(x, y1, label='训练')
    plt.plot(x, y2, label='真实')
    plt.grid()
    plt.legend()
    plt.show()
 
    # 打印损失变化曲线
    plt.plot(range(epochs), epochs_loss)
    plt.grid()
    plt.title('损失变化曲线')
    plt.show()
 
if __name__ == '__main__':
    train()

def test03():
 
    # y = x**2
    x = torch.tensor(10, requires_grad=True, dtype=torch.float64)
 
    for _ in range(500):
 
        # 正向计算
        f = x ** 2
        print(x.grad)
        # 梯度清零
        if x.grad is not None:
            x.grad.data.zero_()
 
        # 反向传播计算梯度
        f.backward()
 
        # 更新参数
        x.data = x.data - 0.01 * x.grad
 
        print('%.10f' % x.data)

from sklearn.linear_model import SGDRegressor

import torch
from torch.utils.data import TensorDataset
from torch.utils.data import DataLoader
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import make_regression
import matplotlib.pyplot as plt
 
 
def create_data():
 
    x, y, coef = make_regression(n_samples=100,
                                 n_features=1,
                                 noise=10,
                                 coef=True,
                                 bias=14.5,
                                 random_state=0)
 
    
    x = torch.tensor(x)
    y = torch.tensor(y)
 
    return x, y, coef
 
 
def train():
 
    
    x, y, coef = create_data()
    
    dataset = TensorDataset(x, y)
    # 数据加载器
    dataloader = DataLoader(dataset, batch_size=16, shuffle=True)
 
    model = nn.Linear(in_features=1, out_features=1)
    # 构建损失函数
    criterion = nn.MSELoss()
    # 优化方法
    optimizer = optim.SGD(model.parameters(), lr=1e-2)
    # 初始化训练参数
    epochs = 100
 
    for _ in range(epochs):
 
        for train_x, train_y in dataloader:
 
            
            y_pred = model(train_x.type(torch.float32))
            # 计算损失值
            loss = criterion(y_pred, train_y.reshape(-1, 1).type(torch.float32))
            # 梯度清零
            optimizer.zero_grad()
            # 自动微分(反向传播)
            loss.backward()
            # 更新参数
            optimizer.step()
 
 
    # 绘制拟合直线
    plt.scatter(x, y)
    x = torch.linspace(x.min(), x.max(), 1000)
    y1 = torch.tensor([v * model.weight + model.bias for v in x])
    y2 = torch.tensor([v * coef + 14.5 for v in x])
 
    plt.plot(x, y1, label='训练')
    plt.plot(x, y2, label='真实')
    plt.legend()
    plt.show()
 
 
if __name__ == '__main__':
    train()