实现MINST图片的分类程序

实现步骤：

1.导入库

2.超参数设置

3.载入MNIST数据

4.设置训练配置

5.搭建神经网络架构

6.初始化架构

7.定义损失函数和优化器

8.训练

9.测试

ps:按照这样的框架结构方便我们理解 ，在代码中都备注的更加详细，

代码实现如下：

############################
#   创建一个简单的全连接神经网络 #
############################



#导入库
import torch
import torch.nn as nn
import torchvision.datasets as datasets
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
#超参数设置
num_input=28*28 #(784)
num_hidden=200 #隐藏层神经元
num_class=10 #类别
batch_size=64  #分批送
learning_rate=0.001
num_epochs=3 #迭代次数 所有的图片迭代三次
#载入mnist数据
Train_dataset=datasets.MNIST(root='dataset/',train=True,transform=transforms.ToTensor(),download=True)
Test_dataset=datasets.MNIST(root='dataset/',train=False,transform=transforms.ToTensor(),download=True)

Train_loader=DataLoader(dataset=Train_dataset,batch_size=batch_size,shuffle=True)
Test_loader=DataLoader(dataset=Train_dataset,batch_size=len(Test_dataset),shuffle=False)
#设置训配置
device=torch.device('cuda' if torch.cuda.is_available() else 'cpu')


#搭建神经网络架构
class NeuralNet(nn.Module):  #创建一个类
    def __init__(self,num_input,num_hidden,num_class):
        super(NeuralNet, self).__init__()      #此三行都是固定格式
        self.fc1=nn.Linear(num_input,num_hidden)  #第一个全连接层
        self.fc2=nn.Linear(num_hidden,num_class)  #第二个全连接层
        self.act=nn.ReLU()  #激活函数
    #定义前传函数
    def forward(self,x):  #self代表的是类的实体，x 代表图片
        x=self.fc1(x)  #先把传入的x送入到全连接层，得到的隐藏层的输入结果
        x=self.act(x)  #再把隐藏层的结果送到激活函数里面，
        x=self.fc2(x)  #把上一步的激活函数得到的结果放入到第二层全连接层里面
        #应该在此行再放一层激活函数。但是在后面的损失函数里面已经包含了激活函数softmax，故可以省略
        return x

# model=NeuralNet(num_input,num_hidden,num_class)
# x=torch.rand(64,28*28) #给64张图片，每张图片是28*28的格式输入
# y=model(x)
# print(y.shape)  #torch.Size([64, 10])  64：代表64张图片。10：代表10个类别
#初始化架构
model=NeuralNet(num_input,num_hidden,num_class)
#定义损失函数和优化器
LossF=nn.CrossEntropyLoss()  #使用交叉熵定义损失函数
optimizer=torch.optim.Adam(model.parameters(),lr=learning_rate)  #定义优化器，第一个参数是优化所有参数，第二个是优化学习率

#训练
for epoch in range(num_epochs):
    for batch_index,(images,labels) in enumerate(Train_loader):
        images=images.reshape(-1,28*28).to(device) #64*1*28*28--->>64*784
        labels=labels.to(device)
        output=model(images)  #把图片images放入到model模型中


        #计算损失函数
        loss=LossF(output,labels)


        #梯度的向后传播
        optimizer.zero_grad()  #优化器清空
        loss.backward() #损失函数，梯度的向后传播
        optimizer.step() #优化器的更新

        if batch_index%100==0:
            print('[{}/{}],[{}/{}],loss={:.4f}'.format(epoch,num_epochs,batch_index,len(Train_loader),loss))

#测试
with torch.no_grad():  #在测试的时候必须使用这个方法让里面的参数不能再进行迭代了
    correct_num=0
    total_num=0
    for images,labels in Test_loader:
        images=images.reshape(-1,28*28).to(device)
        labels=labels.to(device)  #送到device设备上训练
        outputs=model(images)  #10000*10
        _,predictions=torch.max(outputs,1) #1 代表10这个维度，0代表10000这个维度
        #[0.001,0.02.....0.9,0.1]-->8
        correct_num+=(predictions==labels).sum()
        total_num+=(predictions.size(0))
        print("测试的精度:{}%".format(correct_num/total_num*100))