Python LeNetネットワークの説明とpytorchでの実装

from torch import nn
import torch
import torch.nn.functional as F

'''
    Notes:
    1. LeNet is a 5-layer network
    2. nn.ReLU(inplace=True) The parameter True is to modify the tensor passed down from the upper layer network Conv2d directly, which can save memory for computing and not to store other variables.
    3. The dimensional annotations of this model omit the size of N(batch_size), i.e. input(3, 32, 32) -->input(N, 3, 32, 32)
    4.nn.init.xavier_uniform_(m.weight)
     Generate values with a uniform distribution, fill the input tensor or variable, and sample the values in the resulting tensor from U(-a, a)
     where a = gain * sqrt( 2/(fan_in + fan_out))* sqrt(3),
     gain is the optional scaling factor, default is 1
     'fan_in' retains the magnitude of the variance of the weights in forward propagation, 'fan_out' retains the magnitude in backward propagation
    5.nn.init.constant_(m.bias, 0)
      Fill a constant 0 for all dimensional tensor
'''


class LeNet(nn.Module):
    def __init__(self, num_classes=10, init_weights=False):
        super(LeNet, self). __init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=5, stride=1)
        self.maxpool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.relu = nn.ReLU(True)

        self.conv2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=5, stride=1)
        self.maxpool2 = nn.MaxPool2d(kernel_size=2, stride=2)

        self.fc1 = nn.Linear(32 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, num_classes)

        if init_weights:
            self._initialize_weights()

    def forward(self, x):
        x = self.conv1(x) # input(3, 32, 32) output(16, 28, 28)
        x = self.relu(x) # activation function
        x = self.maxpool1(x) # output(16, 14, 14)
        x = self.conv2(x) # output(32, 10, 10)
        x = self.relu(x) # activation function
        x = self.maxpool2(x) # output(32, 5, 5)
        x = torch.flatten(x, start_dim=1) # output(32*5*5) N for batch_size
        x = self.fc1(x) # output(120)
        x = self.relu(x) # activation function
        x = self.fc2(x) # output(84)
        x = self.relu(x) # activation function
        x = self.fc3(x) # output(num_classes)

        return x

    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.xavier_uniform_(m.weight)
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                nn.init.xavier_uniform_(m.weight)
                nn.init.constant_(m.bias, 0)

import torch.nn as nn
import torch.nn.functional as F
import torch


class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self). __init__()
        self.conv1 = nn.Conv2d(3, 16, 5)
        self.pool1 = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(16, 32, 5)
        self.pool2 = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(32*5*5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = F.relu(self.conv1(x)) # output(16, 28, 28)
        x = self.pool1(x) # output(16, 14, 14)
        x = F.relu(self.conv2(x)) # output(32, 10, 10)
        x = self.pool2(x) # output(32, 5, 5)
        x = x.view(x.size(0), -1) # output(32*5*5)
        x = F.relu(self.fc1(x)) # output(120)
        x = F.relu(self.fc2(x)) # output(84)
        x = self.fc3(x) # output(10)
        return x