注意：
把每个像素位置看作⼀个特征
# 导入PyTorch库
import torch
# 从IPython库中导入display模块，用于在交互式环境中显示内容
from IPython import display
# 从d2l.torch模块中导入torch作为d2l的别名，方便后续使用d2l库中的功能
from d2l import torch as d2l
# 定义批次大小
batch_size = 256
# 使用d2l库中的load_data_fashion_mnist函数加载Fashion-MNIST数据集
# 并将返回的训练数据迭代器和测试数据迭代器分别赋值给train_iter和test_iter
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
1、初始化模型参数
分析：前面弄成只有两层，第一层是特征，第二程是输出的类别，前面移动有10类，所以输出层弄成了10，按照这样的道理请问现在对于该任务的网络层数该如何设置呢？
答：现在图像是28*28，每一个像素看做一个特征，那么第一层就是28乘以28，第二层是10个种类，所以为10
# 定义输入特征的维度
num_inputs = 784
# 定义输出类别的数量
num_outputs = 10
# 使用torch.normal函数创建一个大小为(num_inputs, num_outputs)的张量W
# 张量的值从均值为0，标准差为0.01的正态分布中随机采样，并且需要计算梯度
W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)
# 使用torch.zeros函数创建一个大小为num_outputs的张量b
# 张量的值全部初始化为0，并且需要计算梯度
b = torch.zeros(num_outputs, requires_grad=True)
def softmax(X):
"""
执行softmax操作，将输入张量X的每个元素进行指数运算并进行归一化
参数:
X: 输入张量
返回:
归一化后的张量，与输入X的形状相同
"""
# 使用torch.exp函数计算输入张量X的每个元素的指数值
X_exp = torch.exp(X)
# 使用.sum函数计算每行元素的和，并保持维度
partition = X_exp.sum(1, keepdim=True)
# 将每个元素的指数值除以对应行的和，实现归一化操作
# 通过广播机制，使得每一行的元素都除以对应行的和
return X_exp / partition
2、定义softmax—没看懂
def softmax(X):
"""
执行softmax操作，将输入张量X的每个元素进行指数运算并进行归一化
参数:
X: 输入张量
返回:
归一化后的张量，与输入X的形状相同
"""
# 使用torch.exp函数计算输入张量X的每个元素的指数值
X_exp = torch.exp(X)
# 使用.sum函数计算每行元素的和，并保持维度
partition = X_exp.sum(1, keepdim=True)
# 将每个元素的指数值除以对应行的和，实现归一化操作
# 通过广播机制，使得每一行的元素都除以对应行的和
return X_exp / partition
# 使用torch.normal函数创建一个大小为(2, 5)的张量X
# 张量的值从均值为0，标准差为1的正态分布中随机采样
X = torch.normal(0, 1, (2, 5))
# 使用定义的softmax函数对张量X进行softmax操作
X_prob = softmax(X)
# 输出经过softmax操作后的张量X_prob，以及每行元素的和（归一化后的概率之和）
X_prob, X_prob.sum(1)
3、定义模型
**def net(X):
"""
定义一个简单的神经网络模型，接受输入X并输出预测结果
参数:
X: 输入特征张量
返回:
经过模型处理后的预测结果
"""
# 将输入特征X进行形状变换，展平并与权重矩阵W相乘，然后加上偏置向量b
linear_output = torch.matmul(X.reshape((-1, W.shape[0])), W) + b
# 使用之前定义的softmax函数对线性输出进行softmax操作，得到最终的预测结果
return softmax(linear_output)
**
4、定义损失函数
交叉熵损失函数
# 创建一个张量y，包含真实标签
y = torch.tensor([0, 2])
# 创建一个张量y_hat，表示模型的预测概率分布
y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])
# 使用切片操作选择y_hat中对应真实标签的预测概率
selected_probs = y_hat[[0, 1], y]
# 定义交叉熵损失函数，接受预测概率分布y_hat和真实标签y作为输入
def cross_entropy(y_hat, y):
"""
计算交叉熵损失
参数:
y_hat: 模型的预测概率分布张量
y: 真实标签张量
返回:
计算得到的交叉熵损失张量
"""
# 使用索引操作从y_hat中选择对应真实标签的预测概率
selected_probs = y_hat[range(len(y_hat)), y]
# 使用torch.log计算对数，然后使用负号得到交叉熵损失
return -torch.log(selected_probs)
# 使用定义的交叉熵损失函数计算损失
loss = cross_entropy(y_hat, y)
6、分类精度
def accuracy(y_hat, y): #@save
"""
计算预测正确的数量
参数:
y_hat: 模型的预测概率分布张量
y: 真实标签张量
返回:
预测正确的样本数量
"""
# 检查预测概率分布张量的形状，如果有多个预测类别，则选择预测概率最高的类别
if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
y_hat = y_hat.argmax(axis=1)
# 将预测类别与真实标签进行比较，得到一个布尔张量cmp
cmp = y_hat.type(y.dtype) == y
# 使用sum函数统计布尔张量cmp中值为True的数量，即预测正确的样本数量
# 最后将结果转换为浮点数并返回
return float(cmp.type(y.dtype).sum())
下面这张图是分类精度
上面是测试单个数据，这个是测试数据集，也就是多个数据
def evaluate_accuracy(net, data_iter): #@save
"""
计算在指定数据集上模型的精度
参数:
net: 需要评估的模型
data_iter: 数据迭代器，包含输入特征和真实标签
返回:
计算得到的模型精度
"""
# 如果net是torch.nn.Module的实例，将其设置为评估模式
if isinstance(net, torch.nn.Module):
net.eval()
# 创建累加器metric，用于记录正确预测数和总样本数
metric = Accumulator(2)
# 使用torch.no_grad()上下文管理器，关闭梯度计算
with torch.no_grad():
# 遍历数据迭代器中的每个批次
for X, y in data_iter:
# 对模型net进行预测，计算预测精度并累加到metric中
metric.add(accuracy(net(X), y), y.numel())
# 计算模型在数据集上的精度，即正确预测数除以总样本数
return metric[0] / metric[1]
这个代码是别⽤于存储正确预测的数量和预测的总数量。
class Accumulator: #@save
"""
在n个变量上进行累加的累加器类
"""
def __init__(self, n):
"""
初始化累加器，创建n个初始值为0.0的变量
参数:
n: 需要累加的变量个数
"""
self.data = [0.0] * n
def add(self, *args):
"""
将传入的参数与已有变量逐元素相加
参数:
*args: 可变数量的参数，需要与已有变量个数相匹配
"""
self.data = [a + float(b) for a, b in zip(self.data, args)]
def reset(self):
"""重置累加器，将所有变量的值重置为0.0"""
self.data = [0.0] * len(self.data)
def __getitem__(self, idx):
"""
获取指定索引处的变量值
参数:
idx: 索引
返回:
指定索引处的变量值
"""
return self.data[idx]
3.6.6、训练
def train_epoch_ch3(net, train_iter, loss, updater): #@save
"""
训练模型一个迭代周期
参数:
net: 需要训练的模型
train_iter: 训练数据迭代器，包含输入特征和真实标签
loss: 损失函数，用于计算模型预测与真实标签之间的损失
updater: 更新参数的方法，可以是PyTorch内置的优化器或定制的优化器
返回:
训练损失和训练精度的平均值
"""
# 如果net是torch.nn.Module的实例，将其设置为训练模式
if isinstance(net, torch.nn.Module):
net.train()
# 创建累加器metric，用于记录训练损失总和、训练准确度总和、样本数
metric = Accumulator(3)
# 遍历训练数据迭代器中的每个批次
for X, y in train_iter:
# 使用模型net对输入特征X进行预测，得到预测结果y_hat
y_hat = net(X)
# 使用损失函数loss计算预测结果y_hat与真实标签y之间的损失
l = loss(y_hat, y)
# 根据updater的类型选择不同的优化策略
if isinstance(updater, torch.optim.Optimizer):
# 如果updater是PyTorch内置的优化器
updater.zero_grad() # 清除梯度
l.mean().backward() # 计算损失的均值并计算梯度
updater.step() # 更新参数
else:
# 如果updater是定制的优化器
l.sum().backward() # 计算损失的总和并计算梯度
updater(X.shape[0]) # 更新参数
# 将当前批次的损失值、预测精度和样本数累加到metric中
metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
# 计算训练损失和训练精度的平均值，并返回
return metric[0] / metric[2], metric[1] / metric[2]
画图的代码，每个批次都更新图片，训练图片
class Animator: #@save
"""在动画中绘制数据的动画类"""
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)):
"""
初始化动画对象，配置绘图参数
参数:
xlabel: x轴标签
ylabel: y轴标签
legend: 图例标签
xlim: x轴范围
ylim: y轴范围
xscale: x轴的刻度类型
yscale: y轴的刻度类型
fmts: 绘制线条的格式
nrows: 子图的行数
ncols: 子图的列数
figsize: 图像的大小
"""
if legend is None:
legend = [] # 如果没有图例标签，默认为空列表
d2l.use_svg_display() # 设置使用SVG格式显示图像
# 创建图像和子图对象，配置绘图参数
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):
"""向动画中添加数据点"""
# 如果y不是可迭代对象，将其转换为单元素的可迭代列表
if not hasattr(y, "__len__"):
y = [y]
n = len(y) # 获取y的长度
# 如果x不是可迭代对象，将其复制为与y长度相同的可迭代列表
if not hasattr(x, "__len__"):
x = [x] * n
# 如果self.X为空，创建一个空列表，用于存储x轴坐标
if not self.X:
self.X = [[] for _ in range(n)]
# 如果self.Y为空，创建一个空列表，用于存储y轴坐标
if not self.Y:
self.Y = [[] for _ in range(n)]
# 遍历x轴坐标和y轴坐标，将数据点添加到相应的列表中
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() # 清空子图内容，以便绘制新的数据
# 使用fmts列表中的格式绘制各个数据序列的线条
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) # 清空输出区域，以便更新图像
def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater): #@save
"""
训练模型（定义⻅第3章）
参数:
net: 需要训练的模型
train_iter: 训练数据迭代器
test_iter: 测试数据迭代器
loss: 损失函数
num_epochs: 训练的迭代周期数
updater: 更新参数的方法
"""
# 创建动画对象，用于绘制训练过程中的变化
animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],
legend=['train loss', 'train acc', 'test acc'])
# 遍历迭代周期
for epoch in range(num_epochs):
# 调用train_epoch_ch3函数训练一个迭代周期，获取训练损失和训练精度
train_metrics = train_epoch_ch3(net, train_iter, loss, updater)
# 在测试数据上计算模型精度
test_acc = evaluate_accuracy(net, test_iter)
# 将训练损失、训练精度和测试精度添加到动画对象中，以更新绘制的图像
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
7、预测
def predict_ch3(net, test_iter, n=6): #@save
"""
预测标签（定义⻅第3章）
参数:
net: 训练好的模型
test_iter: 测试数据迭代器
n: 需要展示的图像数量（默认为6）
"""
for X, y in test_iter:
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]) # 展示图像和对应的标签
158
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
