softmax回归的从零开始实现
一、创建数据集
从Fashion-MNIST数据集中引入创建数据，并设置数据迭代器的批量大小为256
import torch from IPython import display from d2l import torch as d2l
#batch_size=256，表明随机读取256张图片 batch_size = 256 # 返回训练集和测试集的迭代器 # load_data_fashion_mnist函数是在图像分类数据集中定义的一个函数，可以返回batch_size大小的训练数据集和测试数据集 train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
二、初始化模型参数
1、原始数据集中的每个样本都是28*28的图像
2、在本书中，我们将展平每个图像，把它们看作长度为784的向量
3、在softmax回归中，我们输出与类别一样多。(因为我们的数据集有10个类别，所以网络输出的维度为10)
4、权重将构成一个 784×10 的矩阵，偏置将构成一个 1×10 的行向量。与线性回归一样，我们将使用正态分布初始化我们的权重 W，偏置初始化为0
num_inputs = 784 # 样本的长和宽都是28，将其展平为空间向量，长度变为784 num_outputs = 10 # 数据集类别，也是输出数 #size=(num_inputs, num_outputs)；行数等于输入的个数，列数等于输出的个数 #requires_grad=True表明要计算梯度 #权重 #在这里W被定义为一个784*10的矩阵 W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True) #偏离 b = torch.zeros(num_outputs, requires_grad=True)
三、定义softmax操作
# 定义softmax()函数
def softmax(X):
#torch.exp()对每个元素做指数计算
X_exp = torch.exp(X)
#对矩阵的每一行求和，重新生成新的矩阵
partition = X_exp.sum(1, keepdim=True)
# X_exp / partition：每一行代表一个样本，行中的每个数据代表在该类别的概率
return X_exp / partition # 这里应用了广播机制
可以发现，每个元素都变成了一个非负数。此外，依据概率原理，每行总和为1。
如下，是个小测试
#创建一个随机的均值为0，方差为1的两行五列的矩阵
X = torch.normal(0, 1, (2, 5))
#对矩阵进行softmax计算
X_prob = softmax(X)
X_prob, X_prob.sum(1)
#通过输出可以发现在softmax之后，每个元素都是正的，且行之和为1
#输出结果
(tensor([[0.0474, 0.0313, 0.8646, 0.0317, 0.0250],
[0.1736, 0.4575, 0.2832, 0.0618, 0.0239]]),
tensor([1.0000, 1.0000]))
四、定义模型
1、利用之前实现的softmax操作，可以实现softmax回归模型
2、在将数据传递到模型之前，需要使用reshape函数将每张原始图像展平为向量
def net(X):
#matmul是矩阵乘法
#W.shape[0]=784
# W是一个784*10的矩阵，W.shape就是[784,10]的列表，可以通过W.shape[0]来访问784
return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)
五、定义损失函数
y = torch.tensor([0, 2]) # y_hat为预测值，此次是对两个样本做预测值 y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]]) # 对第零个样本，拿出y0的数据=0.1；对第一个样本，拿出y1的书籍，y1=2,就是拿出第三个数据=0.5 # 第一个参数[0,1]表示样本号，第二个参数y表示在第一个参数确定的样本中取数的序号 y_hat[[0, 1], y] #输出结果 tensor([0.1000, 0.5000])
上诉可以帮助我们理解“交叉”的含义。接下来，我们只需要添加一行代码实现损失函数
# 给定我的y_hat预测和真实标号y
def cross_entropy(y_hat, y):
#对于每一行range(len(y_hat))：生成一个从零开始一直到len(y_hat)的向量
return -torch.log(y_hat[range(len(y_hat)), y])
print(cross_entropy(y_hat, y))
-torch.log(y_hat[[0, 1], y])
#输出：2.3026样本零的损失，0.6931样本1的损失
#输出结果
tensor([2.3026, 0.6931])
tensor([2.3026, 0.6931])
六、分类准确度
1、分类准确率即正确预测数量与总预测数量之比。
2、y_hat 是矩阵，假定第二个维度存储每个类的预测分数。
3、使用 argmax 获得每行中最大元素的索引来获得预测类别
4、将预测类别与真实 y 元素进行比较
# 计算分类准确率，正确预测数量与总预测数量之比
# y_hat是预测值，y是真实值
# 计算预测正确的样本数
def accuracy(y_hat, y): #@save
"""计算预测正确的数量。"""
# len是查看矩阵的行数
# y_hat.shape[1]就是去列数，y_hat.
if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
#每一行中元素最大的那个下标存在y_hat里面
#最大的元素就可以算为预测分类的类别
y_hat = y_hat.argmax(axis=1)
#将y_hat转换为y的数据类型然后作比较
#使用cmp函数存储bool类型
cmp = y_hat.type(y.dtype) == y
#将cmp转化为y的数据类型再求和——得到找出来预测正确的类别数
return float(cmp.type(y.dtype).sum())
5、按照之前定义的变量y_hat和y，我们预测准确率（第一个样本的预测类别是2（该行的最大元素为0.6，索引为2），这与实际标签0不一致。第二个样本的预测类别是2（该行的最大元素为0.5，索引为 2），这与实际标签2一致）
#除以整个y的长度（样本数），就是预测正确的概率 accuracy(y_hat, y) / len(y) #输出结果 0.5
6、泛化，对于任意数据迭代器data_iter 可访问的数据集，我们可以评估在任意模型 net 的准确率。
# 评估任意模型的准确率
def evaluate_accuracy(net, data_iter): #@save
"""计算在指定数据集上模型的精度。"""
# isinstance()：判断一个对象是否是一个已知的类型
# 判断输入的net模型是否是torch.nn.Module类型
if isinstance(net, torch.nn.Module):
net.eval() # 将模型设置为评估模式（不用计算梯度）
metric = Accumulator(2) # 存储正确预测数、预测总数
# 每次从迭代器中拿出一个x和y
for X, y in data_iter:
# 1、net(X)：X放在net模型中进行softmax操作
# 2、accuracy(net(X), y)：再计算所有预算正确的样本数
# numel()函数：返回数组中元素的个数，在此可以求得样本数
metric.add(accuracy(net(X), y), y.numel())
#metric[0]:分类正确的样本数，metric[1]:总的样本数
return metric[0] / metric[1]
evaluate_accuracy(net, test_iter)
#输出结果
0.1001
七、训练
1、首先，我们定义一个函数来训练一个迭代周期
2、注意，updater是更新模型参数的常用函数，接受批量大小作为参数
def train_epoch_ch3(net, train_iter, loss, updater): #@save
"""训练模型一个迭代周期（定义见第3章）。"""
# 将模型设置为训练模式 if isinstance(net, torch.nn.Module): net.train()#告诉pytorch我要计算梯度 # 训练损失总和、训练准确度总和、样本数 # Accumulator 是一个实用程序类，用于对多个变量进行累加 #在此创建了一个长度为三的迭代器，用于累加信息 metric = Accumulator(3) for X, y in train_iter: # 计算梯度并更新参数 y_hat = net(X) l = loss(y_hat, y) if isinstance(updater, torch.optim.Optimizer): # 使用PyTorch内置的优化器和损失函数 updater.zero_grad()#先把梯度设置为零 l.backward() #计算梯度 updater.step()#自更新 metric.add( float(l) * len(y), accuracy(y_hat, y), y.size().numel()) else: # 使用定制的优化器和损失函数 # 如果是自我实现的话，l出来就是向量，我们先做求和，再求梯度 l.sum().backward() updater(X.shape[0]) metric.add(float(l.sum()), accuracy(y_hat, y), y.numel()) # 返回训练损失和训练准确率 # metric[0]就是损失样本数目；metric[1]是训练正确的样本数；metric[2]是总的样本数 return metric[0] / metric[2], metric[1] / metric[2]
3、实现一个训练函数，它会在train_iter 访问到的训练数据集上训练一个模型net
4、该训练函数将会运行多个迭代周期（由num_epochs指定）
def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater): #@save
"""训练模型（定义见第3章）。"""
animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],
legend=['train loss', 'train acc', 'test acc'])
# num_epochs：训练次数
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
5、作为一个从零开始的实现，我们使用 小批量随机梯度下降来优化模型的损失函数，设置学习率为0.1
lr = 0.1
def updater(batch_size):
return d2l.sgd([W, b], lr, batch_size)
6、现在，训练模型10个迭代周期。请注意，迭代周期（num_epochs）和学习率（lr）都是可调节的超参数。通过更改它们的值，我们可以提高模型的分类准确率。
#开始训练 num_epochs = 10 train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater)
八、预测
给定一系列图像，比较它们的实际标签（文本输出的第一行）和模型预测（文本输出的第二行）
def predict_ch3(net, test_iter, n=6): #@save
"""预测标签（定义见第3章）。"""
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])
predict_ch3(net, test_iter)
