Handwritten character recognition

import numpy as np
import torch
from torchvision.datasets import mnist # Import pytorch Built in mnist data
from torch import nn
from torch.autograd import Variable

Download datasets

train_set=mnist.MNIST('./data',train=True,download=True)
test_set=mnist.MNIST('./data',train=False,download=True)

a_data,a_lable=train_set[0] # Show the first data

a_data

a_lable

 # The data read in earlier is pil Cut view in Library , Convert it to numpy array

a_data=np.array(a_data,dtype='float32')       
print(a_data.shape) 

print(a_data) 

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_lable=train_set[0]
print(a.shape)
print(a_lable)

 

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)

a,a_lable=next(iter(train_data))# use iter Convert array to lterator,next Will continue to return to the next element

print(a.shape)
print(a_lable.shape)

 

# Use Sequential Definition 4 Layer neural networks
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)
)

criterion=nn.CrossEntropyLoss()
optimizer=torch.optim.SGD(net.parameters(),1e-1)

losses=[]
acces=[]
eval_losses=[]
eval_acces=[]
for e in range(20):
    train_loss=0
    train_acc=0
    net.train()
    for im,lable in train_data:
        im=Variable(im)
        lable=Variable(lable)
        out=net(im)
        loss=criterion(out,lable)
        optimizer.zero_grad()
        loss.backward()
        train_loss+=loss.item()
        _,pred=out.max(1)
        num_correct=(pred==lable).sum().item()  # Statistical labels and the correctness of labels
        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, lable in test_data:
        im=Variable(im)
        lable=Variable(lable)
        out=net(im)
        loss=criterion(out,lable)
        eval_loss+=loss.item()
        _,pred=out.max(1)
        num_correct=(pred==lable).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}, EvalAcc: {:.6f}'.format(e, train_loss / len(train_data), train_acc / len(train_data),
eval_loss / len(test_data), eval_acc / len(test_data)))

 

We can draw it train loss,train acc,test loss,test acc Graph