????????本篇主要学习《动手学深度学习》第三章线性神经网络线性回归的实现。可以结合线性分类器学习笔记和《计算机视觉与深度学习》——线性分类器一起学习。
1 线性回归
1.1 从零开始实现
1. 导入需要的库
import random
import torch
from d2l import torch as d2l
2. 生成数据集
????????这里将根据带有噪声的线性模型构造?个?造数据集。我们的任务是使用这个有限样本的数据集来恢复这个模型的参数。我们将使?低维数据，这样可以很容易地将其可视化。在下?的代码中，我们?成?个包含1000个样本的数据集，每个样本包含从标准正态分布中采样的2个特征。我们的合成数据集是?个矩阵 X ∈ R 1000 × 2 X\in \mathbb{R}^{1000\times 2} X∈R1000×2。
????????我们使用线性模型参数
w
=
[
2
,
?
3.4
]
T
、
b
=
4.2
\pmb{w}=[2, -3.4]^T、b=4.2
www=[2,?3.4]T、b=4.2和噪声项
?
\epsilon
?生成数据集及其标签：
y
=
X
w
+
b
+
?
y=\pmb{Xw}+b+\epsilon
y=XwXwXw+b+?
????????这里可以将 ? \epsilon ?视为模型预测和标签时的潜在观测误差。在这?我们认为标准假设成?，即 ? \epsilon ?服从均值为0的正态分布。为了简化问题，我们将标准差设为0.01。下?的代码?成合成数据集。
# 合成数据集
def synthetic_data(w, b, num_examples):
"""生成y=Xw+b+?的数据"""
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)
????????注意，features中的每??都包含?个?维数据样本，labels中的每??都包含?维标签值（?个标量）。
print("features:", features[0], "\nlabel:", labels[0])
features: tensor([0.0555, 0.9877])
label: tensor([0.9647])
????????通过?成第?个特征features[:, 1]和labels的散点图，可以直观观察到两者之间的线性关系。
d2l.set_figsize()
d2l.plt.scatter(features[:, 1].detach().numpy(), labels.detach().numpy(), 1)
3. 读取数据集
????????训练模型时要对数据集进?遍历，每次抽取?小批量样本，并使?它们来更新我们的模型。由于这个过程是训练机器学习算法的基础，所以有必要定义?个函数，该函数能打乱数据集中的样本并以小批量?式获取数据。
在下?的代码中，我们定义?个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)]) # 考虑最后一组不够一个批量
yield features[batch_indices], labels[batch_indices] # 生成器
????????通常，我们利?GPU并?运算的优势，处理合理?小的“小批量”。每个样本都可以并?地进?模型计算，且每个样本损失函数的梯度也可以被并?计算。GPU可以在处理?百个样本时，所花费的时间不?处理?个样本时多太多。
????????读取第?个小批量数据样本并打印。每个批量的特征维度显?批量?小和输?特征数。同样的，批量的标签形状与batch_size相等。
batch_size = 10
for X, y in data_iter(batch_size, features, labels):
print(X, '\n', y)
break
????????当我们运?迭代时，我们会连续地获得不同的小批量，直?遍历完整个数据集。上?实现的迭代对于教学来说很好，但它的执?效率很低，可能会在实际问题上陷??烦。例如，它要求我们将所有数据加载到内存中，并执??量的随机内存访问。在深度学习框架中实现的内置迭代器效率要?得多，它可以处理存储在?件中的数据和数据流提供的数据。
4. 初始化模型参数
????????在我们开始?小批量随机梯度下降优化我们的模型参数之前，我们需要先有?些参数。在下?的代码中，我们通过从均值为0、标准差为0.01的正态分布中采样随机数来初始化权重，并将偏置初始化为0。
w = torch.normal(0, 0.01, size=(2, 1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)
????????在初始化参数之后，我们的任务是更新这些参数，直到这些参数?够拟合我们的数据。每次更新都需要计算损失函数关于模型参数的梯度。有了这个梯度，我们就可以向减小损失的?向更新每个参数
5. 定义模型
????????要计算线性模型的输出，我们只需计算输?特征 X \pmb{X} XXX和模型权重 w \pmb{w} www的矩阵-向量乘法后加上偏置 b b b。注意，上?的 X w \pmb{Xw} XwXwXw是?个向量，而 b b b是?个标量。这里会自动触发广播机制。
def linreg(X, w, b):
"""线性回归模型"""
return torch.matmul(X, w) + b
6. 定义损失函数
????????在我们开始考虑如何?模型拟合（fit）数据之前，我们需要确定?个拟合程度的度量。损失函数（loss function）能够量化?标的实际值与预测值之间的差距。通常我们会选择?负数作为损失，且数值越小表?损失越小，完美预测时的损失为0。回归问题中最常?的损失函数是平?误差函数。当样本
i
i
i的预测值为
y
^
(
i
)
\hat{y}^{(i)}
y^?(i)，其相应的真实标签为
y
(
i
)
y^{(i)}
y(i)时，平?误差可以定义为以下公式：
l
(
i
)
(
w
,
b
)
=
1
2
(
y
^
(
i
)
?
y
(
i
)
)
2
l^{(i)}(\pmb{w}, b)=\frac{1}{2}(\hat{y}^{(i)}-{y}^{(i)})^2
l(i)(www,b)=21?(y^?(i)?y(i))2
????????常数
1
2
\frac{1}{2}
21?不会带来本质的差别，但这样在形式上稍微简单?些（因为当我们对损失函数求导后常数系数为1)。
def squared_loss(y_hat, y):
"""均方损失"""
return (y_hat - y) ** 2 /2
7. 定义优化算法
????????在每?步中，使?从数据集中随机抽取的?个小批量，然后根据参数计算损失的梯度。接下来，朝着减少损失的?向更新我们的参数。下?的函数实现小批量随机梯度下降更新。该函数接受模型参数集合、学习速率和批量?小作为输?。每?步更新的?小由学习速率lr决定。因为我们计算的损失是?个批量样本的总和，所以我们?批量?小（batch_size）来规范化步?，这样步??小就不会取决于我们对批量?小的选择。
def sgd(params, lr, batch_size):
"""小批量随机梯度下降"""
with torch.no_grad():
for param in params:
param -= lr * param.grad / batch_size
param.grad.zero_()
8. 训练
????????选练过成为：在每次迭代中，我们读取?小批量训练样本，并通过我们的模型来获得?组预测。计算完损失后，我们开始反向传播，存储每个参数的梯度。最后，我们调?优化算法sgd来更新模型参数。循环过程如下：
- 初始化参数
- 重复以下训练，直到完成
- 计算梯度 g ← ? ( w , b ) 1 ∣ B ∣ ∑ i ∈ B l ( x ( i ) , y ( i ) , w , b ) \mathbf{g} \leftarrow \partial_{(\mathbf{w}, b)} \frac{1}{|\mathcal{B}|} \sum_{i \in \mathcal{B}} l\left(\mathbf{x}^{(i)}, y^{(i)}, \mathbf{w}, b\right) g←?(w,b)?∣B∣1?i∈B∑?l(x(i),y(i),w,b)
- 更新参数 ( w , b ) ← ( w , b ) ? η g (\pmb{w}, b) \leftarrow (\pmb{w}, b) - \eta \mathbf{g} (www,b)←(www,b)?ηg
????????在每个迭代周期（epoch）中，我们使?data_iter函数遍历整个数据集，并将训练数据集中所有样本都使??次（假设样本数能够被批量?小整除）。这?的迭代周期个数num_epochs和学习率lr都是超参数，分别设为3和0.03。设置超参数很棘?，需要通过反复试验进?调整。
lr = 0.03 # 学习率
num_epoches = 3 # 迭代次数
net = linreg # 模型
loss = squared_loss # 损失
for epoch in range(num_epoches):
for X, y in data_iter(batch_size, features, labels):
l = loss(net(X, w, b), y) # X和y的小批量损失
# l的形状是(batch_size, 1)，而不是一个标量，l中所有的元素被加到一起
l.sum().backward() # 计算关于[w, b]的梯度
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}')
epoch 1, loss 0.042979
epoch 2, loss 0.000169
epoch 3, loss 0.000052
????????我们可以通过?较真实参数和通过训练学到的参数来评估训练的成功程度。
print(f'w的估计误差：{true_w-w.reshape(true_w.shape)}')
print(f'b的估计误差：{true_b-b}')
w的估计误差：tensor([ 1.5374e-03, -1.6689e-06], grad_fn=)
b的估计误差：tensor([0.0009], grad_fn=)
????????温馨提示： 在机器学习中，我们通常不太关?恢复真正的参数，而更关?如何?度准确预测参数。幸运的是，即使是在复杂的优化问题上，随机梯度下降通常也能找到?常好的解。其中?个原因是，在深度?络中存在许多参数组合能够实现?度精确的预测。
1.2 简洁实现
1. 生成数据集
import numpy as np
import torch
from torch.utils import data
from d2l import torch as d2l
true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = d2l.synthetic_data(true_w, true_b, 1000)
2. 读取数据集
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)
batch_size = 20
data_iter = load_array((features, labels), batch_size)
next(iter(data_iter))
3. 定义模型
????????在PyTorch中，全连接层在Linear类中定义。值得注意的是，我们将两个参数传递到nn.Linear中。第?个指定输?特征形状，即2，第?个指定输出特征形状，输出特征形状为单个标量，因此为1。
from torch import nn
net = nn.Sequential(nn.Linear(2, 1))
4. 初始化模型参数
????????通过net[0]选择?络中的第?个图层，然后使?weight.data和bias.data?法访问参数。我们还可以使?替换?法normal_和fill_来重写参数值。
net[0].weight.data.normal_(0, 0.1)
net[0].bias.data.fill_(0)
5. 定义损失函数
????????计算均?误差使?的是MSELoss类，也称为平?L2范数。默认情况下，它返回所有样本损失的平均值。
criterion = nn.MSELoss()
6. 定义优化算法
????????小批量随机梯度下降算法是?种优化神经?络的标准?具，PyTorch在optim模块中实现了该算法的许多变种。当我们实例化?个SGD实例时，我们要指定优化的参数（可通过net.parameters()从我们的模型中获得）以及优化算法所需的超参数字典。小批量随机梯度下降只需要设置lr值，这?设置为0.03。
optimizer = torch.optim.SGD(net.parameters(), lr=0.03)
7. 训练
????????在每个迭代周期?，我们将完整遍历一次数据集（train_data），不停地从中获取一个小批量的输?和相应的标签。对于每?个小批量，我们会进?以下步骤:
? 通过调?net(X)?成预测并计算损失loss（前向传播）。
? 通过进?反向传播来计算梯度。
? 通过调?优化器来更新模型参数
num_epochs = 3
for epoch in range(num_epochs):
for X, y in data_iter:
# forwad
output = net(X)
loss = criterion(output, y)
# backward
optimizer.zero_grad()
loss.backward()
optimizer.step()
l = criterion(net(features), labels)
print(f'epoch {epoch+1}, loss {l:f}')
epoch 1, loss 0.075949
epoch 2, loss 0.000290
epoch 3, loss 0.000103
????????下?我们?较?成数据集的真实参数和通过有限数据训练获得的模型参数。要访问参数，我们?先从net访问所需的层，然后读取该层的权重和偏置。正如在从零开始实现中?样，我们估计得到的参数与?成数据的真实参数?常接近。
w = net[0].weight.data
print('w的估计误差：', true_w-w.reshape(true_w.shape))
b = net[0].bias.data
print('b的估计误差：', true_b-b)
w的估计误差： tensor([ 8.4531e-04, -4.3392e-05])
b的估计误差： tensor([0.0007])
2 softmax回归
2.1 数据集
1. 导入库
????????MNIST数据集是图像分类中?泛使?的数据集之?，但作为基准数据集过于简单。我们将使?类似但更复杂的Fashion-MNIST数据集。
import torch
from torchvision import datasets
from torch.utils import data
from torchvision import transforms
from d2l import torch as d2l
import numpy as np
import gzip
2. 读取数据集
????????我们可以通过框架中的内置函数将Fashion-MNIST数据集下载并读取到内存中。
# 读取数据集，在线下载
mnist_train = datasets.FashionMNIST(root="../data", train=True, transform=transforms.ToTensor(), download=True)
mnist_test = datasets.FashionMNIST(root="../data", train=False, transform=transforms.ToTensor(), download=True)
print(len(mnist_train, mnist_test)) # （60000， 10000）
????????有的小伙伴觉得本地下载太慢，或者老是失败，那我们可以直接下载到本地，然后自己导入数据集，如下：
class FashionMnistDataset(data.Dataset):
"""读取数据、初始化数据"""
def __init__(self, folder, data_name, label_name, transform=None):
(train_set, train_labels) = load_data(folder, data_name, label_name)
self.train_set = train_set
self.train_labels = train_labels
self.transform = transform
def __getitem__(self, index):
img, target = self.train_set[index], int(self.train_labels[index])
if self.transform is not None:
img = self.transform(img)
return img, target
def __len__(self):
return len(self.train_set)
def load_data(data_folder, data_name, label_name):
with gzip.open(os.path.join(data_folder, label_name), 'rb') as labpath:
y_train = np.frombuffer(labpath.read(), np.uint8, offset=8)
with gzip.open(os.path.join(data_folder, data_name), 'rb') as imgpath:
x_train = np.frombuffer(imgpath.read(), np.uint8, offset=16).reshape(len(y_train), 28, 28)
return (x_train, y_train)
# 通过ToTensor实例将图像数据从PIL类型变换成32位浮点数格式，
# 并除以255使得所有像素的数值均在0到1之间
mnist_train = FashionMnistDataset("../data/FashionMNIST", "train-images-idx3-ubyte.gz", "train-labels-idx1-ubyte.gz", transform=transforms.ToTensor())
mnist_test = FashionMnistDataset("../data/FashionMNIST", "t10k-images-idx3-ubyte.gz", "t10k-labels-idx1-ubyte.gz", transform=transforms.ToTensor())
print(len(mnist_train), len(mnist_test))
????????Fashion-MNIST由10个类别的图像组成，每个类别由训练数据集（train dataset）中的6000张图像和测试数据集（test dataset）中的1000张图像组成。因此，训练集和测试集分别包含60000和10000张图像。测试数据集不会?于训练，只?于评估模型性能。
????????每个输?图像的?度和宽度均为28像素。数据集由灰度图像组成，其通道数为1。
print(mnist_train[0][0].shape) # torch.Size([1, 28, 28])
????????Fashion-MNIST中包含的10个类别，分别为t-shirt（T恤）、trouser（裤?）、pullover（套衫）、dress（连?裙）、coat（外套）、sandal（凉鞋）、shirt（衬衫）、sneaker（运动鞋）、bag（包）和ankle boot（短靴）。以下函数?于在数字标签索引及其?本名称之间进?转换。
def get_fashion_mnist_labels(labels):
"""返回Fashion-MNIST数据集的文本标签"""
text_labels =['t-shirt', 'trouser', 'pullover', 'dress', 'coat', 'sandal', 'shirt', 'sneaker', 'bag', 'ankle boot']
return [text_labels[int(i)] for i in labels] # 标签是浮点型的
????????下面创建一个函数可视化这些样本。
def show_images(imgs, num_rows, num_cols, titles=None, scale=1.5):
"""绘制图像列表"""
figsize = (num_cols * scale, num_rows * scale)
_, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize)
axes = axes.flatten() # 将axes由n*m的Axes组展平成1*nm的Axes组
for i, (ax, img) in enumerate(zip(axes, imgs)):
if torch.is_tensor(img): # 图片张量
ax.imshow(img.numpy())
else: # PIL图片
ax.imshow(img)
ax.axes.get_xaxis().set_visible(False) # 不需要坐标轴
ax.axes.get_yaxis().set_visible(False)
if titles:
ax.set_title(titles[i])
return axes
????????以下是训练数据集中前?个样本的图像及其相应的标签。
X, y = next(iter(data.DataLoader(mnist_train, batch_size=20)))
show_images(X.reshape(20, 28, 28), 2, 10, titles=get_fashion_mnist_labels(y)) # 由[20, 1, 28, 28]转换为[20, 28, 28]
3. 读取小批量
train_loader = data.DataLoader(mnist_train, batch_size=256, shuffle=True, num_workers=4)
test_loader = data.DataLoader(mnist_test, batch_size=256, shuffle=True, num_workers=4)
timer = d2l.Timer()
for X, y in train_loader:
continue
print(f'{timer.stop():.2f} sec') # 0.66 sec
2.2 从零实现
1. 初始化模型参数
????????和之前线性回归的例??样，这?的每个样本都将?固定?度的向量表?。原始数据集中的每个样本都是28×28的图像。在本节中，我们将展平每个图像，把它们看作?度为784的向量。
????????在softmax回归中，我们的输出与类别?样多。因为我们的数据集有10个类别，所以?络输出维度为10。因此，权重将构成?个784×10的矩阵，偏置将构成?个1×10的?向量。与线性回归?样，我们将使?正态分布初始化我们的权重 W \pmb{W} WWW，偏置初始化为0。
# 初始化模型参数
num_inputs = 784
num_outputs = 10
W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)
b = torch.zeros(num_outputs, requires_grad=True)
2. 定义softmax操作
????????实现softmax由三个步骤组成：（1）对每个项求幂（使?exp）；（2）对每??求和（小批量中每个样本是??），得到每个样本的规范化常数；（3）将每??除以其规范化常数，确保结果的和为1。表达式如下：
softmax
?
(
X
)
i
j
=
exp
?
(
X
i
j
)
∑
k
exp
?
(
X
i
k
)
\operatorname{softmax}(\mathbf{X})_{i j}=\frac{\exp \left(\mathbf{X}_{i j}\right)}{\sum_{k} \exp \left(\mathbf{X}_{i k}\right)}
softmax(X)ij?=∑k?exp(Xik?)exp(Xij?)?
def softmax(X):
X_exp = torch.exp(X)
partition = X_exp.sum(1, keepdim=True)
return X_exp / partition # 触发广播机制
3. 定义模型
????????下?的代码定义了输?如何通过?络映射到输出。注意，将数据传递到模型之前，我们使?reshape函数将每张原始图像展平为向量。
def net(X):
return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)
4. 定义损失函数
# 交叉熵损失
def cross_entropy(y_hat, y):
return -torch.log(y_hat[range(len(y_hat)), y])
5. 分类精度
????????为了计算精度，我们执?以下操作。?先，如果y_hat是矩阵，那么假定第?个维度存储每个类的预测分数。我们使?argmax获得每?中最?元素的索引来获得预测类别。然后我们将预测类别与真实y元素进??较。由于等式运算符“==”对数据类型很敏感，因此我们将y_hat的数据类型转换为与y的数据类型?致。结果是?个包含0（错）和1（对）的张量。最后，我们求和会得到正确预测的数量。
def accuracy(y_hat, y):
"""计算预测正确的数量"""
if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
y_hat = y_hat.argmax(axis=1)
cmp = y_hat.type(y.dtype) == y # 讲y_hat的类型抓换位和y一样
return float(cmp.type(y.dtype).sum())
对于任意数据迭代器data_iter可访问的数据集，我们可以评估在任意模型net的精度。
def evaluate_accuracy(net, data_iter):
"""计算在指定数据集上模型的精度"""
if isinstance(net, torch.nn.Module):
net.eval() # 将模型设置为评估模式
metric = Accumulator(2)
with torch.no_grad():
for X, y in data_iter:
metric.add(accuracy(net(X), y), y.numel())
return metric[0] / metric[1]
????????这?定义?个实?程序类Accumulator，?于对多个变量进?累加。在上?的evaluate_accuracy函数中，我们在Accumulator实例中创建了2个变量，分别?于存储正确预测的数量和预测的总数量。当我们遍历数据集时，两者都将随着时间的推移而累加。
class Accumulator:
"""在n个变量上累加"""
def __init__(self, n):
self.data = [0.0] * n
def add(self, *args):
self.data = [a + float(b) for a, b in zip(self.data, args)]
def reset(self):
self.data = [0.0] * len(self.data)
def __getitem__(self, idx):
return self.data[idx]
6. 训练
?????????先，我们定义?个函数来训练?个迭代周期。请注意，updater是更新模型参数的常?函数，它接受批量?小作为参数。它可以是d2l.sgd函数，也可以是框架的内置优化函数。
def train_epoch_ch3(net, train_loader, loss, updater):
"""训练模型一个迭代周期"""
if isinstance(net, torch.nn.Module):
net.train()
# 训练损失总和、训练准确度总和、样本数
metric = Accumulator(3)
for X, y in train_loader:
# 计算梯度并更新参数
y_hat = net(X)
l = loss(y_hat, y)
if isinstance(updater, torch.optim.Optimizer):
# 使用PyTorch内置的优化器和损失函数
updater.zero_grad()
l.sum().backward()
updater.step()
else:
# 使用定制的优化器和损失函数
l.sum().backward()
updater(X.shape[0])
metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
# 返回训练损失和训练精度
return metric[0] / metric[2], metric[1] / metric[2]
????????在展?训练函数的实现之前，我们定义?个在动画中绘制数据的实?程序类Animator。
# from IPython import display
class Animator:
"""在动画中绘制数据"""
def __init__(self, xlabel=None, ylabel=None, legend=None, xlim=None, ylim=None, xscale='linear', yscale='linear', fmts=('-', 'm--', 'g-.', 'r:'), nrows=1, ncols=1, figsize=(3.5, 2.5)):
# 增量地绘制多条线
if legend is None:
legend = []
d2l.use_svg_display()
self.fig, self.axes = d2l.plt.subplots(nrows, ncols, figsize=figsize)
if nrows * ncols == 1:
self.axes = [self.axes, ]
# 使用lambda函数捕获参数
self.config_axes = lambda: d2l.set_axes(self.axes[0], xlabel, ylabel, xlim, ylim, xscale, yscale, legend)
self.X, self.Y, self.fmts = None, None, fmts
def add(self, x, y):
"""向图表中添加多个数据点"""
if not hasattr(y, "__len__"):
y = [y]
n = len(y)
if not hasattr(x, "__len__"):
x = [x] * n
if not self.X:
self.X = [[] for _ in range(n)]
if not self.Y:
self.Y = [[] for _ in range(n)]
for i, (a, b) in enumerate(zip(x, y)):
if a is not None and b is not None:
self.X[i].append(a)
self.Y[i].append(b)
self.axes[0].cla()
for x, y, fmt in zip(self.X, self.Y, self.fmts):
self.axes[0].plot(x, y, fmt)
self.config_axes()
# display.display(self.fig)
# display.clear_output(wait=True)
????????下来我们实现?个训练函数，它会在train_iter访问到的训练数据集上训练?个模型net。该训练函数将会运?多个迭代周期（由num_epochs指定）。在每个迭代周期结束时，利?test_loader访问到的测试数据集对模型进?评估。我们将利?Animator类来可视化训练进度。
def train_ch3(net, train_loader, test_loader, loss, num_epoches, updater):
"""训练模型"""
animator = Animator(xlabel='epoch', xlim=[1, num_epoches], ylim=[0.3, 0.9], legend=['train loss', 'train acc', 'test acc'])
for epoch in range(num_epoches):
train_metrics = train_epoch_ch3(net, train_loader, loss, updater)
test_acc = evaluate_accuracy(net, test_loader)
animator.add(epoch+1, train_metrics + (test_acc,))
train_loss, train_acc = train_metrics
assert train_loss < 0.5, train_loss
assert train_acc <= 1 and train_acc > 0.7, train_acc
assert test_acc <= 1 and test_acc > 0.7, test_acc
????????现在，我们使用小批量梯度下降法来优化模型损失函数，设置学习率为0.1，训练模型10个迭代周期。请注意，迭代周期（num_epochs）和学习率（lr）都是可调节的超参数。通过更改它们的值，我们可以提?模型的分类精度。
lr = 0.1
def updater(batch_size):
return d2l.sgd([W, b], lr, batch_size)
num_epoches = 10
train_ch3(net, train_loader, test_loader, cross_entropy, num_epoches, updater)
7. 预测
????????现在训练已经完成，我们的模型已经准备好对图像进?分类预测。给定?系列图像，我们将?较它们的实际标签（?本输出的第??）和模型预测（?本输出的第??）。
def predict_ch3(net, test_loader, n=6):
"""预测标签"""
for X, y in test_loader:
break
trues = d2l.get_fashion_mnist_labels(y)
preds = d2l.get_fashion_mnist_labels(net(X).argmax(axis=1))
titles = [true+'\n' + pred for true, pred in zip(trues, preds)]
d2l.show_images(X[0:n].reshape((n, 28, 28)), 1, n, titles=titles[0:n])
predict_ch3(net, test_loader)
2.2 简洁实现
import torch
from torch import nn
from d2l import torch as d2l
batch_size = 256
# 在线性层前定义了展平层（flatten），来调整?络输?的形状
net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))
def init_weights(m):
if isinstance(m, nn.Linear):
nn.init.normal_(m.weight, std=0.01)
net.apply(init_weights)
loss = nn.CrossEntropyLoss() # 损失函数
optimizer = torch.optim.SGD(net.parameters(), lr=0.1) # 优化算法
num_epoches = 10
d2l.train_ch3(net, train_loader, test_loader, loss, num_epoches, optimizer)
