手写体识别识别（pytorch）：

手写体识别识别：

​ 因为前段日子记录过tensorflow的手写体识别，所以这里就对pytorch的手写体识别学习记录简单的记录以下。

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets
from torchvision import transforms
from torch.autograd import Variable

batch_size = 64
epoch = 5
LR = 0.001
# 获取手写数字的训练集和测试集
train_dataset = datasets.MNIST(root='./res/data',
                               transform=transforms.ToTensor(),  #转换类型
                               train=True,                       #如果是True则从training.pt创建数据集，否则来自test.pt。
                               download=True)                    #为True时，下载数据集
test_dataset = datasets.MNIST(root='./res/data',
                              transform=transforms.ToTensor(),
                              download=True)

train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True)         #为True时，打乱数据集
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                          batch_size=batch_size,
                                          shuffle=True)


# 定义网络结构
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        #继承父类，即此处的nn.Module
        self.conv1 = nn.Sequential(nn.Conv2d(1, 6, 3, 1, 2), nn.ReLU(),
                                nn.MaxPool2d(2, 2))
        '''
        nn.Sequential()表示将一系列操作打包   nn.Conv2d()表示对由多个输入平面组成的输入信号进行二维卷积
        nn.ReLU(inplace=True)中，inplace = True时，改变输入状态，否则只产生新的输出
        nn.MaxPool2d（）对邻域内特征点取最大，减小卷积层参数误差造成估计均值的偏移的误差，更多的保留纹理信息。
        
        '''

        self.conv2 = nn.Sequential(nn.Conv2d(6, 16, 5), nn.ReLU(),
                                   nn.MaxPool2d(2, 2))
        self.fc1 = nn.Sequential(nn.Linear(16 * 5 * 5, 120),
                                 nn.BatchNorm1d(120), nn.ReLU())
        '''
        nn.Linear(120, 84)就是制造出一个全连接层的框架，即y=X*W.T + b，对给定一个具体的输入X，就会输出相应的y
        nn.BatchNorm1d()实现归一化
        
        '''
        self.fc2 = nn.Sequential(nn.Linear(120, 84), nn.BatchNorm1d(84),
                                 nn.ReLU(), nn.Linear(84, 10))

        #前向传播
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size()[0], -1)
        #x.view(x.size()[0], -1)将前面多维度的tensor展平成一维
        x = self.fc1(x)
        x = self.fc2(x)
        return x


        # 训练模型
net = Net()
criterion = nn.CrossEntropyLoss()                 #损失函数
optimizer = optim.Adam(net.parameters(), lr=LR)   #优化器

for epoch in range(epoch):
    sum_loss = 0.0
    for i, data in enumerate(train_loader):
        inputs, labels = data
        inputs, labels = Variable(inputs), Variable(labels)
        optimizer.zero_grad()      #将数据梯度归零
        outputs = net(inputs)      #前向传播预测值
        loss = criterion(outputs, labels)
        loss.backward()            #反向传播
        optimizer.step()           #根据梯度下降进行数据更新
        sum_loss += loss.item()    #求总的loss
        if i % 100 == 99:
            print("[%d, %d] loss is %.03f" %
                  (epoch + 1, i + 1, sum_loss / 100))    #打印平均的loss
            sum_loss = 0.0
            
    # 测试模型与训练模型相同
    net.eval()
    correct = 0
    for data_test in test_loader:
        images, labels = data_test
        images, labels = Variable(images), Variable(labels)
        output_test = net(images)
        _, pred = torch.max(output_test, 1)
        correct += (pred == labels).sum()
    print("Test acc is {}".format(correct.item()/len(test_dataset)))

思路：

1.首先确定输入量、学习率等

2.获取手写体识别的数据集，构成训练集和测试集

3.定义卷积神经网络，本文定义2卷积层、2完全连接层，对应对应的conv、fc

4.再进行前向传播，得到预测的x

5.再定义相应的交叉熵、优化器对数据进行处理

6.最后进行训练和测试，即反向传播不断更新各个数据的值，以达最优解