2.2softmax回归 - 技术栈

1.基本要素

在一类情景中，模型输出可以是一个像图像类别这样的离散值。对于这样的离散值预测问题，我们可以使用诸如softmax回归在内的分类模型。和线性回归不同，softmax回归的输出单元从一个变成了多个，且引入了softmax运算使输出更适合离散值的预测和训练。

(1)回归模型

softmax回归的输出值个数等于标签里的类别数。因为一共有4种特征和3种输出动物类别，所以权重包含12个标量（带下标的w）、偏差包含3个标量（带下标的b），且对每个输入计算o₁，o₂，o₃这三个输出：

o1=x1w11+x2w21+x3w31+x4w41+b1

o2=x1w12+x2w22+x3w32+x4w42+b2

o3=x1w13+x2w23+x3w33+x4w43+b3

既然分类问题需要得到离散的预测输出，一个简单的办法是将输出值o_i当作预测类别是i的置信度，并将值最大的输出所对应的类作为预测输出，即输出 arg_imaxo_i。

（2）单样本分类的矢量表达式

复制代码

              W = [

					 [w11, w12, w13],

				     [w21, w22, w23],

				     [w31, w32, w33],

				     [w41, w42, w43]]
		b = [b1, b2, b3]

设高和宽分别为2个像素的图像样本i的特征为

复制代码

       x^(i) = [x1^(i), x2^(i), x3^(i), x4^(i)]

预测为狗、猫或鸡的概率分布为

复制代码

             ŷ^(i) = [ŷ₁^(i), ŷ₂^(i), ŷ₃^(i)]ᵀ

矢量计算表达式为

复制代码

                    o^(i) = x^(i) W + b  
                     ŷ^(i) = softmax(o^(i))

2.图像分类数据集Fashion-MNIST

（1）获取数据集

python 复制代码

mnist_train=torchvision.datasets.FashionMNIST(root="../Datasets/FashionMNIST",train=True,download=True,
                                              transform=transforms.ToTensor())
mnist_test=torchvision.datasets.FashionMNIST(root="../Datasets/FashionMNIST",train=False,download=True,
                                              transform=transforms.ToTensor())

（2）读取小批量

python 复制代码

batch_size=256
#获取当前操作系统平台信息
if sys.platform.startswith('win'):
    #windows系统下不使用多进程
    num_workers=0
else:
    num_workers=4

train_iter=torch.utils.data.DataLoader(mnist_train,batch_size=batch_size,shuffle=True,num_workers=num_workers)
test_iter=torch.utils.data.DataLoader(mnist_test,batch_size=batch_size,shuffle=False,num_workers=num_workers)

3.使用PyTorch实现

（1）获取和读取数据

python 复制代码

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

（2）定义和初始化模型

python 复制代码

num_inputs=784
num_outputs=10

class LinearNet(nn.Module):
    def __init__(self,num_inputs,num_outputs):
        super(LinearNet,self).__init__()
        self.linear=nn.Linear(num_inputs,num_outputs)
    def forward(self,x):
        y=self.linear(x.view(x.shape[0],-1))
        return y

net=LinearNet(num_inputs,num_outputs)

class FlattenLayer(nn.Module):
    def __init__(self):
        super(FlattenLayer, self).__init__()
    def forward(self, x): # x shape: (batch, *, *, ...)
        return x.view(x.shape[0], -1)
    
net=nn.Sequential(
    FlattenLayer(),
    nn.Linear(num_inputs,num_outputs)
)

#初始化模型参数
init.normal_(net.linear.weight,mean=0,std=0.01)
init.constant_(net.linear.bias,val=0)

（3）交叉熵损失函数

PyTorch提供了一个包括softmax运算和交叉熵损失计算的函数。它的数值稳定性更好。

python 复制代码

loss = nn.CrossEntropyLoss()

（4）定义优化算法

python 复制代码

optimizer=torch.optim.SGD(net.parameters(),lr=0.1)

（5）训练模型

python 复制代码

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 = d2l.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)