第 3 章：构建神经网络¶

import torch
import torch.nn as nn

class SimpleNet(nn.Module):
    """一个简单的三层全连接网络"""
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleNet, self).__init__()

        # 定义网络层
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, hidden_size)
        self.fc3 = nn.Linear(hidden_size, output_size)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        # 定义前向传播流程
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        x = self.relu(x)
        x = self.fc3(x)
        x = self.sigmoid(x)
        return x

# 创建模型实例
model = SimpleNet(input_size=10, hidden_size=20, output_size=1)
print(model)

# 测试前向传播
x = torch.randn(5, 10)
y = model(x)
print(f"\n输入形状: {x.shape}")
print(f"输出形状: {y.shape}")

# nn.Linear(in_features, out_features, bias=True)
linear = nn.Linear(4, 3)

x = torch.randn(2, 4)
y = linear(x)

print(f"输入: {x.shape}")
print(f"权重形状: {linear.weight.shape}")
print(f"偏置形状: {linear.bias.shape}")
print(f"输出: {y.shape}")
print(f"\n计算验证: y = x @ W^T + b")
print(f"手动计算:\n{x @ linear.weight.T + linear.bias}")
print(f"Linear 输出:\n{y}")

# 常见激活函数对比
x = torch.linspace(-3, 3, 100)

activations = {
    'Sigmoid': nn.Sigmoid(),
    'Tanh': nn.Tanh(),
    'ReLU': nn.ReLU(),
    'LeakyReLU': nn.LeakyReLU(0.1),
    'GELU': nn.GELU(),
}

print("激活函数输出示例（x = -2, 0, 2）：")
print(f"{'函数':<12} {'x=-2':<10} {'x=0':<10} {'x=2':<10}")
print("-" * 42)

test_x = torch.tensor([-2.0, 0.0, 2.0])
for name, fn in activations.items():
    y = fn(test_x)
    print(f"{name:<12} {y[0].item():<10.4f} {y[1].item():<10.4f} {y[2].item():<10.4f}")

# 创建一个简单的卷积层
conv = nn.Conv2d(
    in_channels=3,      # 输入通道数（RGB 图像 = 3）
    out_channels=16,    # 输出通道数（16 个卷积核）
    kernel_size=3,      # 卷积核大小 3x3
    stride=1,           # 步长
    padding=1           # 填充（保持尺寸不变）
)

# 模拟一张 RGB 图像：batch=1, channels=3, height=32, width=32
image = torch.randn(1, 3, 32, 32)
output = conv(image)

print(f"输入形状:  {image.shape}")
print(f"卷积核形状: {conv.weight.shape}")
print(f"输出形状:  {output.shape}")
print(f"\n参数量: {sum(p.numel() for p in conv.parameters())}")

# 最大池化
maxpool = nn.MaxPool2d(kernel_size=2, stride=2)

# 平均池化
avgpool = nn.AvgPool2d(kernel_size=2, stride=2)

x = torch.tensor([[[[1.0, 2.0, 3.0, 4.0],
                    [5.0, 6.0, 7.0, 8.0],
                    [9.0, 10.0, 11.0, 12.0],
                    [13.0, 14.0, 15.0, 16.0]]]])

print(f"输入:\n{x}\n")
print(f"最大池化 (2x2, stride=2):\n{maxpool(x)}\n")
print(f"平均池化 (2x2, stride=2):\n{avgpool(x)}")

# BatchNorm：对一个 batch 内的数据做归一化
batch_norm = nn.BatchNorm1d(4)

# LayerNorm：对一个样本内的特征做归一化（Transformer 常用）
layer_norm = nn.LayerNorm(4)

x = torch.randn(3, 4)
print(f"输入:\n{x}\n")
print(f"BatchNorm 输出:\n{batch_norm(x)}\n")
print(f"LayerNorm 输出:\n{layer_norm(x)}")

dropout = nn.Dropout(p=0.5)

x = torch.ones(1, 10)
print(f"输入: {x}")

# 训练模式（随机置零）
dropout.train()
print(f"训练模式: {dropout(x)}")

# 评估模式（不置零，但缩放）
dropout.eval()
print(f"评估模式: {dropout(x)}")

# 用 Sequential 搭建一个 CNN
cnn = nn.Sequential(
    nn.Conv2d(1, 32, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.MaxPool2d(2),

    nn.Conv2d(32, 64, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.MaxPool2d(2),

    nn.Flatten(),
    nn.Linear(64 * 7 * 7, 128),
    nn.ReLU(),
    nn.Dropout(0.5),
    nn.Linear(128, 10)
)

print(cnn)

# 测试
x = torch.randn(1, 1, 28, 28)
y = cnn(x)
print(f"\n输入: {x.shape} → 输出: {y.shape}")

class CNNClassifier(nn.Module):
    """一个完整的 CNN 分类器"""
    def __init__(self, num_classes=10):
        super(CNNClassifier, self).__init__()

        # 特征提取器
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2),

            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(),
            nn.MaxPool2d(2),

            nn.Conv2d(128, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(),
            nn.MaxPool2d(2),
        )

        # 分类器
        self.classifier = nn.Sequential(
            nn.AdaptiveAvgPool2d((1, 1)),
            nn.Flatten(),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(128, num_classes)
        )

    def forward(self, x):
        x = self.features(x)
        x = self.classifier(x)
        return x

model = CNNClassifier(num_classes=10)
x = torch.randn(2, 3, 32, 32)
y = model(x)

print(f"输入形状: {x.shape}")
print(f"输出形状: {y.shape}")

# 统计参数量
total_params = sum(p.numel() for p in model.parameters())
trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f"\n总参数量: {total_params:,}")
print(f"可训练参数: {trainable_params:,}")

model = SimpleNet(10, 20, 1)

# 查看所有参数
print("模型参数列表：")
for name, param in model.named_parameters():
    print(f"  {name:<20} shape={str(param.shape):<15} requires_grad={param.requires_grad}")

# 获取特定层的参数
fc1_weights = model.fc1.weight
fc1_bias = model.fc1.bias
print(f"\nfc1 权重形状: {fc1_weights.shape}")
print(f"fc1 偏置形状: {fc1_bias.shape}")

# 参数初始化
def init_weights(m):
    if isinstance(m, nn.Linear):
        nn.init.xavier_uniform_(m.weight)
        nn.init.zeros_(m.bias)

model.apply(init_weights)
print("\n参数已用 Xavier 初始化")

# 创建并训练一个简单模型（略去训练过程）
model = SimpleNet(10, 20, 1)

# 方式 1：保存整个模型（不推荐，依赖类定义）
torch.save(model, 'model_full.pth')
loaded_model = torch.load('model_full.pth', weights_only=False)

# 方式 2：只保存参数（推荐！）
torch.save(model.state_dict(), 'model_params.pth')

# 加载参数
new_model = SimpleNet(10, 20, 1)
new_model.load_state_dict(torch.load('model_params.pth'))
new_model.eval()

print("模型参数已保存和加载")

# 清理临时文件
import os
os.remove('model_full.pth')
os.remove('model_params.pth')