【PyTorch深度学习实践】08_Softmax分类器（多分类）

1.Softmax层

当需要多分类的时候，会输出一个分布，这些分布需要满足P(y = i) >=0 和 所有的P值加起来=1，使用softmax可以实现。

要注意的是，softmax本质上和sigmoid一样也是一个激活函数。
sigmoid用于二分类，softmax用于多分类。

1.1softmax的函数表示

示例

1.2 损失函数

关于代码中的ToTensor

2. 代码实现

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim

batch_size = 64
transform = transforms.Compose([
    transforms.ToTensor(),  # 转为张量
    # 归一化，切换到01分布进行训练（神经网络更适用），两个值分别是均值和方差，用于进行分布转换
    transforms.Normalize((0.1307, ), (0.3081, ))  # 注意这里说的不是取值范围，而是以0为均值，1为标准差的分布
])

train_dataset = datasets.MNIST(
    root='/Users/yahoo/Downloads',
    train=True,
    download=False,
    transform=transform
)

train_loader = DataLoader(
    train_dataset,
    shuffle=True,
    batch_size=batch_size
)

test_dataset = datasets.MNIST(
    root='/Users/yahoo/Downloads',
    train=True,
    download=False,
    transform=transform
)

test_loader = DataLoader(
    test_dataset,
    shuffle=True,
    batch_size=batch_size
)

class Net(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.l1 = torch.nn.Linear(784, 512)  # 每层都是全连接
        self.l2 = torch.nn.Linear(512, 256)
        self.l3 = torch.nn.Linear(256, 128)
        self.l4 = torch.nn.Linear(128, 64)
        self.l5 = torch.nn.Linear(64, 10)

    def forward(self,x):
        x = x.view(-1,784)
        x = F.relu(self.l1(x))
        x = F.relu(self.l2(x))
        x = F.relu(self.l3(x))
        x = F.relu(self.l4(x))
        return self.l5(x)        # 最后一层不激活

model = Net()

criterion = torch.nn.CrossEntropyLoss()  # 打包好的交叉熵损失
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5) # 带冲量效果更好，可以冲破局部最小值，尽可能找到全局最优解

def train(epoch):
    running_loss = 0.0
    for batch_idx,data in enumerate(train_loader, 0):
        inputs, target = data
        optimizer.zero_grad() # 每轮先置0

        # forward + backward + update
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if batch_idx % 300 == 299:
            print('[%d， %5d] loss: %.3f' % (epoch + 1, batch_idx+1, running_loss / 300))
            running_loss = 0.0

def test():
    correct = 0
    total = 0
    with torch.no_grad():  # 表明不用计算梯度
        for data in test_loader:
            images, labels = data
            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim=1)  # 横向为第一个维度，意指从每行中找出最大值及其下标
            total += labels.size(0)
            correct += (predicted == labels).sum().item()  # 比较下标与预测值的结果是否接近，求和即是看我们猜对了多少个
    print('Accuracy on test set: %d %%' % (100 * correct / total))


if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)
        test()

输出结果

[1，   300] loss: 2.213
[1，   600] loss: 0.892
[1，   900] loss: 0.446
Accuracy on test set: 89 %
[2，   300] loss: 0.313
[2，   600] loss: 0.268
[2，   900] loss: 0.224
Accuracy on test set: 94 %
···························
[9，   300] loss: 0.044
[9，   600] loss: 0.040
[9，   900] loss: 0.043
Accuracy on test set: 99 %
[10，   300] loss: 0.035
[10，   600] loss: 0.033
[10，   900] loss: 0.033
Accuracy on test set: 99 %