李沐老师 PyTorch版——线性回归 + 基础优化算法（2）

---

torch.utils.data.TensorDataset

TensorDataset文档

torch.utils.data.TensorDataset(*tensors)
通过沿数据的第一维来索引每一样本、构成一个样本对。这就要求参数具有相同的第一维维数。

torch.utils.data.DataLoader

DataLoader文档

torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=None, sampler=None, batch_sampler=None, num_workers=0, collate_fn=None, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, multiprocessing_context=None, generator=None, *, prefetch_factor=2, persistent_workers=False, pin_memory_device=‘’)

• batch_size (int, optional) ：每一个 batch 读取的样本数，默认是 1 个样本
• shuffle (bool, optional) ：在一个 epoch 迭代中，打乱所有的样本顺序，默认是 False.
• num_workers (int, optional) ：加载数据使用的子进程数量，0 意味着数据将通过主进程加载，默认数量是 0.

torch.nn.Sequential

Sequential文档

torch.nn.Sequential(*args)
Sequential 是一个顺序容器，每一个添加到 Sequential 容器的神经网络层是有先后次序的。一个模型的输出是下一个模型的输入，像一个链子一样向前计算传播。

# Using Sequential to create a small model. When `model` is run,
# input will first be passed to `Conv2d(1,20,5)`. The output of
# `Conv2d(1,20,5)` will be used as the input to the first
# `ReLU`; the output of the first `ReLU` will become the input
# for `Conv2d(20,64,5)`. Finally, the output of
# `Conv2d(20,64,5)` will be used as input to the second `ReLU`
model = nn.Sequential(
          nn.Conv2d(1,20,5),
          nn.ReLU(),
          nn.Conv2d(20,64,5),
          nn.ReLU()
        )

torch.nn.Linear

Linear文档

torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None)
Linear 层对输入的数据进行一个线性变化：$y=x{A}^T+b$

Parameters

• in_features – 每一个输入样本的尺寸
• out_features – 每一个输出样本的尺寸
• bias – 默认为 True，相当于线性变换存在一个偏差项。可以设置为 False，那样将没有 b 的偏差项。

Shape

• 模型的输入样本形状 Input：$(\ast ,H_{in})$，$\ast$ 代表输入数据的任何数据维度，包括输入数据可以是一个向量。$H_{in}=in\_features$
• 模型的输出样本形状 Output：$(\ast ,H_{out})$，其中 $H_{out}=out\_features$

Variables

• Linear.weight - 模型的一个形状为 $(out\_features,in\_features)$ 的权重参数，它是可以学习的。
• Linear.bias - 模型的一个形状为 $out\_features$ 的偏置，它是可以学习的。

>>> from torch import nn
>>> a = nn.Linear(20,100)
>>> b = torch.randn(66,20)
>>> a(b).shape
torch.Size([66, 100])

torch.nn.MSELoss

MSELoss文档

torch.nn.MSELoss(size_average=None, reduce=None, reduction=‘mean’)
定义了一个度量输入元素 x 和目标 y 之间的差距的 $L2$ 均方差标准。x 和 y 都是任意形状的 tensor 张量，但是两者的元素总数分别应该是 n。

• reduction = ‘none’ 计算结果是一个向量 $\ell (x,y)=L={\left\{l_1,\dots ,l_N\right\}}^{\top },l_n={\left(x_n-y_n\right)}^2$
• reduction = ‘sum’ 计算结果是一个标量 $\ell (x,y)=L=sum(L)$
• reduction = ‘mean’ 计算结果同样是一个标量，是 sum 求和计算后取平均值除以 batch_size $\ell (x,y)=L=mean(L)$

>>> input = torch.randn(5,5,requires_grad=True)
>>> target = torch.randn(5,5)
>>> loss = nn.MSELoss()
>>> output = loss(input,target)
>>> output
tensor(2.9564, grad_fn=<MseLossBackward0>)

torch.optim

torch.optim 是一个已经实现了大多数优化算法的包，并且支持许多普遍被使用的优化方法。使用这个包需要我们首先构造一个优化对象，这个对象保存着目前的状态，并且会基于计算出的梯度更新参数。

构造一个 Optimizer ，必须给它一个包含 Variable 要优化的参数的可迭代对象。然后，可以指定优化器特定的选项，例如学习率、权重衰减等。

optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
optimizer = optim.Adam([var1, var2], lr=0.0001)

所有的 optimizer 都实现了一个 step() 方法，该方法用于更新参数。使用方法如下：

optimizer.step()

linear-regression-concise

torch.utils包处理数据

在上一篇文章我们介绍了怎么生成样本数据，在本节我们就使用 d2l 包中封装好的函数直接调用，然后使用 torch 中 torch.utils 中的数据处理方法进行加载。

def load_array(data_arrays, batch_size, is_train=True):
    """构造一个PyTorch数据迭代器"""
    # 将 data_array 解包传入进行数据对应
    # 使用 DataLoader 返回 batch_size 个样本的小批量，同时将数据顺序打乱
    # * 代表将参数
    dataset = data.TensorDataset(*data_arrays)
    return data.DataLoader(dataset, batch_size=batch_size, shuffle=is_train)

读取数据进行测试

batch_size = 10
data_iter = load_array((features, labels), batch_size)
print(next(iter(data_iter)))

定义模型

我们使用 Sequential 序列模型，模型中只包括一个 Linear 线性层。随后对 net 网络中的参数进行初始化。

net = nn.Sequential(
    nn.Linear(2, 1)
)
# 设置 net 的参数
net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)

定义损失函数、优化函数

loss = nn.MSELoss()
trainer = torch.optim.SGD(net.parameters(),0.01)

进行训练

num_epochs = 3
for epoch in range(num_epochs):
    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:6f}')