pytorch 卷积神经网络-MNIST数据集

import torch
import torch.nn as nn
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader

batch_size = 64
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, ))])
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

train_dataset = datasets.MNIST(root="/dataset", train=True, transform=transform)
train_Dataloader = DataLoader(dataset=train_dataset, shuffle=True, batch_size=batch_size, num_workers=6)
test_dataset = datasets.MNIST(root="/dataset", train=False, transform=transform)
test_Dataloader = DataLoader(dataset=test_dataset, shuffle=True, batch_size=batch_size, num_workers=6)

class Module(nn.Module):
    def __init__(self):
        super(Module, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
        self.pooling = nn.MaxPool2d(2)
        self.relu = nn.ReLU()
        self.fc = nn.Linear(320, 10)
    def forward(self, x):
        batch_size = len(x)
        x = self.relu(self.pooling(self.conv1(x)))
        x = self.relu(self.pooling(self.conv2(x)))
        x = x.view(batch_size, -1)
        x = self.fc(x)
        return x


model = Module()
model.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.5)


def train(epoch):
    loss_running = 0.0
    for batch_Idx, data in enumerate(train_Dataloader):
        inputs, labels = data[0].to(device), data[1].to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loos = criterion(outputs, labels)
        loos.backward()
        optimizer.step()
        loss_running += loos.item()
        if batch_Idx % 300 == 299:
            print('[%d , %5d] loss : %.3f' % (epoch+1, batch_Idx+1, loss_running/300))
            loss_running = 0.0

def test():
    correct = 0.0
    total = 0.0
    with torch.no_grad():
        for data in test_Dataloader:
            images, labels = data[0].to(device), data[1].to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs, dim=1)
            total += len(labels)
            correct += (predicted == labels).sum().item()
        print('Accuracy of the network on the 10000 test images:  %d %%' % (correct*100/total))


if __name__ == '__main__':
    for epoch in range(100):
        train(epoch)
        test()

这里处理的准确率能达到98%

通过增加卷积层，池化层和全连接层还可以提升

import numpy
import torch
import torch.nn as nn
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt

batch_size = 64
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, ))])
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

train_dataset = datasets.MNIST(root="/dataset", train=True, transform=transform)
train_Dataloader = DataLoader(dataset=train_dataset, shuffle=True, batch_size=batch_size, num_workers=6)
test_dataset = datasets.MNIST(root="/dataset", train=False, transform=transform)
test_Dataloader = DataLoader(dataset=test_dataset, shuffle=True, batch_size=batch_size, num_workers=6)

class Module(nn.Module):
    def __init__(self):
        super(Module, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=3)
        self.conv3 = nn.Conv2d(20, 30, kernel_size=4)
        self.pooling = nn.MaxPool2d(2)
        self.relu = nn.ReLU()
        self.fc1 = nn.Linear(30, 64)
        self.fc2 = nn.Linear(64, 16)
        self.fc3 = nn.Linear(16, 10)
    def forward(self, x):
        batch_size = len(x)
        x = self.relu(self.pooling(self.conv1(x)))
        x = self.relu(self.pooling(self.conv2(x)))
        x = self.relu(self.pooling(self.conv3(x)))
        x = x.view(batch_size, -1)
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x


model = Module()
model.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.5)


def train(epoch):
    loss_running = 0.0
    rem = 0
    for batch_Idx, data in enumerate(train_Dataloader):
        inputs, labels = data[0].to(device), data[1].to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loos = criterion(outputs, labels)
        loos.backward()
        optimizer.step()
        loss_running += loos.item()
        if batch_Idx % 300 == 299:
            print('[%d , %5d] loss : %.6f' % (epoch+1, batch_Idx+1, loss_running/300))
            rem += loss_running/300
            loss_running = 0.0
    return rem/3
def test():
    correct = 0.0
    total = 0.0
    with torch.no_grad():
        for data in test_Dataloader:
            images, labels = data[0].to(device), data[1].to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs, dim=1)
            total += len(labels)
            correct += (predicted == labels).sum().item()
        print('Accuracy of the network on the 900 test images:  %d %%' % (correct*100/total))
        return correct*100/total





loss_List = []
Accuracy_list = []
epoch_list = numpy.arange(100)

if __name__ == '__main__':
    for epoch in range(100):
       loss_List.append(train(epoch))
       Accuracy_list.append(test())

    print(epoch_list)
    print(loss_List)
    print(Accuracy_list)
    plt.plot(epoch_list, loss_List, c='red')
    plt.xlabel("epoch")
    plt.ylabel("loss_List")
    plt.show()


    plt.plot(epoch_list, Accuracy_list, c='blue')
    plt.xlabel("epoch")
    plt.ylabel("AC")
    plt.show()

 这样已经达到了99当然还可以优化