深度学习day09 多分类问题

本文参考视频链接

重点（全连接的神经网络）

1. 多标签值分类要满足这样一种概率分布：每一个标签的概率要大于等于0；所有标签的概率之和等于1
2. sigmoid函数输出值是-1~1，为了满足上述条件，所以我们在神经网络的最后一层不使用sigmoid激活函数，而使用softmax函数（内包含在交叉熵损失里面），该函数可以将某一标签输入的值进行指数变换，得到一个正数，然后除于所有标签的变换后的指数，得到的所有标签的概率就满足上述的概率分布。
3. 标签y的类型是LongTensor，采用one-hot编码。比如说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. 交叉熵损失就是最后一层输出的值经过Softmax函数变换后求对数，然后再与-Y做一个向量乘法。CrossEntropyLoss = Softmax(x) + NLLLoss(-YlogY^)。也就是说使用CrossEntropyLoss最后一层(线性层)是不需要做其他变化的；使用NLLLoss之前，需要对最后一层(线性层)先进行SoftMax处理，再进行Log操作。
   二分类的损失函数：
   
   多分类的损失函数softmax：
   
   NLL损失函数：
   交叉熵损失函数：
   x = x.view(-1,784)中的-1表示自动计算有多少个样本图片，一个图片的像素矩阵大小28*28，784是将二维矩阵转换为一维矩阵后的列数
   带冲量的优化器可以优化训练过程。
   
   

图像的特征提取方法：
手动：傅里叶变换FFT、小波Wavelet
自动：CNN

代码

代码结构：

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

# prepare dataset

batch_size = 64
transform = transforms.Compose([
    # 将输入的图像转化为pytorch中的张量
    transforms.ToTensor(),
    # 标准化，均值mean和标准差std，将其中0~255的数据变化成[0,1]之间，这样的数据在神经网络中训练的效果是最好的
    transforms.Normalize((0.1307,), (0.3081,))])
# 构造训练集和数据加载器
train_dataset = datasets.MNIST(root='../dataset/mnist/', train=False, download=False, transform=transform)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)
# 构造测试集和数据加载器
test_dataset = datasets.MNIST(root='../dataset/mnist/', train=True, download=False, transform=transform)
test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)


# design model using class
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)  # -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()

# construct loss and optimizer
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5) # 带冲量的优化器可以帮助梯度下降效果更好


# training cycle forward, backward, update

# 将一轮循环封装成函数，方便边训练边测试
def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        # 获得一个批次64个的数据和标签
        inputs, target = data
        optimizer.zero_grad()

        # 获得模型预测结果(64, 10)
        outputs = model(inputs)
        # 交叉熵代价函数outputs(64,10),target（64）
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()

        running_loss += loss.item() # 要用item（）取值，否则会构建计算图
        if batch_idx % 50 == 49:
            # 打印这是第几次训练，这次训练中是第几次batch迭代
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0

# test不需要反向传播，也不需要计算梯度
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)  # 找到最大值所在的下标，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()

训练20次的结果