Pytorch 手写数字识别

import torch
from torchvision import datasets,transforms
import matplotlib.pyplot as plt
import torchvision

from torch.autograd import Variable
#数据格式转化为Tensor
transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize(mean=(0.5,0.5,0.5),std=(0.5,0.5,0.5))])
#xnormalize=(x-mean)/std
#下载数数据集
data_train=datasets.MNIST(root="./data/",transform=transform,train=True,download=True)
data_test=datasets.MNIST(root="./data/",transform=transform,train=False)

#数据数载
data_loader_train=torch.utils.data.DataLoader(dataset=data_train,batch_size=64,shuffle=True)
data_loader_test=torch.utils.data.DataLoader(dataset=data_test,batch_size=64,shuffle=True)
#数据为四维的[batch_size,channe,height,widel]

#数据预临览
images,labels=next(iter(data_loader_train))
#  Get an iterator from an object.
#  next() Return the next item from the iterator

img=torchvision.utils.make_grid(images)
#数据的[channe,height,widel]
img=img.numpy().transpose(1,2,0)#数据[height,widel,channe]
std=[0.5,0.5,0.5]
mean=[0.5,0.5,0.5]
img=img*std+mean
print([labels[i] for i in range(64)])
# plt.imshow(img)
# plt.show()

# 卷积神经网洛构建
class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.conv1=torch.nn.Sequential(
            torch.nn.Conv2d(in_channels=1,out_channels=64,kernel_size=3,stride=1,padding=1),
            #[batch_size,1,8,8]->#[batch_size,64,8,8]
            torch.nn.ReLU(),
            torch.nn.Conv2d(in_channels=64,out_channels=128,kernel_size=3,stride=1,padding=1),
            # [batch_size,128,8,8]
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(kernel_size=2,stride=2,padding=0)
            # [batch_size,128,4,4]

        )
        self.dense=torch.nn.Sequential(
            torch.nn.Linear(14*14*128,1024),
            torch.nn.ReLU(),
            torch.nn.Dropout(p=0.5),
            torch.nn.Linear(1024,10)
        )

    def forward(self, x):
        x = self.conv1(x)
        x = x.view(-1, 14 * 14 * 128)
        x = self.dense(x)
        return x
#模型训练和优化
#1.构建模型
model=Model()
cost=torch.nn.CrossEntropyLoss()
optimizer=torch.optim.Adam(model.parameters())

print(model)

#2。训练
n_epochs=5
for epoch in range(n_epochs):
    running_loss=0
    running_correct=0
    print("Epoch{}/{}".format(epoch,n_epochs))
    print("-"*10)

    for data in data_loader_train:
        X_train, y_train=data
        X_train,y_train=Variable(X_train),Variable(y_train)
        outputs=model(X_train)
        _,pred=torch.max(outputs.data,1)
        optimizer.zero_grad()
        loss=cost(outputs,y_train)
        loss.backward()
        optimizer.step()
        running_loss+=loss.data
        running_correct+=torch.sum(pred==y_train.data)
    testing_correct=0
    for data in data_loader_test:
        X_test,y_test=data
        X_test,y_test=Variable(X_test),Variable(y_test)
        outputs=model(X_test)
        _,pred=torch.max(outputs.data,1)
        testing_correct+=torch.sum(pred==y_test.data)
    print("Loss is:{:.4f},Train Accuracy is{:.4f}%，Test Accuracy is:{:.4f}". \
      format((running_loss)/len(data_train),100*running_correct/len(data_train),
             100*testing_correct/len(data_test)))