多层全连接神经网络实现minist手写数字分类

import torch
import numpy as np
import torch.nn as nn
from torch.autograd import Variable
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

batch_size = 64
learning_rate = 1e-2
num_epoches = 20

data_tf = transforms.Compose([transforms.ToTensor(), transforms.Normalize([0.5],[0.5])])
#transform.Compose()  将各种预处理操作组合在一起
#transform.ToTensor() 将数据转化为Tensor类型，并自动标准化，Tensor的取值是（0，1）
#transform.Normalize()是标准化操作，类似正太分布的标准化，第一个值是均值，第二个值是方差
#如果图像是三个通道，则transform.Normalize([a,b,c],[d,e,f])

train_dataset = datasets.MNIST(root = './mnist_data', train = True, transform = data_tf, download = True) #用datasets加载数据集，传入预处理
test_dataset  = datasets.MNIST(root = './mnist_data', train = False,transform = data_tf)
train_loader  = DataLoader(train_dataset, batch_size = batch_size, shuffle = True)    #利用DataLoader建立一个数据迭代器
test_loader   = DataLoader(test_dataset,  batch_size = batch_size, shuffle = False)

class Batch_Net(nn.Module):
    def __init__(self, inputdim, hidden1, hidden2, outputdim):
        super(Batch_Net, self).__init__()
        self.layer1 = nn.Sequential(nn.Linear(inputdim, hidden1), nn.BatchNorm1d(hidden1), nn.ReLU(True))
        self.layer2 = nn.Sequential(nn.Linear(hidden1, hidden2), nn.BatchNorm1d(hidden2), nn.ReLU(True))
        self.layer3 = nn.Sequential(nn.Linear(hidden2, outputdim))

    def forward(self, x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        return x

model = Batch_Net(28*28, 300, 100, 10)
model

定义损失函数和优化器

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr = learning_rate)

训练模型

for epoch in range(num_epoches):
    train_loss = 0
    train_acc = 0
    model.train()   #这句话会自动调整batch_normalize和dropout值，很关键！
    for img, label in train_loader:
        img = img.view(img.size(0), -1)   #将数据扁平化为一维
        img = Variable(img)
        label = Variable(label)
        # 前向传播
        out = model(img)
        loss = criterion(out, label)
        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        # 记录误差
        train_loss += loss.item()
        # 计算分类的准确率
        _, pred = out.max(1)
        num_correct = (pred == label).sum().item()
        acc = num_correct / img.shape[0]
        train_acc += acc

    print('epoch:{},train_loss:{:.6f},acc:{:.6f}'.format(epoch+1, train_loss/len(train_loader), train_acc/len(train_loader)))

epoch:1,train_loss:0.002079,acc:0.999767
......　　
epoch:19,train_loss:0.001532,acc:0.999917
epoch:20,train_loss:0.001670,acc:0.999850

测试集

model.eval()  #在评估模型时使用，固定BN 和 Dropout
eval_loss = 0
val_acc  = 0
for img , label in test_loader:
    img = img.view(img.size(0), -1)
    img = Variable(img, volatile = True)   #volatile=TRUE表示前向传播是不会保留缓存，因为测试集不需要反向传播
    label = Variable(label, volatile = True)
    out = model(img)
    loss = criterion(out, label)
    eval_loss += loss.item()
    _,pred = torch.max(out, 1)
    num_correct = (pred == label).sum().item()
    print(num_correct)
    eval_acc = num_correct / label.shape[0]
    val_acc += eval_acc

print('Test Loss:{:.6f}, Acc:{:.6f}'.format(eval_loss/len(test_loader), val_acc/len(test_loader)))
    

Test Loss:0.062413, Acc:0.981091