使用pytorch实现SOFTMAX回归

《Dive-into-DL-Pytorch》3.7 SOFTMAX回归的简洁实现(SOFTMAX regression pytorch)

# 导入需要的包和模块
import torch
from torch import nn
from torch.nn import init
import numpy as np
import sys
sys.path.append("...")	# 引号内为d2lzh_pytorch的路径，如果出现报错，注意修改\为\\
import d2lzh_pytorch as d2l

3.7.1 获取和读取数据

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

3.7.2 定义和初始化模型

导入的每个batch样本的形状为(batch_size, 1, 28, 28)，为了方便计算，我们将其转换为(batch_size, 784)，$784=28\times 28\times 1$

num_inputs = 784
num_outputs = 10

class LinearNet(nn.Module): # 定义一个名为LinearNet的类，该类继承自nn.Module
    def __init__(self, num_inputs, num_outputs):    # 定义了一个名为__init__的方法，该方法是LinearNet的构造函数，用于初始化类的实例
        super(LinearNet, self).__init__()   # 调用父类nn.Module的构造函数，初始化神经网络模型
        self.linear = nn.Linear(num_inputs, num_outputs)    # 定义一个名为linear的属性，该属性是一个线性层，用于将输入数据映射到输出数据
    def forward(self, x):   # x shape: (batch_size, 1, 28, 28)
        '''定义了一个forward的方法，该方法是神经网络模型的前向传播函数，用于计算输入数据的输出'''
        y = self.linear(x.view(x.shape[0], -1)) # 将输入数据通过线性层linear进行线性变换，并将结果赋给y
        return y

这里简单介绍下几个函数的作用：

1. super()（链接是菜鸟教程对super()函数的解释）：super()是一个python的内置函数，用于调用父类的方法，因为LinearNet类是集成自父类nn.Module的，使用super().xxx()可以调用父类nn.Module中的函数xxx()。这里通过super().__init__()来调用nn.Module的__init()_函数，用于初始化神经网络

2. nn.linear()（CSDN上一个大佬的文章，讲的很好）：这里的nn.linear()有两个参数，一个是输入的特征数784，一个是输出的标签数10。nn.linear()的作用就是将输入的特征经过线性变换，得到输出的结果。
   这里的输入应该有784个，输出有10个
   由于一个batch有256个样本，上面只是对一个样本进行线性处理，得到其输出结果。所以在forward()函数中调用了nn.linear，其参数为$x_{256\times 784}$，线性计算为：
   $$y_{256\times 10}=x_{256\times 784}{\omega }_{784\times 10}+b_{256\times 10}$$
   这里需要注意的是调用self.linear()的时候里面只有一个参数$x_{256\times 784}$，那权重和偏差都是哪来的呢？
   这里的权重和偏差（模型参数）都是初始化时随机生成的，因为我们不知道什么样的权重和偏差更好，所以我们随机生成，万一生成了准确率高的模型参数呢。后面也会对模型参数进行训练来找到更好的模型参数

3. view(x.shape[0], -1)：将x的形状改为一个二维张量，形状为(batch_size, 总像素数)，其中x.shape[0]就是batch_size，表示输入张量的总样本数，-1表示自动计算该维度的大小，以保证张量大小不变。
   这样的目的是将输入数据展平为一维，以便于传入全连接层

当然，我们也可以使用Sequential容器来定义我们的模型：

class FlattenLayer(nn.Module):
	'''转换x的形状为二维张量，以便于传入全连接层'''
    def __init__(self):
        super(FlattenLayer, self).__init__()
    def forward(self, x):   # x shape: (batch, *, *, ...)
        return x.view(x.shape[0], -1)

from collections import OrderedDict
net = nn.Sequential(
    # FlattenLayer(),
    # nn.Linear(nm_imputs, num_outputs)
    OrderedDict([
        ('flatten', FlattenLayer()),
        ('linear', nn.Linear(num_inputs, num_outputs))
    ])
)

net = nn.Sequential()：定义了一个名为net的神经网络模型，该模型是一个序列容器，可以把多个神经网络层按顺序组合成一个神经网络模型

然后创建了两个神经网络层flatten和linear（网络层的名称）：flatten网络层是一个自定义的层，用于将输入数据展平成一维；linear网络层是一个线性层，用于将输入数据映射到输出数据（和上面的nn.linear()一样）

初始化模型参数：

前面有说过模型参数是初始化时随机生成的，但我们也可以自己来设定怎么生成模型参数：

init.normal_(net.linear.weight, mean=0, std=0.01)	# 使用均值为0，标准差为0.01的正态分布来随机初始化模型的权重参数
init.constant_(net.linear.bias, val=0)	# 模型的偏差参数直接初始化为0

3.7.3 SOFTMAX和交叉熵损失函数

在上一节中，softmax运算和交叉熵损失函数是分开定义的，可能会造成数值不稳定。pytorch提供了一个包括softmax运算和交叉熵损失计算的函数。它的数值稳定性更好

loss = nn.CrossEntropyLoss()

nn.CrossEntropyLoss()（这是pytorch的中文官方文档对nn.CrossEntropyLoss()的解释）：当然，这里为什么用softmax运算，书中3.4给有，为什么用交叉熵损失函数，我也不知道

3.7.4 定义优化算法

# 使用学习率为0.1的小批量随机梯度下降作为优化算法
optimizer = torch.optim.SGD(net.parameters(), lr=0.1)

还记得线性回归中说的吗？这个地方可以改变不同网络层的学习率，因为当时只有一个网络层，所以没办法展示，当时的代码是注释掉的，这里就可以了，我们可以改为这样的：

optimizer = torch.optim.SGD([
    {'params': net.flatten.parameters(), 'lr': 0.1},	# 将flatten层学习率改为0.1
    {'params': net.linear.parameters(), 'lr': 0.01}		# 将linear层学习率改为0.01
])

也可以看出来学习率越小，结果越准确

3.7.5 训练模型

# 评价模型net在数据集data_iter上的准确率
def evaluate_accuracy(data_iter, net):
    acc_sum, n = 0.0, 0
    for X, y in data_iter:
        acc_sum += (net(X).argmax(dim=1) == y).float().sum().item()
        n += y.shape[0]
    return acc_sum / n


def train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, params=None, lr=None, optimizer=None):
    for epoch in range(num_epochs):
        train_l_sum, train_acc_sum, n = 0.0, 0.0, 0
        for X, y in train_iter:
            y_hat = net(X)
            l = loss(y_hat, y).sum()

            # 梯度清零
            if optimizer is not None:
                optimizer.zero_grad()
            elif params is not None and params[0].grad is not None:
                for param in params:
                    param.grad.data.zero_()

            l.backward()
            if optimizer is None:
                d2l.sgd(params, lr, batch_size)
            else:
                optimizer.step()


            train_l_sum += l.item()
            train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item()
            n += y.shape[0]
        test_acc = evaluate_accuracy(test_iter, net)
        print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f' % (epoch + 1, train_l_sum / n, train_acc_sum / n, test_acc))

num_epochs = 5
train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, None, None, optimizer)

ERROR

优化定义算法的时候出现报错，找了很久都没找到，错误情况如下：

错误原因为：AttributeError: 'FlattenLayer' object has no attribute '_parameters'（属性错误：FlattenLayer没有parameters属性），找了很久的原因，最终发现是定义FlattenLayer类的时候，没有对其初始化，即下面这段代码的第4行__init__后面没有加()，害，我找了一个多小时😭

class FlattenLayer(nn.Module):
	'''转换x的形状为二维张量，以便于传入全连接层'''
    def __init__(self):
        super(FlattenLayer, self).__init__()
    def forward(self, x):   # x shape: (batch, *, *, ...)
        return x.view(x.shape[0], -1)

参考

Dive-into-DL-Pytorch