LeNet structure code

# The input image's shape is (num_channels: 1, height: 28, width: 28)
# The ouput classes number is 10
import torch
from torch import nn

model = nn.Sequential(nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(),
                    nn.AvgPool2d(kernel_size=2, stride=2),
                    nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(),
                    nn.AvgPool2d(kernel_size=2, stride=2),
                    nn.Flatten(),
                    nn.Linear(16 * 5 * 5, 120), nn.Sigmoid(),
                    nn.Linear(120, 84), nn.Sigmoid(),
                    nn.Linear(84, 10))

nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias=True, padding_mode='zeros')

• in_channels: represent the number of feature images(channels) in the input layer;

• out_channels: represents the number of channels in the output layer, meanwhile, it is the number of convolutional kernels;

• kernel_size=5: means that each kernel’s pixel is 5×5.

Fashion-MNIST Data Loading code

import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
import numpy as np

transform = transforms.Compose(
    [transforms.Resize((28, 28)),
     transforms.ToTensor(),
     transforms.Normalize([0.5], [0.5])])

train_dataset = torchvision.datasets.FashionMNIST(root='./data', train=True, download=True, transform=transform)
val_dataset = torchvision.datasets.FashionMNIST(root='./data', train=False, download=True, transform=transform)

LeNet training code

from torch.utils.data import DataLoader

device = "cuda" if torch.cuda.is_available() else "cpu"

def init_weights(m):
    if type(m) == nn.Linear or type(m) == nn.Conv2d:
        nn.init.xavier_uniform_(m.weight)
model.apply(init_weights)

num_epochs = 30
batch_size = 128
lr = 0.3
model.to(device)
criterion = nn.CrossEntropyLoss(reduction='mean')
optimizer = torch.optim.SGD(model.parameters(), lr=lr, weight_decay=0.05)

train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=2)
val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=2)

for epoch in range(num_epochs):
    model.train()
    train_loss = 0
    for batch_features, batch_labels in train_loader:
        optimizer.zero_grad()
        batch_features, batch_labels = batch_features.to(device), batch_labels.to(device)
        train_outputs = model(batch_features)
        loss = criterion(train_outputs, batch_labels)
        train_loss += loss.item()
        loss.backward()
        optimizer.step()
    train_loss /= len(train_loader)

    if (epoch + 1) % 2 == 0:
        model.eval()
        true_label, pred_label = [], []
        val_loss = 0
        with torch.no_grad():
            for batch_features, batch_labels in val_loader:
                batch_features, batch_labels = batch_features.to(device), batch_labels.to(device)
                val_outputs = model(batch_features)
                loss = criterion(val_outputs, batch_labels)
                true_label.extend(batch_labels.cpu().numpy().reshape(-1))
                pred_label.extend(np.argmax(val_outputs.cpu().numpy(), axis=1))
                val_loss += loss.item()
        val_accuracy = np.mean(np.array(true_label) == np.array(pred_label))
        val_loss /= len(val_loader)
        print('epoch {}/{} | train loss: {:.4f}, val loss: {:.4f} | Accuracy: {:.2f}'.format(epoch+1, num_epochs, train_loss, val_loss, val_accuracy))

The training result can reach an accuracy of \(87\%\).

LeNet prediction code

test_dataset = MyDataset(test_data, None, features_transform)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
pred_label = []
model.eval()
with torch.no_grad():
    for batch_features, _ in test_loader:
        batch_features = batch_features.to(device)
        test_outputs = model(batch_features)
        pred_label.extend(torch.argmax(test_outputs, dim=1).cpu().numpy())
# np.save('save/path', pred_label)

A ResNet block

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

class Residual(nn.Module):
    def __init__(self, input_channels, num_channels, use_1x1conv=False, strides=1):
        super().__init__()
        self.conv1 = nn.Conv2d(input_channels, num_channels, kernel_size=3, padding=1, stride=strides)
        self.conv2 = nn.Conv2d(num_channels, num_channels, kernel_size=3, padding=1)

        if use_1x1conv:
            self.conv3 = nn.Conv2d(input_channels, num_channels, kernel_size=1, stride=strides)
        else:
            self.conv3 = None

        self.bn1 = nn.BatchNorm2d(num_channels)
        self.bn2 = nn.BatchNorm2d(num_channels)

    def forward(self, X):
        Y = F.relu(self.bn1(self.conv1(X)))
        Y = self.bn2(self.conv2(Y))
        if self.conv3 is not None:
            X = self.conv3(X)
        Y += X
        return F.relu(Y)

ResNet-18

# The input image's shape is (num_channels: 1, height: 224, width: 224)
# The ouput classes number is 10
def resnet_block(input_channels, num_channels, num_residuals, first_block=False):
    blk = []
    for i in range(num_residuals):
        if i == 0 and not first_block:
            '''
            The first block of two-blocks structures(b3, b4, b5) includes channel increasing(use_1x1conv=True)
            and pixel decreasing(stride=2).
            b2 is the first two-blocks structure which doesn't include channel increasing and pixel decreasing.
            '''
            blk.append(Residual(input_channels, num_channels, use_1x1conv=True, strides=2))
        else:
            blk.append(Residual(num_channels, num_channels))
    return blk

b1 = nn.Sequential(
    nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
    nn.BatchNorm2d(64), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
)
b2 = nn.Sequential(*resnet_block(64, 64, 2, first_block=True))
b3 = nn.Sequential(*resnet_block(64, 128, 2))
b4 = nn.Sequential(*resnet_block(128, 256, 2))
b5 = nn.Sequential(*resnet_block(256, 512, 2))
model = nn.Sequential(
    b1, b2, b3, b4, b5,
    nn.AdaptiveAvgPool2d((1, 1)),
    nn.Flatten(), nn.Linear(512, 10)
)

The training result can reach an accuracy of \(91\%\).

Dataflow

X = torch.randn(1, 1, 224, 224)
for layer in model:
    X = layer(X)
    print(layer.__calss__.__name__, 'output shape: \t', X.shape)

Self-designed model

import torch
import torch.nn as nn

# The input image's shape is (num_channels: 3, frames: 4, height: 224, width: 224)
# The ouput classes number is 10
class VideoClassifier(nn.Module):
    def __init__(self, num_classes):
        super(VideoClassifier, self).__init__()
        
        self.conv_layers = nn.Sequential(
            nn.Conv3d(3, 32, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.MaxPool3d(kernel_size=2, stride=2),
            
            nn.Conv3d(32, 64, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.MaxPool3d(kernel_size=2, stride=2),
        )
        
        self.fc_layers = nn.Sequential(
            nn.Flatten(),
                                       
            nn.Linear(64 * 1 * 56 * 56, 1024),
            nn.ReLU(),
            nn.Dropout(0.5),
            
            nn.Linear(1024, 512),
            nn.ReLU(),
            nn.Dropout(0.5),
            
            nn.Linear(512, num_classes),
        )
        
    def forward(self, x):
        x = self.conv_layers(x)
        x = x.view(x.size(0), -1)
        x = self.fc_layers(x)
        return x

model = VideoClassifier(num_classes=15)

If I have a frame size larger than 4, for example 16, I can change nn.Linear(64 * 1 * 56 * 56, 1024) to nn.Linear(64 * 16 * 56 * 56, 1024), or I can add two more blocks in self.conv_layer.

ResNet18-3d

from torchvision.models.video import r3d_18

num_classes = 10
model = r3d_18(pretrained=True)
model.fc = nn.Linear(512, num_classes)