手写字识别代码_手写体识别代码

import numpy as np
import torch
from torchvision.datasets import mnist#导入pytorch内置的mnist数据
from torch import nn
from torch.autograd import Variable

#使用内置函数下载mnist数据集
train_set=mnist.MNIST('./data',train=True,download=True)
test_set=mnist.MNIST('./data',train=False,download=True)

a_data,a_label=train_set[0]
a_data

a_label

#转换成numpy array格式
a_data=np.array(a_data,dtype='float32')
print(a_data.shape)

print(a_data)

#对于神经网络，我们第一层的输入就是28*28=784，所以必须用reshape将其拉成一个一维数组
def data_tf(x):
    x=np.array(x,dtype='float32')/255
    x=(x-0.5)/0.5#标准化
    x=x.reshape((-1,))#拉平
    x=torch.from_numpy(x)
    return x
#重新载入数据集，申明定义的数据变换
train_set=mnist.MNIST('./data',train=True,transform=data_tf,download=True)
test_set=mnist.MNIST('./data',train=False,transform=data_tf,download=True)

a,a_label=train_set[0]
print(a.shape)
print(a_label)

#使用pytorch自带的DataLoader定义一个数据迭代器
from torch.utils.data import DataLoader
train_data=DataLoader(train_set,batch_size=64,shuffle=True)
test_data=DataLoader(test_set,batch_size=128,shuffle=False)
#由于数据量太大，无法一次全部读入内存，所以需要使用python迭代器，每次生成一个批次的数据
a,a_label=next(iter(train_data))
#打印出一个批次的数据大小
print(a.shape)
print(a_label.shape)

#使用Sequential定义4层神经网络
net=nn.Sequential(
    nn.Linear(784,400),
    nn.ReLU(),
    nn.Linear(400,200),
    nn.ReLU(),
    nn.Linear(200,100),
    nn.ReLU(),
    nn.Linear(100,10)
)
net

#定义loss函数，采用的是交叉熵损失函数
criterion=nn.CrossEntropyLoss()
optimizer=torch.optim.SGD(net.parameters(),1e-1)#使用梯度下降，学习率0.1

#开始训练
losses=[]
acces=[]
eval_losses=[]
eval_acces=[]
for e in range(20):
    train_loss=0
    train_acc=0
    net.train()
    for im,label in train_data:
        im=Variable(im)
        label=Variable(label)
        #向前传播
        out=net(im)
        loss=criterion(out,label)
        #反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        #记录误差
        train_loss+=loss.item()
        #计算分类的准确率
        _,pred=out.max(1)
        num_correct=(pred==label).sum().item()
        acc=num_correct/im.shape[0]
        train_acc+=acc
    losses.append(train_loss/len(train_data))
    acces.append(train_acc/len(train_data))
    #在测试集上检验效果
    eval_loss=0
    eval_acc=0
    net.eval()#将模型改为预测模型
    for im, label in test_data:
        im=Variable(im)
        label=Variable(label)
        out=net(im)
        loss=criterion(out,label)
        #记录误差
        eval_loss+=loss.item()
        #记录准确率
        _,pred=out.max(1) 
        num_correct=(pred==label).sum().item()
        acc=num_correct/im.shape[0]
        eval_acc+=acc
    eval_losses.append(eval_loss/len(test_data))
    eval_acces.append(eval_acc/len(test_data))
    print('epoch:{},Train Loss:{:.6f},Train Acc:{:.6f},Eval Loss:{:.6f},Eval Acc:{:.6f}'.format(e,train_loss/len(train_data),train_acc/len(train_data),eval_loss/len(test_data),eval_acc/len(test_data)))

#画出loss曲线和准确率曲线
import matplotlib.pyplot as plt
%matplotlib inline
plt.title('train loss')
plt.plot(np.arange(len(losses)),losses)
plt.title('train acc')
plt.plot(np.arange(len(acces)),acces)
plt.title('test loss')
plt.plot(np.arange(len(eval_losses)),eval_losses)
plt.title('test acc')
plt.plot(np.arange(len(eval_acces)),eval_acces)