手写数字识别-卷积（pytorch ）

import torch
import numpy as np
from torch import nn,optim
from torch.autograd import Variable
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

#训练集
#数据直接载入
train_dataset = datasets.MNIST('./',
                               train=True,
                               transform=transforms.ToTensor(),
                               download=True)

#测试集
test_dataset = datasets.MNIST('./',
                               train=False,
                               transform=transforms.ToTensor(),
                               download=True)
#批次大小
batch_size=64
#装载训练集
train_loader = DataLoader(dataset=train_dataset,
                          batch_size=batch_size,
                          shuffle=True)
#装载测试集
test_loader = DataLoader(dataset=test_dataset,
                          batch_size=batch_size,
                          shuffle=True)
#定义网络结构
class Conv(nn.Module):
    def __init__(self):
        super(Conv, self).__init__()
        #初始化
        self.conv1 = nn.Sequential(nn.Conv2d(1,32,5,1,2),nn.ReLU(),nn.MaxPool2d(2,2))
        #第一层结构：卷积层-激活函数-最大池化层
        self.conv2 = nn.Sequential(nn.Conv2d(32,64,5,1,2),nn.ReLU(),nn.MaxPool2d(2,2))
        #第二层结构：卷积层-激活函数-最大池化层
        self.fc1 = nn.Sequential(nn.Linear(64*7*7,1000),nn.Dropout(p=0.5),nn.ReLU())
        
        self.fc2 = nn.Sequential(nn.Linear(1000,10),nn.Softmax(dim=1))
        
        
    def forward(self,x):
        #([64,1,28,28])
        #卷积运算需要的结构是([64,1,28,28])4维
        x=self.conv1(x)
        x=self.conv2(x)
        #全连接层需要的数据结构是2维
        #更改数据结构
        x= x.view(x.size()[0],-1)

        x= self.fc1(x)
        x= self.fc2(x)
        #结果为2维
        return x
LR = 0.001
#定义模型
model = Conv()
#定义代价函数
mse_loss = nn.CrossEntropyLoss()
#定义优化器
#学习率
optimizer = optim.Adam(model.parameters(),LR)

def train():
    for i,data in enumerate(train_loader):
        #获得一个批次的数据和标签
        inputs, labels = data
        #获得模型预测结果（64，10）
        out = model(inputs)
        #把数据标签变成独热编码
        labels = labels.reshape(-1,1)
        #tensor.scatter(dim,index,src)
        #dim 对哪个维度进行独热编码
        #index 将src中的对应值放到tensor的哪个位置
        #src 插入index的值
        one_hot = torch.zeros(inputs.shape[0],10).scatter(1,labels,1)
        #计算loss ,mse_loss的两个数据shape要一致
        loss = mse_loss(out,one_hot)
        #梯度清零
        optimizer.zero_grad()
        #计算梯度
        loss.backward()
        #修改权值
def test():
    correct = 0
    for i,data in enumerate(test_loader):
        inputs, labels =data
        out = model(inputs)
        _, predicted =torch.max(out, 1)
        correct+=(predicted == labels).sum()
    print("Test acc:{0}".format(correct.item()/len(test_dataset)))
        optimizer.step()

for epoch in range(10):
    print('epoch:',epoch+1)
    train()
    test()