Demo9 :多分类问题

来源：B站刘二大人
说明：

1. softmax的输入不需要做非线性变换。也就是说softmax之前不再需要激活函数(relu)。softmax两个作用：1.如果在进行softmax前的input有负数，通过指数变换，得到正数。2.所有类的概率求和为1。
2. y的标签编码方式是one-hot编码：只有一位是1，其他位为0。(算法的输入仍为原始标签，只是经过算法后变成one-hot编码)
3. 多分类问题，标签y的类型是LongTensor。比如说0-9分类问题，如果y = torch.LongTensor([3])，对应的one-hot是[0,0,0,1,0,0,0,0,0,0].(这里要注意：如果使用了one-hot，标签y的类型是LongTensor，课程中糖尿病数据集中的target的类型是FloatTensor)
4. CrossEntropyLoss === Softmax +Log+ NLLLoss。也就是说只需要对线性层最后一层先进行SoftMax处理，再进行log操作，然后使用NLLLoss就行了，具体看代码

过程如下：



代码说明：

1. torch.max的返回值有两个：第一个是每一行的最大值是，第二个是每一行最大值的下标(索引)。
   传送1. torch.max函数用法
   传送2. torch.max()使用讲解
2. 在test中涉及到with torch.no_grad() :
   torch.no_grad() 详解
   Python中with的用法
3. 代码中出现了"_" 。 Python中各种下划线的操作

# 8 多分类问题
import torch
from torchvision import transforms  # 
from torchvision import datasets  # 视觉领域基础数据集包，可下载经典数据集如minist等
from torch.utils.data import DataLoader  # 第八讲中详细说明
import torch.nn.functional as F
import torch.optim as optim

# prepare dataset

# 开始用tensor，需要导入transforms包
batch_size = 64

# 需要对数据进行归一化，均值和方差处理
# （0.1307,), (0.3081,) 解释：minist数据集是灰度图，灰度图的方差和标准差是这两个固定值
#  RGB图像的话就是这两组：([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
transform = transforms.Compose([transforms.ToTensor(),
                                transforms.Normalize((0.1307,), (0.3081,))])
# 自动下载minist训练集到root路径，对图片做归一化，标准化和方差
train_dataset = datasets.MNIST(root='../dataset/minist/', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)
# 下载minist测试集到root路径，对图片做归一化，标准化和方差
test_dataset = datasets.MNIST(root='../dataset/minist/', train=False, download=True, transform=transform)
test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)


# design model 
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.l1 = torch.nn.Linear(784, 512)  # minist数据集resize成（1，784）本来是x * y = 784
        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)  # view() 等于np.resize（）,-1就是当前batch_size
        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()

# construct loss and optimizer 

criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)  # 动量+学习率


# training cycle
def train(epoch):
    running_loss = 0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        optimizer.zero_grad()

        outputs = model(inputs)
        # 交叉熵损失的outputs是（64,10），target是64
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

        # 每300个数据迭代1次
        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
            # 获取模型输出，10类别
            outputs = model(images)
            # 取出预测值最大的一个，出现_了，意义具体看说明
            # predicted 获取最大值的索引，one-hot编码中，索引就是它的输出
            _, predicted = torch.max(outputs.data, dim=1)  # 对行取最大值，列是0，行是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()