pytorch CNN手写字体识别

## """CNN手写字体识别"""

import torch
import torch.nn as nn
from torch.autograd import Variable
import torch.utils.data as Data
import torchvision       #其中包括一些数据库（图片...）
import matplotlib.pyplot as plt


#超参数
EPOCH = 1                            #总数据循环的次数
BATCH_SIZE = 50                #每次训练50个数据
LR = 0.001                    #学习率
DOWNLOAD_MNIST = False    #已经下好数据 则用False

train_data = torchvision.datasets.MNIST(                                                 #下载手写数据训练集
    root='./mnist',
    train=True,  #获得其中的训练数据
    transform=torchvision.transforms.ToTensor(),  #下载的数据格式改成tensor格式,数据的值  （0-255）压缩到(0-1)
    download=DOWNLOAD_MNIST
)

#画图工具显示其中一个图片
# print(train_data.train_data.size())     #(60000, 28, 28)
# print(train_data.train_labels.size())   #(60000)
# pause=input("Continue")
# plt.imshow(train_data.train_data[0].numpy(),cmap='gray')  #呈现其中的第一张图片
# plt.title('%i' % train_data.train_labels[0])
# plt.show()

train_loader = Data.DataLoader(                                      #批处理
    dataset=train_data,
    batch_size=BATCH_SIZE,
    shuffle=True,   #训练的时候，要不要随机打乱数据
)

#训练集
test_data = torchvision.datasets.MNIST(
    root='./mnist',train=False
)

test_x = Variable(torch.unsqueeze(test_data.test_data, dim=1), volatile=True).type(torch.FloatTensor)[:2000]/255.   #压缩到（0-1）
test_y = test_data.test_labels[:2000]

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(           #图片的维度是（1,28,28）
                in_channels=1,           #图片的高度也就是层数
                out_channels=16,        #fittle的个数（相当于卷积核的个数） 相当于16个卷积核同时扫描
                kernel_size=5,          #卷积核的大小   5*5
                stride=1,               #卷积核每隔多少步跳一下  相当于步长
                padding=2,              #边缘填充  不够补零  如果stride = 1   padding = (kernel_size-1)/2
            ),   # ->  (16,28,28)
            nn.ReLU(),                      #激活层    # ->  (16,28,28)
            nn.MaxPool2d(              # ->  (16,14,14)
                kernel_size=2
            ),
        )
        self.conv2 = nn.Sequential(                 # ->  (16,14,14)
            nn.Conv2d(16, 32, 5, 1, 2),               # ->  (32,14,14)
            nn.ReLU(),                    # ->  (32,14,14)
            nn.MaxPool2d(2)              # ->  (32,7,7)
        )
        self.out = nn.Linear(32 * 7 * 7, 10)          #辗平  （10 代表分类的个数  这里是手写数字识别  所以有是个分类）

    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)    #（batch, 32, 7, 7） 考虑batch的维度
        x = x.view(x.size(0),-1)      #(batch, 32 * 7 * 7 )    ( -1 的作用就是把矩阵辗平)  x.size(0):作用是把batch的维度保留
        output = self.out(x)
        return output

cnn = CNN()
# print(cnn)
optimizer = torch.optim.Adam(cnn.parameters(), lr=LR)
loss_func = nn.CrossEntropyLoss()

for epoch in range(EPOCH):
    for step, (x, y) in enumerate(train_loader):
        output = cnn(x)
        loss = loss_func(output, y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        # print(step)
        if step % 50 == 0:
            test_output = cnn(test_x)
            pred_y = torch.max(test_output, 1)[1].data.squeeze()
            # print(sum(pred_y == test_y))
            # print(test_y.size(0))
            accuracy = sum(pred_y == test_y) / test_y.size(0)
            # accuracy = float((pred_y == test_y.data.numpy()).astype(int).sum()) / float(test_y.size(0))
            # print("Epoch: ", epoch, "| train loss: %.4f" % loss.item(), "| test accuracy: %.4f", accuracy)
            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.numpy(), '| test accuracy: %f' % accuracy)    #每50 step 输出一次结果  每次数据集迭代24 次   所以总数据为 24 * 50 * 50

test_output = cnn(test_x[:10])    #前十个看预测的标签
pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()
print(pred_y,"prediction number")
print(test_y[:10].numpy(), "real number")

数据整体训练一次，对于accuracy都是0的问题，由于刚开始学，有些代码的细节我也没看懂，不过整体结果是对的，可能是由于pytorch版本的更新，导致accuracy的计算方式有所改变

内容转载自：https://www.bilibili.com/video/av15997678/?p=19