（系列更新完毕）深度学习零基础使用 PyTorch 框架跑 MNIST 数据集的第一天：LeNet 网络的搭建_mnist数据集需要跑几天

作者：羊村懒王 | 2024-06-08 00:06:03

踩

mnist数据集需要跑几天

1. Introduction

今天是尝试用 PyTorch 框架来跑 MNIST 手写数字数据集的第一天，主要学习 LeNet 网络结构的定义。本 blog 主要记录一个学习的路径以及学习资料的汇总。

注意：这是用 Python 2.7 版本写的代码

第一天（LeNet 网络的搭建）：https://blog.csdn.net/qq_36627158/article/details/108098147

第二天（加载 MNIST 数据集）：https://blog.csdn.net/qq_36627158/article/details/108119048

第三天（训练模型）：https://blog.csdn.net/qq_36627158/article/details/108163693

第四天（单例测试）：https://blog.csdn.net/qq_36627158/article/details/108183655

2. Code（lenet.py）

感谢凯神提供的代码与耐心指导！


import torch.nn as nn
import torch.nn.functional as F
 
 
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
 
        # C1: input: 1*28*28    output: 6*28*28  (32-5+1)
        self.conv1 = nn.Conv2d(
            in_channels=1,
            out_channels=6,
            kernel_size=5,
            padding=2
        )
 
        # S2: input: 6*28*28    output: 6*14*14
        self.max_pooling1 = nn.MaxPool2d(
            kernel_size=2,
            stride=2
        )
 
        # C3: input: 6*14*14    output: 16*10*10 (14-5+1)
        self.conv2 = nn.Conv2d(
            in_channels=6,
            out_channels=16,
            kernel_size=5
        )
 
        # S4: input: 16*10*10    output: 16*5*5
        self.max_pooling2 = nn.MaxPool2d(
            kernel_size=2,
            stride=2
        )
 
        # C5: input: 16*5*5    output: 1*120*1
        self.conv3 = nn.Linear(
            in_features=16 * 5 * 5,
            out_features=120
        )
 
        # F6: input: 1*120*1   output: 1*84*1
        self.fc1 = nn.Linear(
            in_features=120,
            out_features=84
        )
 
        # F7(OutPut): input: 1*84*1   output: 1*10*1
        self.fc2 = nn.Linear(
            in_features=84,
            out_features=10
        )
 
    def forward(self, x):
        # C1:
        x = self.conv1(x)
        x = F.relu(x)
 
        # S2:
        x = self.max_pooling1(x)
 
        # C3:
        x = self.conv2(x)
        x = F.relu(x)
 
        # S4:
        x = self.max_pooling2(x)
 
        # num_flat_features(x): get a flatten vector's size
        # view(): 16*5*5 -> 400*1
        x = x.view(-1, self.num_flat_features(x))
 
        # C5:
        x = self.conv3(x)
        x = F.relu(x)
 
        # F6:
        x = self.fc1(x)
        x = F.relu(x)
 
        # F7:
        x = self.fc2(x)
        x = F.relu(x)
 
        return x
 
    def num_flat_features(self, x):
        # x.size() = [b, c, h, w]
        # size = [c, h, w]    [16*5*5]
        size = x.size()[1:]
 
        # c * h * w
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

3. Materials

4. Details

1、Python 类的定义以及初始化函数函数：

https://www.runoob.com/python3/python3-class.html

2、Python 2.x 继承父类的 init() 与 Python 3.x 不一样。

https://www.runoob.com/python/python-func-super.html

3、torch.nn 与 torch.nn.functional 的区别：

最开始是因为看到了池化层既可以写成：self.max_pooling1 = nn.MaxPool2d() ；也可以写成：self.max_pooling1 = F.maxpool2d()。就产生了疑问：既然都有每一层的实现方法，为什么不只使用 torch.nn ？或者为什么不只使用 torch.nn.functional ？为什么要两个混在一起写？有什么区别吗？

后来找到了一篇不错的解释：https://blog.csdn.net/GZHermit/article/details/78730856