刘二PyTorch深度学习（八）——多分类问题（Softmax+CrossEntropy）

多分类和交叉熵：（前面层还是用sigmoid，最后一层用softmax）

1. softmax分类器

2. 多分类问题需要满足的条件（离散分类）：第一概率要大于0；第二和为1

3. 使用交叉熵损失时，神经网络的最后一层是不需要激活的

4. 拿到一个图片后，分两步操作：第一步先用transforms.ToTensor():方法将图片转换成PyTorch里的张量；第二步用transforms.Normalize()把其切换到0~1分布，供神经网络进行训练

5. 因为神经网络模型比较大了，所以要用更好一点的优化算法，比如说带冲量的momentum=0.5

6. torch.max函数中的dim表示维度：dim=0表示行（矩阵从上到下），dim=1表示列（矩阵从左到右）

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

# 准备数据
batch_size = 64
# 两步走：第一步将训练的图片转换成PyTorch中的张量；第二步转换成0-1分布，供神经网络训练使用
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])

train_dataset = datasets.MNIST(root='./data/mnist/', train=True, download=False, transform=transform)
train_dataloder = DataLoader(dataset=train_dataset, shuffle=True, batch_size=batch_size)
test_dataset = datasets.MNIST(root='./data/mnist/', train=False, download=False, transform=transform)
test_dataloder = DataLoader(dataset=test_dataset, shuffle=False, batch_size=batch_size)


# 构建模型
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__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)  # 将矩阵拉直成一个一行的向量，总共有784列；-1表示动态调整元素个数
        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 = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.5)


# 封装训练方法和测试方法
def train(epoc):
    running_loss = 0.0
    for batch_index, data in enumerate(train_dataloder, 0):
        inputs, target = data
        y_pred = model(inputs)
        loss = criterion(y_pred, target)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        running_loss += loss.item()

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


def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_dataloder:
            images, labels = data
            outputs = model(images)
            # 求出每一行最大值的下标
            _, predicted = torch.max(outputs.data, dim=1)  # dim=0表示行（矩阵从上到下），dim=1表示列（矩阵从左到右）
            total += labels.size(0)  # labels是一个（N,1）的元组
            correct += (predicted == labels).sum().item()

    print('Accuracy on testset %d %%' % (100 * correct / total))


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