神经网络与深度学习分类

Task 01

替换平均池化（AvgPool）为最大池化（MaxPool），并输出结果。

代码

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms


# --------------------- 1. 定义 LeNet 网络 ---------------------
class LeNet(nn.Module):
    def __init__(self, use_maxpool=True):
        super(LeNet, self).__init__()

        # 卷积层
        self.conv1 = nn.Conv2d(1, 6, kernel_size=5, padding=2)  # 28x28 -> 28x28
        self.conv2 = nn.Conv2d(6, 16, kernel_size=5)  # 14x14 -> 10x10

        # 选择池化方式（默认使用 MaxPool）
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2) if use_maxpool else nn.AvgPool2d(kernel_size=2, stride=2)

        # 全连接层
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))  # 第一层卷积 + ReLU + 池化
        x = self.pool(torch.relu(self.conv2(x)))  # 第二层卷积 + ReLU + 池化
        x = torch.flatten(x, 1)  # 展平
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)  # 最终输出 10 维
        return x


# --------------------- 2. 载入 MNIST 数据集 ---------------------
mnist_data_path = "D:/603/pythonProject/data/MNIST/"

transform = transforms.Compose([
    transforms.Grayscale(),
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))  # 归一化到 [-1, 1]
])

# 加载训练和测试数据
trainset = torchvision.datasets.MNIST(root=mnist_data_path, train=True, download=False, transform=transform)
testset = torchvision.datasets.MNIST(root=mnist_data_path, train=False, download=False, transform=transform)

train_loader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)


# --------------------- 3. 训练模型 ---------------------
def train_model(model, train_loader, epochs=5, learning_rate=0.001):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

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

    for epoch in range(epochs):
        model.train()
        running_loss = 0.0
        for images, labels in train_loader:
            images, labels = images.to(device), labels.to(device)
            optimizer.zero_grad()
            outputs = model(images)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            running_loss += loss.item()

        print(f"Epoch {epoch + 1}, Loss: {running_loss / len(train_loader):.4f}")


# --------------------- 4. 评估模型 ---------------------
def evaluate_model(model, test_loader):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)
    model.eval()

    correct, total = 0, 0
    with torch.no_grad():
        for images, labels in test_loader:
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

    print(f"Test Accuracy: {100 * correct / total:.2f}%")


# --------------------- 5. 运行实验 ---------------------

# 训练并评估使用平均池化的 LeNet
print("\nTraining LeNet with Average Pooling...")
lenet_avg = LeNet(use_maxpool=False)
train_model(lenet_avg, train_loader, epochs=5, learning_rate=0.001)
print("\nEvaluating LeNet with Average Pooling...")
evaluate_model(lenet_avg, test_loader)

# 训练并评估使用最大池化的 LeNet
print("\nTraining LeNet with Max Pooling...")
lenet_max = LeNet(use_maxpool=True)
train_model(lenet_max, train_loader, epochs=5, learning_rate=0.001)
print("\nEvaluating LeNet with Max Pooling...")
evaluate_model(lenet_max, test_loader)

CNN:Basic components and LeNet

卷积

计算过程

The weight matrix for the convolution, which is the white square in the middle of the figure，but in regular calculation, there is a bias

Padding-classification

image-20250318104245806

That is to say, the size of the convolutional kernel need to fit the convolution area.

早停调参

Task 01

According to the referenced code related to weight decay, plot the functions of the training loss and the test loss with respect to λ

代码

import torch
from torch import nn
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt

# 设定超参数
batch_size = 256
num_inputs, num_outputs = 784, 10
num_hiddens = 128
num_layers = 2
learning_rate = 0.1
num_epochs = 10
lambda_values = [0, 0.0001, 0.001, 0.01, 0.1, 1]  # 不同的权重衰减系数 λ

# 预处理 FashionMNIST 数据集
transform = transforms.Compose([transforms.ToTensor()])
train_dataset = torchvision.datasets.FashionMNIST(root="./data", train=True, transform=transform, download=True)
test_dataset = torchvision.datasets.FashionMNIST(root="./data", train=False, transform=transform, download=True)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# 定义 MLP 网络
class MLP(nn.Module):
    def __init__(self, num_inputs, num_hiddens, num_outputs, num_layers):
        super(MLP, self).__init__()
        layers = []
        layers.append(nn.Linear(num_inputs, num_hiddens))
        layers.append(nn.ReLU())

        for _ in range(num_layers - 1):
            layers.append(nn.Linear(num_hiddens, num_hiddens))
            layers.append(nn.ReLU())

        layers.append(nn.Linear(num_hiddens, num_outputs))
        self.net = nn.Sequential(*layers)

    def forward(self, X):
        return self.net(X.view(-1, num_inputs))  # 展平输入

# 训练函数，接收不同的 weight_decay 参数
def train_with_weight_decay(lambda_values):
    train_losses, val_losses = [], []

    for weight_decay in lambda_values:
        net = MLP(num_inputs, num_hiddens, num_outputs, num_layers)
        loss = nn.CrossEntropyLoss()
        optimizer = torch.optim.SGD(net.parameters(), lr=learning_rate, weight_decay=weight_decay)  # 添加权重衰减

        train_loss, val_loss = [], []
        for epoch in range(num_epochs):
            net.train()
            total_loss, total_samples = 0, 0
            for X, y in train_loader:
                y_hat = net(X)
                l = loss(y_hat, y)
                optimizer.zero_grad()
                l.backward()
                optimizer.step()
                total_loss += l.item() * y.size(0)
                total_samples += y.size(0)
            train_loss.append(total_loss / total_samples)

            net.eval()
            total, test_loss = 0, 0
            with torch.no_grad():
                for X, y in test_loader:
                    y_hat = net(X)
                    test_loss += loss(y_hat, y).item() * y.size(0)
                    total += y.size(0)
            val_loss.append(test_loss / total)

        train_losses.append(train_loss[-1])
        val_losses.append(val_loss[-1])

        print(f"λ={weight_decay:.5f}, Final Train Loss={train_loss[-1]:.4f}, Final Val Loss={val_loss[-1]:.4f}")

    return train_losses, val_losses

# 训练并记录不同 λ 对损失的影响
train_losses, val_losses = train_with_weight_decay(lambda_values)

# 绘制 λ vs 训练损失 / 测试损失曲线
plt.figure(figsize=(8, 5))
plt.plot(lambda_values, train_losses, marker="o", label="Train Loss", color="blue")
plt.plot(lambda_values, val_losses, marker="s", label="Test Loss", color="orange", linestyle="dashed")
plt.xlabel("Weight Decay (λ)")
plt.ylabel("Loss")
plt.xscale("log")  # 采用对数刻度更清晰
plt.legend()
plt.title("Effect of Weight Decay (λ) on Loss")
plt.show()

实现多层感知机

代码

import torch
from torch import nn
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt

batch_size = 256
num_inputs, num_outputs = 784, 10  
num_hiddens = 128  
num_layers = 2 
learning_rate = 0.1  
num_epochs = 10


transform = transforms.Compose([transforms.ToTensor()])
train_dataset = torchvision.datasets.FashionMNIST(root="./data", train=True, transform=transform, download=False)
test_dataset = torchvision.datasets.FashionMNIST(root="./data", train=False, transform=transform, download=False)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False)


class MLP(nn.Module):
    def __init__(self, num_inputs, num_hiddens, num_outputs, num_layers):
        super(MLP, self).__init__()
        layers = []
        layers.append(nn.Linear(num_inputs, num_hiddens))
        layers.append(nn.ReLU())

        for _ in range(num_layers - 1):
            layers.append(nn.Linear(num_hiddens, num_hiddens))
            layers.append(nn.ReLU())

        layers.append(nn.Linear(num_hiddens, num_outputs))
        self.net = nn.Sequential(*layers)

    def forward(self, X):
        return self.net(X.view(-1, num_inputs))  # 展平输入


net = MLP(num_inputs, num_hiddens, num_outputs, num_layers)

loss = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(net.parameters(), lr=learning_rate)


def train(net, train_loader, test_loader, loss, num_epochs):
    train_loss, val_loss, val_acc = [], [], []

    for epoch in range(num_epochs):
        net.train()
        total_loss, total_samples = 0, 0
        for X, y in train_loader:
            y_hat = net(X)
            l = loss(y_hat, y)
            optimizer.zero_grad()
            l.backward()
            optimizer.step()
            total_loss += l.item() * y.size(0)
            total_samples += y.size(0)
        train_loss.append(total_loss / total_samples)

        net.eval()
        correct, total, test_loss = 0, 0, 0
        with torch.no_grad():
            for X, y in test_loader:
                y_hat = net(X)
                test_loss += loss(y_hat, y).item() * y.size(0)
                correct += (y_hat.argmax(dim=1) == y).sum().item()
                total += y.size(0)
        val_loss.append(test_loss / total)
        val_acc.append(correct / total)

        print(
            f"Epoch {epoch + 1}: train_loss={train_loss[-1]:.4f}, val_loss={val_loss[-1]:.4f}, val_acc={val_acc[-1]:.4f}")


    plt.plot(range(1, num_epochs + 1), train_loss, label="train_loss", color="blue")
    plt.plot(range(1, num_epochs + 1), val_loss, label="val_loss", color="orange", linestyle="dashed")
    plt.plot(range(1, num_epochs + 1), val_acc, label="val_acc", color="green", linestyle="dashdot")
    plt.xlabel("Epoch")
    plt.legend()
    plt.show()


# 训练模型
train(net, train_loader, test_loader, loss, num_epochs)

Key Components of Deep Learning

1. MLP

1.1 Structural analysis

image-20250305103104357

1.1.1 结构

该图展示了一个三层神经网络（输入层、隐藏层、输出层）。

输入层（Input Layer）：由组成，表示输入特征，每个特征作为一个神经元。

隐藏层（Hidden Layer）：由组成，表示经过线性变换和激活函数处理后的隐藏表示。

Preceding Conceptual Tech

Basics of Machine Learning

Softmax 回归：这是一种用于多类分类问题的回归方法，通常用于神经网络的输出层。

Softmax 与深度学习的关系：Softmax 回归是深度学习中的一个重要组成部分，特别是在处理分类问题时。它与线性回归和单层神经网络有联系，并可以追溯到深度学习的更广泛背景中。

1. Softmax 回归解决了什么问题？

解决多分类问题。

线性回归在分类问题上的局限性

Linear Regression-->Discrete Classification

Problem: In the process of converting continuous values to discrete values, there is usually an element of experience. If the error is large, it will greatly affect the quality of classification. During the conversion process, it is easy for people to think of setting a threshold. Setting the threshold based on experience will bring a lot of uncertainties, and the quality of classification is also related to the different experiences of different people.