神经网络原理

输入 (5×5)          卷积核 (3×3)        输出特征图 (3×3)
┌─┬─┬─┬─┬─┐        ┌─┬─┬─┐           ┌──┬──┬──┐
│1│0│1│0│1│        │1│0│1│           │ 4│ 3│ 4│
├─┼─┼─┼─┼─┤        ├─┼─┼─┤           ├──┼──┼──┤
│0│1│0│1│0│   *    │0│1│0│    =      │ 2│ 4│ 3│
├─┼─┼─┼─┼─┤        ├─┼─┼─┤           ├──┼──┼──┤
│1│0│1│0│1│        │1│0│1│           │ 4│ 3│ 4│
├─┼─┼─┼─┼─┤        └─┴─┴─┘           └──┴──┴──┘
│0│1│0│1│0│
├─┼─┼─┼─┼─┤
│1│0│1│0│1│
└─┴─┴─┴─┴─┘

import torch.nn as nn

# 卷积层：输入 3 通道（RGB），输出 64 个特征图，3×3 卷积核
conv = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, stride=1, padding=1)

# 输出尺寸计算：(输入尺寸 - kernel_size + 2 * padding) / stride + 1
# (224 - 3 + 2) / 1 + 1 = 224  (尺寸保持不变)

# 2×2 最大池化，步长为 2，将特征图尺寸减半
max_pool = nn.MaxPool2d(kernel_size=2, stride=2)

# 全局平均池化，将每个特征图压缩为一个值
global_avg_pool = nn.AdaptiveAvgPool2d(1)

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

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        # 特征提取部分
        self.features = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=3, padding=1),   # 28×28×1 → 28×28×32
            nn.ReLU(),
            nn.MaxPool2d(2),                               # 28×28×32 → 14×14×32

            nn.Conv2d(32, 64, kernel_size=3, padding=1),   # 14×14×32 → 14×14×64
            nn.ReLU(),
            nn.MaxPool2d(2),                               # 14×14×64 → 7×7×64
        )
        # 分类部分
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64 * 7 * 7, 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 = SimpleCNN()
# 测试前向传播
sample = torch.randn(1, 1, 28, 28)
output = model(sample)
print(f"输出形状: {output.shape}")  # torch.Size([1, 10])

import torch.nn as nn

# 基本 RNN
rnn = nn.RNN(input_size=128, hidden_size=256, num_layers=2, batch_first=True)

# 输入：batch_size=32, 序列长度=50, 每个 token 的维度=128
x = torch.randn(32, 50, 128)
output, hidden = rnn(x)

print(f"输出形状: {output.shape}")   # (32, 50, 256) - 每个时间步的隐藏状态
print(f"隐藏状态: {hidden.shape}")   # (2, 32, 256) - 最后时间步的隐藏状态

# LSTM
lstm = nn.LSTM(input_size=128, hidden_size=256, num_layers=2,
               batch_first=True, dropout=0.2, bidirectional=True)

x = torch.randn(32, 50, 128)
output, (hidden, cell) = lstm(x)

# 双向 LSTM 的输出维度是 hidden_size × 2
print(f"输出形状: {output.shape}")   # (32, 50, 512)
print(f"隐藏状态: {hidden.shape}")   # (4, 32, 256) - 2 layers × 2 directions

# GRU
gru = nn.GRU(input_size=128, hidden_size=256, num_layers=2,
             batch_first=True, dropout=0.2)

x = torch.randn(32, 50, 128)
output, hidden = gru(x)
print(f"输出形状: {output.shape}")   # (32, 50, 256)

计算过程：
1. 计算 Query 和每个 Key 的相似度（点积）
2. 通过 Softmax 将相似度转为权重（和为 1）
3. 用权重对 Value 做加权求和，得到输出

Attention(Q, K, V) = softmax(Q × K^T / √d_k) × V

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

def scaled_dot_product_attention(query, key, value, mask=None):
    """缩放点积注意力"""
    d_k = query.size(-1)

    # 计算注意力分数
    scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_k)

    # 可选的掩码（用于解码器中屏蔽未来位置）
    if mask is not None:
        scores = scores.masked_fill(mask == 0, float('-inf'))

    # Softmax 归一化为权重
    attention_weights = F.softmax(scores, dim=-1)

    # 加权求和
    output = torch.matmul(attention_weights, value)
    return output, attention_weights

# 示例
seq_len, d_model = 10, 64
Q = torch.randn(1, seq_len, d_model)
K = torch.randn(1, seq_len, d_model)
V = torch.randn(1, seq_len, d_model)

output, weights = scaled_dot_product_attention(Q, K, V)
print(f"输出形状: {output.shape}")           # (1, 10, 64)
print(f"注意力权重形状: {weights.shape}")     # (1, 10, 10)

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model=512, num_heads=8):
        super().__init__()
        self.num_heads = num_heads
        self.d_k = d_model // num_heads

        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)

    def forward(self, query, key, value, mask=None):
        batch_size = query.size(0)

        # 线性投影并拆分为多头
        Q = self.W_q(query).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        K = self.W_k(key).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        V = self.W_v(value).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)

        # 计算注意力
        output, _ = scaled_dot_product_attention(Q, K, V, mask)

        # 拼接多头结果
        output = output.transpose(1, 2).contiguous().view(batch_size, -1, self.num_heads * self.d_k)
        return self.W_o(output)

mha = MultiHeadAttention(d_model=512, num_heads=8)
x = torch.randn(2, 20, 512)  # batch=2, 序列长度=20, 维度=512
out = mha(x, x, x)           # 自注意力：Q=K=V
print(f"多头注意力输出: {out.shape}")  # (2, 20, 512)

import torchvision.models as models

# 使用预训练的 ResNet-18 进行迁移学习
model = models.resnet18(pretrained=True)

# 冻结特征提取层
for param in model.parameters():
    param.requires_grad = False

# 替换最后的全连接层（适配自定义类别数）
model.fc = nn.Linear(model.fc.in_features, num_classes=5)

# 只训练新加的全连接层
optimizer = torch.optim.Adam(model.fc.parameters(), lr=0.001)

class TextClassifier(nn.Module):
    def __init__(self, vocab_size, embed_dim=128, hidden_dim=256, num_classes=4):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True, bidirectional=True)
        self.classifier = nn.Linear(hidden_dim * 2, num_classes)

    def forward(self, x):
        embedded = self.embedding(x)                # (batch, seq_len, embed_dim)
        output, (hidden, _) = self.lstm(embedded)   # output: (batch, seq_len, hidden*2)

        # 取最后时间步的输出进行分类
        last_output = output[:, -1, :]
        return self.classifier(last_output)

model = TextClassifier(vocab_size=10000)
tokens = torch.randint(0, 10000, (16, 100))  # 16 个句子，每句 100 个 token
output = model(tokens)
print(f"分类输出: {output.shape}")  # (16, 4)