Pytorch学习笔记-FCNN实现Mnist数据集分类

目录

Part1​​​​​

Part2

Part3

Part4

Part5

Part6 完整代码

Result:(Pycharm, Jupyter Notebook)

---

​​​​​​​

Part1​​​​​

from torchvision import transforms
transform = transforms.Compose([
    transforms.ToTensor(), 
    transforms.Normalize((0.1307, ), (0.3081, ))
])

transforms.ToTensor()的作用是：将shape为(H, W, C)的nump.ndarray或img转为shape为(C, H, W)的tensor,并将每一个数值归一化到[0,1]（除以255即可）。

transforms.Normalize((mean1,mean2,),(std1,std2,))的作用是：是对数据按通道channel进行标准化（(P1-mean1)/std1）。

代码在神经网络的作用：数据分布在(0,1)之间时，实际的bias（即神经网络的输入b）可能会比较大，而模型初始化时b=0，这会导致神经网络收敛速度较慢，经过Normalize后，则可以加快模型的收敛速度。

参考博客[1]

参考博客[2]

参考博客[3]

Part2

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)  #reshape
        x = F.relu(self.l1(x)) #relu()激活函数
        x = F.relu(self.l2(x))
        x = F.relu(self.l3(x))
        x = F.relu(self.l4(x))
        return self.l5(x)

model = Net()

super(Model, self).__init__()的作用：通过初始化父类属性以初始化自身继承了父类的那部分属性。

x.view()的作用：view函数相当于numpy中的reshape函数，-1表示一个不确定的数，784表示确定的列数，详见参考博客[4]。

relu()的作用：激活函数，详见参考博客[5]。

​​​​​​​参考博客[4]
参考博客[5]
 

Part3

criterion = torch.nn.CrossEntropyLoss()  #计算交叉熵损失
optimizer = optim.SGD(model.parameters(), lr = 0.01, momentum = 0.5)

criterion = torch.nn.CrossEntropyLoss()的作用：用于计算交叉熵损失(详见参考博客[6]和[7])，计算公式如下：

 

optimizer = optim.SGD()的作用：构造梯度下降优化器。​​​​​​​model.parameters()表示待优化的参数组，lr表示学习率，momentum表示冲量因子，详见参考博客[8]和[9]。

参考博客[6]

参考博客[7]​​​​​​​

参考博客[8]​​​​​​​

参考博客[9]​​​​​

Part4

def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0): # 遍历函数，0表示从第0个元素开始，返回数据下标和数值
        inputs, target = data #特征，标签
        optimizer.zero_grad() #梯度归零

        # forward + backward + updata
        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

optimizer.zero_grad()的作用：将梯度归零；
loss.backward()的作用：计算梯度，并反向传播；
optimizer.step()的作用：更新参数；

参考博客[10]

Part5

def test():
    correct = 0
    total = 0
    with torch.no_grad():  #数据不计算梯度
        for data in test_loader:
            images, labels = data
            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim = 1) #predicted为tensor每行最大值的索引
            total += labels.size(0) #总样本
            correct += (predicted == labels).sum().item() #预测准确的样本数
    print('Accuracy on test set: %d %%' % (100 * correct / total)) #准确率

torch.max(input, dim)的作用：返回最大值和索引，详见参考博客[11]。
(predicted == labels).sum().item()的作用：详见参考博客[12]

参考博客[11]

​​​​​​​​​​​​​​参考博客[12]​​​​​​​

这里需要说明的是：由于数据集是mnist，outputs.data返回的是分别属于九个数字标签的概率，predicted则为索引值(0-9)，正好与labels的值相对应，因此使用predicted == labels来判断预测准确的样本数。

Part6 完整代码

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

batch_size = 64
transform = transforms.Compose([
    transforms.ToTensor(), #将shape为(H, W, C)的img转为shape为(C, H, W)的tensor,将每一个数值归一化到[0,1]
    transforms.Normalize((0.1307, ), (0.3081, )) #按通道进行数据标准化
])

train_dataset = datasets.MNIST(root = '../Pycharm/dataset/mnist/', train = True, download = True, transform = transform)

train_loader = DataLoader(train_dataset, shuffle = True, batch_size = batch_size)

test_dataset = datasets.MNIST(root = '../Pycharm/dataset/mnist/', 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)  # view函数相当于numpy中的reshape函数，-1表示一个不确定的数，784表示确定的列
        x = F.relu(self.l1(x)) # relu()激活函数
        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) #构建优化器，lr为学习率，momentum为冲量因子

def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0): # 遍历函数，0表示从第0个元素开始，返回数据下标和数值
        inputs, target = data #特征，标签
        optimizer.zero_grad() #梯度归零

        # forward + backward + updata
        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():
    correct = 0
    total = 0
    with torch.no_grad():  #数据不计算梯度
        for data in test_loader:
            images, labels = data
            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim = 1) #predicted为tensor每行最大值的索引
            total += labels.size(0) #总样本
            correct += (predicted == labels).sum().item() #预测准确的样本数
    print('Accuracy on test set: %d %%' % (100 * correct / total)) #准确率

def main():
    for epoch in range(10):
        train(epoch)
        test()

main()

Result:(Pycharm, Jupyter Notebook)