识别mnist手写数据集

识别mnist手写数据集

加载数据集

#转变数形
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307, ),(0.3081, )) ])
#加载数据
batch_size = 4
train_dataset = datasets.MNIST(root='../data/j/', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)
test_dataset = datasets.MNIST(root='../data/j/', train=False, download=True, transform=transform)
test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)

神经网络模型

class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.l1 = torch.nn.Linear(784, 512)
        self.l2 = torch.nn.Linear(512, 256)
        self.l3 = torch.nn.Linear(256, 128)
        self.l4 = torch.nn.Linear(128, 64)
        self.l5 = torch.nn.Linear(64, 10)
    #前向传播
    def forward(self, x):
        x = x.view(-1, 784)
        x = F.relu(self.l1(x))
        x = F.relu(self.l2(x))
        x = F.relu(self.l3(x))
        x = F.relu(self.l4(x))
        return self.l5(x)

代码

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
batch_size = 4
#转变数形
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307, ),(0.3081, )) ])
#加载数据
train_dataset = datasets.MNIST(root='../data/j/', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)
test_dataset = datasets.MNIST(root='../data/j/', train=False, download=True, transform=transform)
test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)

#神经网络模型
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.l1 = torch.nn.Linear(784, 512)
        self.l2 = torch.nn.Linear(512, 256)
        self.l3 = torch.nn.Linear(256, 128)
        self.l4 = torch.nn.Linear(128, 64)
        self.l5 = torch.nn.Linear(64, 10)
    #前向传播
    def forward(self, x):
        x = x.view(-1, 784)
        x = F.relu(self.l1(x))
        x = F.relu(self.l2(x))
        x = F.relu(self.l3(x))
        x = F.relu(self.l4(x))
        return self.l5(x)

model = Net()
#损失函数
criterion = torch.nn.CrossEntropyLoss()
#优化器
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

#神经网络训练
def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        #数据
        inputs, target = data
        #梯度清0
        optimizer.zero_grad()
        #前向传播
        outputs = model(inputs)
        #计算损失
        loss = criterion(outputs, target)
        #反向传播
        loss.backward()
        #更新参数
        optimizer.step()
        running_loss += loss.item()
        if batch_idx % 300 == 299:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0

#测试
def test(modele):
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            outputs = modele(images)
            _, predicted = torch.max(outputs.data, dim=1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print('识别正确率为: %d %%' % (100 * correct / total))

#提取训练数据
def restore_net():
    net2=torch.load('modeltrain.plk')
    return net2



#测试2
def recotes():
    dataiter=iter(train_loader)
    img,lables=dataiter.next()
    net2 = restore_net()
    #test(net2)
    im=img
    for im in img:
        im = np.array(im)
        im = im.reshape(28, 28)
        plt.imshow(im, cmap='gray')
        plt.show()
    print('实际标签'+str(lables))
    outputs = net2(img)
    _, predicted = torch.max(outputs.data, dim=1)
    print('预测标签'+str(predicted))

if __name__ == '__main__':
    '''
    for epoch in range(5):
        train(epoch)
    #保存训练结果
    #torch.save(model,'modeltrain.plk')
    '''
    net2 = restore_net()
    test(net2)
    recotes()

运行结果