d2l_线性回归完整python程序

从零实现

import torch
import random

def synthetic_data(w, b, num_examples):
    """生成 y=Xw + b + 噪声"""
    X = torch.normal(0, 1, (num_examples, len(w))) # 正态分布（均值为0，标准差为1）
    y = torch.matmul(X, w) + b # 矩阵相乘
    y += torch.normal(0, 0.01, y.shape) # 加入噪声项
    # 得到的y为行向量的形式，为了使其变为一列的形式需要进行reshape
    return X, y.reshape((-1, 1))

def data_iter(batch_size, features, labels):
    num_examples = len(features)
    indices = list(range(num_examples))
    # 这些样本是随机读出的，没有特定的顺序
    random.shuffle(indices)
    for i in range(0, num_examples, batch_size):
        batch_indices = torch.tensor(indices[i:min(i+batch_size,num_examples)])
        yield features[batch_indices],labels[batch_indices]

def linear(X,w,b):
    """定义模型"""
    return torch.matmul(X,w)+b

def squared_loss(y_hat,y):
    return (y_hat-y.reshape(y_hat.shape))**2/2

def sgd(params, lr, batch_size):
    """小批量梯度下降"""
    with torch.no_grad():
        for param in params:  # 参数b和w
            param -= lr*param.grad/batch_size
            param.grad.zero_()

if __name__ == '__main__':

    true_w = torch.tensor([2, -3.4])
    true_b = 4.2
    features, labels = synthetic_data(true_w,true_b,1000) # 生成数据集
    # 初始化模型参数
    w = torch.normal(0,0.01,(2,1),requires_grad=True)
    b = torch.zeros(1,requires_grad=True)

    # 定义超参数
    lr = 0.03
    num_epochs = 3
    batch_size = 15
    net = linear
    loss = squared_loss

    for epoch in range(num_epochs):
        for X, y in data_iter(batch_size,features,labels):
            y_hat = linear(X,w,b)
            loss = squared_loss(y_hat,y)
            loss.sum().backward() # 进行反向传播得到梯度
            sgd((w,b),lr,batch_size)
        with torch.no_grad():
            train_l = squared_loss(net(features,w,b),labels)
            # print(train_l)
            print(f'epoch{epoch+1},loss{float(train_l.mean()):f}')


"""
output：
epoch1,loss0.362755
epoch2,loss0.008698
epoch3,loss0.000259
"""

简洁实现

import torch
from d2l import torch as d2l
from torch.utils import data
from torch import nn

def load_array(data_arrays, batch_size, is_train=True):
    """构建一个pytorch数据迭代器"""
    dataset = data.TensorDataset(*data_arrays)
    return data.DataLoader(dataset, batch_size, shuffle=is_train)

if __name__ == '__main__':

    true_w = torch.tensor([2, -3.4])
    true_b = 4.2
    features , labels = d2l.synthetic_data(true_w, true_b, 10000)
    batch_size = 10
    # 数据迭代器
    data_iter = load_array((features,labels),batch_size)
    print(next(iter(data_iter)))
    # 定义模型
    net = nn.Sequential(nn.Linear(2,1))
    # 初始化模型参数
    net[0].weight.data.normal_(0,0.01)
    net[0].bias.data.fill_(0)
    # 定义损失函数
    loss = nn.MSELoss()
    # 定义优化算法
    trainer = torch.optim.SGD(net.parameters(),0.03)
    # 模型训练
    num_epoch = 3
    for epoch in range(num_epoch):
        for X,y in data_iter:
            l = loss(net(X),y)
            trainer.zero_grad()
            l.backward()
            trainer.step() # 优化
        l = loss(net(features),labels)
        print(f'epoch{epoch+1},loss{l:f}')

    print(net[0].weight.data)

"""
output:
epoch1,loss0.000099
epoch2,loss0.000100
epoch3,loss0.000099
tensor([[ 1.9998, -3.4005]])
"""