线性回归+基础优化算法

案例代码用法

torch.tensor(data, dtype=None, device=None, requires_grad=False)
# data：表示要转换为张量的数据。可以是列表、NumPy 数组、标量值或其他可转换为张量的对象。
# dtype：可选参数，用于指定输出张量的数据类型。如果不指定，则会自动推断数据类型。
# device：可选参数，用于指定输出张量所在的设备。默认为 None，表示使用默认设备（通常是 CPU）。
# requires_grad：可选参数，表示是否需要计算梯度。默认为 False，表示不计算梯度。

torch.normal(mean, std, size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
# mean：表示正态分布的均值。
# std：表示正态分布的标准差。
# size：表示输出张量的大小。
# out：可选参数，用于指定输出张量。
# dtype：可选参数，用于指定输出张量的数据类型。
# layout：可选参数，用于指定输出张量的布局。
# device：可选参数，用于指定输出张量所在的设备。
# requires_grad：可选参数，表示是否需要计算梯度。

torch.matmul(input, other, out=None)
# input：表示第一个输入张量，可以是一个具有至少两个维度的张量。
# other：表示第二个输入张量，也可以是一个具有至少两个维度的张量。
# out：可选参数，表示输出张量。如果指定了 out，则结果将被写入到该张量中。如果未指定 out，则会创建一个新的张量来保存结果。

d2l.set_figsize() #是 Deep Learning - The Straight Dope（D2L）教材中提供的一个辅助函数，用于设置绘图的图像尺寸。

def load_array(data_arrays, batch_size, is_train=True):
    # data_arrays：一个包含输入特征    X    和对应标签    y    的列表或元组。通过解包    data_arrays，将其中的元素作为参数传递给    TensorDataset    类，构建一个数据集。
    # batch_size：整数值，指定每个批次的样本数量。
    # is_train：一个布尔值，指示是否在训练模式下，默认为    True。


dataloader = data.DataLoader(dataset, batch_size=32, shuffle=True, num_workers=4)
    # dataset：数据集，可以是 TensorDataset 或其他自定义的数据集类。数据集中包含了训练样本的特征和标签。
    # batch_size：一个整数，表示每个批次(batch)中包含的样本数量。
    # shuffle：一个布尔值，指示是否在每个迭代周期中打乱数据顺序。
    # num_workers：一个整数，表示用于加载数据的子进程数量。

net[0]是模型中的第一个全连接层。.weight.data用于访问全连接层的权重参数，并使其正态分布地初始化。

线性回归

import random
import torch
from d2l import torch as d2l


def synthetic_data(w, b, num_examples):
    """"生成 y = Xw + b + 噪声"""

    # 第一个参数 0 表示正态分布的均值。
    # 第二个参数 1 表示正态分布的标准差（方差的平方根）。
    # 第三个参数 (num_examples, len(w)) 表示输出张量的形状，其中 num_examples 是例子的数量，len(w) 是 w 向量的长度。
    X = torch.normal(0, 1, (num_examples, len(w)))
    y = torch.matmul(X, w) + b
    y += torch.normal(0, 0.01, y.shape)
    return X, y.reshape((-1, 1))


true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)

print("features.shape:", features.shape)
print("labels.shape:", labels.shape)

d2l.set_figsize()

# features[:,1]表示选择 features 张量的第二列数据
#    .detach().numpy() 将其转换为 NumPy 数组
d2l.plt.scatter(features[:, 1].detach().numpy(), labels.detach().numpy(), 1)
# d2l.plt.show()


# data_iter函数接收批量大小、特征矩阵和标签向量作为输入，生成大小为batch_size的小批量
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)])  # 当i+batch_size超出时，取num_examples
        yield features[batch_indices], labels[batch_indices]  # 它会在迭代过程中依次生成值，而不是一次性返回所有值。


batch_size = 10
for X, y in data_iter(batch_size, features, labels):
    # print(X, '\n', y)
    break

w = torch.normal(0, 0.01, size=(2, 1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)


def linreg(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:
            param -= lr * param.grad / batch_size
            param.grad.zero_()


lr = 0.03
num_epochs = 3
net = linreg
loss = squared_loss
# 训练过程
for epoch in range(num_epochs):
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y)  # x和y的小批量损失
        l.sum().backward()  # 反向传播，计算梯度
        sgd([w, b], lr, batch_size)  # 使用参数的梯度更新参数
    with torch.no_grad():
        train_l = loss(net(features, w, b), labels)
        print(f'epoch{epoch + 1}, loss{float(train_l.mean()):f}')

print(f'w的估计误差: {true_w - w.reshape(true_w.shape)}')
print(f'b的估计误差: {true_b - b}')

代码优化

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

true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = d2l.synthetic_data(true_w, true_b, 1000)  # 生成人工数据集


def load_array(data_arrays, batch_size, is_train=True):
    """构造一个pytorch数据迭代器"""

    #*data_arrays 表示将 data_arrays 中的元素解包，并作为参数传递给 TensorDataset 类
    dataset = data.TensorDataset(*data_arrays)

    #使用 DataLoader 创建一个数据加载器，用于从数据集中随机选择批次大小的样本。
    return data.DataLoader(dataset,batch_size,shuffle=is_train)#返回的是从dataset中随机挑选出batch_size个样本出来


batch_size = 10
data_iter = load_array((features,labels),batch_size)# 返回的数据的迭代器
print(next(iter(data_iter)))
# 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)# 初始化第一个全连接层的偏置为0

loss = nn.MSELoss()

trainer= torch.optim.SGD(net.parameters(),lr=0.03)

num_epochs = 3
for epoch in range(num_epochs):
    for X,y in data_iter:
        # print("X:",X)
        # print("y:",y)
        l = loss(net(X),y)# net(X) 为计算出来的线性回归的预测值
        trainer.zero_grad()# 梯度清零
        l.backward()
        trainer.step()# SGD优化器优化模型

    l = loss(net(features),labels)
    print(f'epoch{epoch+1},loss{l:f}')

跟学：B站李沐《动手学深度学习》

资源来源：B站小王同学在积累