神经网络可以用于多分类问题 神经网络多分类器

用Softmax和CrossEntroyLoss解决多分类问题（Minst数据集）

• 一.SoftMax分类器

• 1.函数原型：
• 2.上述例子用Numpy实现：
• 3.用pytorch实现
• 4.设置batch_size为3时做的一个简单分类模型：

• 二、完成MNIST识别手写体数字

• 1.准备数据集
• 2.构建训练模型class
• 3.构造损失函数和优化器
• 4.训练和测试
• 5.运行结果如下：

一.SoftMax分类器

1.函数原型：

这是我们常见的一个神经网络模型。在输出的时候我们常常会遇到多分类问题，这时就需要我们应用Softmax函数来发挥作用了。

如图就是一个简单的Softmax函数，它只是求了加权平均值，然后进行分类。

2.上述例子用Numpy实现：

import numpy as np
y = np.array([1, 0, 0])
z = np.array([0.2, 0.1, -0.1])
y_pred = np.exp(z) / np.exp(z).sum()
loss = (- y * np.log(y_pred)).sum()
print(loss)

运行结果：

3.用pytorch实现

import torch
y = torch.LongTensor([0])
#print(y)
z = torch.Tensor([[0.2, 0.1, -0.1]])
#print(z)
criterion = torch.nn.CrossEntropyLoss()
loss = criterion(z, y)
print(loss)

运行结果：

4.设置batch_size为3时做的一个简单分类模型：

import torch
criterion = torch.nn.CrossEntropyLoss()
y = torch.LongTensor([2,0,1])
y_pred1 = torch.Tensor([[0.1, 0.2, 0.9],
[1.1, 0.1, 0.2],
[0.2, 2.1, 0.1]])
y_pred2 = torch.Tensor([[0.8, 0.2, 0.3],
[0.2, 0.3, 0.5],
[0.2, 0.2, 0.5]])
l1 = criterion(y_pred1,y)
l2 = criterion(y_pred2,y)
print("Batch Loss1",l1.data,"\nBatch Loss2",l2.data)

二、完成MNIST识别手写体数字

每个图片是28*28

1.准备数据集

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(),   #先将图像变成一个张量tensor
    transforms.Normalize((0.1307,),(0.3081,))  #其中的0.1307是MNIST数据集的均值，0.3081是MNIST数据集的标准差
])

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

2.构建训练模型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) 
        
        '''
        这里-1表示一个不确定的数，就是你如果不确定你想要reshape成几行，但是你很肯定要reshape成4列，那不确定的地方就可以写成-1
        例如一个长度的16向量x，
        x.view(-1, 4)等价于x.view(4, 4)
        x.view(-1, 2)等价于x.view(8，2)
        以此类推
        '''
    def forward(self,x):
        x = x.view(-1,784)   #784 = 28 * 28,即将N *1*28*28转化成 N *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()

3.构造损失函数和优化器

criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(),lr=0.01,momentum=0.5) #momentum 是带有优化的一个训练过程参数

4.训练和测试

def train(epoch):
    running_loss = 0.0
    for batch_idx,data in enumerate(train_loader,0):
        inputs,target = data
        optimizer.zero_grad()
        
        #forward
        outputs = model(inputs)
        loss = criterion(outputs,target)
        
        #backward
        loss.backward()
        
        #update
        optimizer.step()
        
        running_loss += loss.item()
        if batch_idx % 300 ==299 :  #每训练300次就打印一次结果
            print('[%d,%5d] loss: %.3f' % (epoch+1,batch_idx+1,running_loss/300))
            running_loss = 0.0
'''
在分类问题中，通常需要使用max()函数对softmax函数的输出值进行操作，求出预测值索引。下面讲解一下torch.max()函数的输入及输出值都是什么。
1. torch.max(input, dim) 函数
output = torch.max(input, dim)
输入:input是softmax函数输出的一个tensor,dim是max函数索引的维度0/1，0是每列的最大值，1是每行的最大值
输出:会返回两个tensor，第一个tensor是每行的最大值，softmax的输出中最大的是1，所以第一个tensor是全1的tensor；第二个tensor是每行最大值的索引。
'''            
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)  #用max 来找最大值的下标
            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()

5.运行结果如下：