Pytroch搭建全连接神经网络识别MNIST手写数字数据集

编写步骤

之前已经记录国多次的编写步骤了，无需多言。
（1）准备数据集
这里我们使用MNIST数据集，有官方下载渠道。我们直接使用torchvison里面提供的数据读取功能包就行。如果不使用这个，自己像这样子构建也一样。

# 自己构建数据读取模块
#(1) 数据读取模块
class Mydataset(Dataset):
    def __init__(self,filepath):
        xy=np.loadtxt(filepath,delimiter=',',dtype=np.float32)
        self.len=xy.shape[0]
        self.x_data=torch.from_numpy(xy[:,:-1])
        self.y_data=torch.from_numpy(xy[:,[-1]])
    #魔法方法，容许用户通过索引index得到值
    def __getitem__(self,index):
        return self.x_data[index],self.y_data[index]
    def __len__(self):
        return self.len

这里直接使用torchvison里面的工具

#准备数据集
batch_size = 64
transforms = transforms.Compose([transforms.ToTensor(),
                                transforms.Normalize((0.1307,),(0.3081,))])

trainset = torchvision.datasets.MNIST(root=r'../data/mnist',
                                      train=True,
                                      download=True,
                                      transform=transforms)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True)



testset = torchvision.datasets.MNIST(root=r'../data/mnist',
                                     train=False,
                                     download=True,
                                     transform=transforms)
testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False)

(2) 构建模型
这次我们使用不带dropout的全连接模型

# 定义模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.linear1 = nn.Linear(784, 100)
        self.linear2 = nn.Linear(100, 20)
        self.linear3 = nn.Linear(20, 10)
    def forward(self, x):
        x=x.view(x.size(0), -1)
        x = F.relu(self.linear1(x))
        x = F.relu(self.linear2(x))
        x = self.linear3(x)
        return x

(3) 选择损失和优化器

# 构建模型和损失
model=Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

（4）训练模型

def train(epoch):
    running_loss = 0.0
    for batch_idx, (inputs, targets) in enumerate(trainloader):
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()
        #需要将张量转换为浮点数运算
        running_loss += loss.item()
        if batch_idx % 100 == 0:
            print('Train Epoch: {}, Loss: {:.6f}'.format(epoch, loss.item()))
            running_loss = 0

（5）测试模型

def test(epoch):
    correct = 0
    total = 0
    with torch.no_grad():
        for batch_idx, (inputs, targets) in enumerate(testloader):
            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, 1)
            total += targets.size(0)
            correct=correct+(predicted.eq(targets).sum()*1.0)
    print('Accuracy of the network on the 10000 test images: %d %%' % (100*correct/total))

全部代码

import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
import torch.optim as optim
#准备数据集
batch_size = 64
transforms = transforms.Compose([transforms.ToTensor(),
                                transforms.Normalize((0.1307,),(0.3081,))])

trainset = torchvision.datasets.MNIST(root=r'../data/mnist',
                                      train=True,
                                      download=True,
                                      transform=transforms)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True)



testset = torchvision.datasets.MNIST(root=r'../data/mnist',
                                     train=False,
                                     download=True,
                                     transform=transforms)
testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False)

# 定义模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.linear1 = nn.Linear(784, 100)
        self.linear2 = nn.Linear(100, 20)
        self.linear3 = nn.Linear(20, 10)
    def forward(self, x):
        x=x.view(x.size(0), -1)
        x = F.relu(self.linear1(x))
        x = F.relu(self.linear2(x))
        x = self.linear3(x)
        return x
# 构建模型和损失
model=Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

def train(epoch):
    running_loss = 0.0
    for batch_idx, (inputs, targets) in enumerate(trainloader):
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()
        #需要将张量转换为浮点数运算
        running_loss += loss.item()
        if batch_idx % 100 == 0:
            print('Train Epoch: {}, Loss: {:.6f}'.format(epoch, loss.item()))
            running_loss = 0
def test(epoch):
    correct = 0
    total = 0
    with torch.no_grad():
        for batch_idx, (inputs, targets) in enumerate(testloader):
            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, 1)
            total += targets.size(0)
            correct=correct+(predicted.eq(targets).sum()*1.0)
    print('Accuracy of the network on the 10000 test images: %d %%' % (100*correct/total))
if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)
        test(epoch)