五大主流神经网络模型原理与实战：从CNN、RNN到Transformer、GAN、GNN

如果你对神经网络的理解还停留在“黑箱”和“调参”，那么这篇文章就是为你准备的。我们不再空谈概念，而是直接切入核心：为什么神经网络能学习几乎任何东西？其背后的数学原理和工程实现到底是什么？本文将聚焦于五大主流神经网络模型——GNN、CNN、RNN、GAN、Transformer，带你在一小时内从原理到实战，彻底搞懂它们是如何工作的，以及如何用代码亲手实现。

本文的目标是让你获得“可验证”的理解。我们将从最根本的梯度下降和反向传播讲起，这是所有神经网络学习的通用引擎。然后，我们会逐一拆解五大模型的核心思想、适用场景和关键代码实现。你不会看到冗长的数学推导，而是获得清晰的直觉、可运行的代码片段，以及一个能立刻上手的实战项目清单。无论你是想面试突击，还是为项目选型，这篇文章都能提供直接的帮助。

1. 核心能力速览：五大神经网络模型定位

在深入细节前，我们先通过一张表快速把握这五大模型的核心特征与适用领域，这能帮助你快速判断哪个模型适合解决你的问题。

本文实战路线 ：我们将从 CNN识别手写数字 这个经典任务开始，因为它最直观。然后过渡到 RNN进行简单文本生成 ，理解序列建模。接着，我们会用 GAN生成MNIST风格的图像 ，感受“创造”的过程。对于 Transformer ，我们将剖析其自注意力机制，并实现一个极简的文本分类器。最后，我们会探讨 GNN 在节点分类任务上的应用。每个部分都包含可运行的PyTorch代码核心片段。

2. 神经网络为什么能学习：梯度下降与反向传播

在接触具体模型前，必须理解所有神经网络共通的“学习引擎”。这并非魔法，而是一个基于微积分的优化过程。

核心直觉 ：神经网络是一个包含数百万甚至数十亿参数（权重和偏置）的复杂函数。学习的目标是找到一组参数，使得神经网络的输出与真实答案之间的误差（损失）最小。

如何找到？——梯度下降 ：

1. 初始化 ：随机设置所有参数。
2. 前向传播 ：输入数据，计算网络输出和损失。
3. 关键步骤：反向传播 ：利用链式法则，从输出层反向计算损失函数相对于每一个参数的 梯度 。梯度指明了参数调整的方向（使损失增加还是减少）和幅度。
4. 参数更新 ：所有参数沿着其梯度的反方向（即减小损失的方向）移动一小步（学习率）。
5. 循环 ：重复步骤2-4，直到损失收敛。

import torch
import torch.nn as nn
import torch.optim as optim

# 一个超简单的线性模型示例：y = w*x + b
model = nn.Linear(1, 1)  # 内部包含参数 w 和 b
criterion = nn.MSELoss()  # 损失函数：均方误差
optimizer = optim.SGD(model.parameters(), lr=0.01) # 优化器：随机梯度下降

# 模拟数据
x = torch.tensor([[1.0], [2.0], [3.0]])
y = torch.tensor([[2.0], [4.0], [6.0]]) # 理想情况：y = 2*x

# 训练循环（一次迭代）
optimizer.zero_grad() # 清空上一轮的梯度
output = model(x)      # 前向传播：计算预测值
loss = criterion(output, y) # 计算损失
loss.backward()        # 反向传播：计算梯度
optimizer.step()       # 参数更新：w = w - lr * w.grad

print(f‘Loss: {loss.item()}‘)
print(f‘Updated weight: {model.weight.data}, bias: {model.bias.data}‘)

这段代码展示了学习的基本单元。 loss.backward() 是PyTorch自动完成反向传播的魔法命令，它为我们计算了所有参数的梯度。 optimizer.step() 则根据这些梯度更新参数。

为什么能学“任何”东西？ 神经网络的强大源于其巨大的容量（参数量）和层次化结构，使其能够以极高的灵活性逼近极其复杂的函数（万能近似定理）。只要数据中存在模式，并且损失函数能合理定义“好”与“坏”，梯度下降就有机会通过迭代找到那个能捕捉模式的函数（参数组）。

3. CNN实战：图像识别入门

CNN是计算机视觉的基石。其核心在于利用卷积核（滤波器）在图像上滑动，提取局部特征（如边缘、纹理），并通过池化层逐步降低空间尺寸、增加特征深度，最终实现分类。

实战目标 ：使用PyTorch构建一个CNN，在MNIST手写数字数据集上达到99%以上的准确率。

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms

# 1. 定义CNN模型
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        # 卷积层1: 输入通道1(灰度图), 输出通道32, 卷积核3x3
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
        # 卷积层2: 输入32, 输出64
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        # 最大池化层: 2x2窗口
        self.pool = nn.MaxPool2d(2, 2)
        # 全连接层1: 池化后特征图展平的大小 -> 128
        # MNIST 28x28 -> conv/pool 后变为 7x7x64
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        # 输出层: 10个数字类别
        self.fc2 = nn.Linear(128, 10)
        # Dropout 防止过拟合
        self.dropout = nn.Dropout(0.5)

    def forward(self, x):
        # 卷积 -> 激活(ReLU) -> 池化
        x = self.pool(F.relu(self.conv1(x))) # 28x28 -> 14x14
        x = self.pool(F.relu(self.conv2(x))) # 14x14 -> 7x7
        # 展平
        x = x.view(-1, 64 * 7 * 7)
        # 全连接层
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        x = self.fc2(x)
        return x

# 2. 数据准备
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,)) # MNIST的均值和标准差
])
train_dataset = datasets.MNIST(‘./data‘, train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)

# 3. 初始化模型、损失函数、优化器
device = torch.device(‘cuda‘ if torch.cuda.is_available() else ‘cpu‘)
model = SimpleCNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 4. 训练循环 (简化版，仅展示一轮)
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
    data, target = data.to(device), target.to(device)
    optimizer.zero_grad()
    output = model(data)
    loss = criterion(output, target)
    loss.backward()
    optimizer.step()
    if batch_idx % 100 == 0:
        print(f‘Train Batch: {batch_idx}, Loss: {loss.item():.6f}‘)

关键点解析 ：

• nn.Conv2d : 定义卷积层，核心参数是输入/输出通道数和卷积核大小。 padding=1 保证输出尺寸不变。
• nn.MaxPool2d : 下采样，保留最显著特征，减少计算量并增加平移不变性。
• x.view(-1, 64*7*7) : 将三维特征图展平为一维向量，输入全连接层。
• CrossEntropyLoss : 多分类任务的标准损失函数。
• Adam : 比SGD更常用的自适应学习率优化器。

在MNIST上，这个简单模型训练5个epoch后测试准确率很容易超过99%。你可以尝试调整卷积核数量、层数、学习率来观察效果。

4. RNN实战：序列建模与文本生成

RNN通过循环结构处理序列，其隐藏状态充当了“记忆”。但基础RNN存在梯度消失/爆炸问题，因此实践中常用LSTM或GRU。

实战目标 ：使用LSTM，基于字符级别的莎士比亚文本，学习并生成类似风格的文本。

import torch
import torch.nn as nn
import numpy as np

# 1. 数据预处理 (简化，假设已构建字符到索引的映射)
# all_text = “...莎士比亚作品...”
# chars = list(set(all_text))
# char_to_idx = {ch: i for i, ch in enumerate(chars)}
# idx_to_char = {i: ch for i, ch in enumerate(chars)}
# data = [char_to_idx[ch] for ch in all_text]

class CharLSTM(nn.Module):
    def __init__(self, vocab_size, hidden_size, num_layers=2):
        super(CharLSTM, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        # 嵌入层：将字符索引转换为稠密向量
        self.embedding = nn.Embedding(vocab_size, hidden_size)
        # LSTM层
        self.lstm = nn.LSTM(hidden_size, hidden_size, num_layers, batch_first=True)
        # 输出层：预测下一个字符的概率分布
        self.fc = nn.Linear(hidden_size, vocab_size)

    def forward(self, x, hidden):
        # x shape: (batch_size, seq_length)
        embedded = self.embedding(x) # -> (batch_size, seq_length, hidden_size)
        lstm_out, hidden = self.lstm(embedded, hidden)
        # 只取最后一个时间步的输出用于预测
        out = self.fc(lstm_out[:, -1, :])
        return out, hidden

    def init_hidden(self, batch_size):
        # 初始化LSTM的隐藏状态和细胞状态
        device = next(self.parameters()).device
        return (torch.zeros(self.num_layers, batch_size, self.hidden_size).to(device),
                torch.zeros(self.num_layers, batch_size, self.hidden_size).to(device))

# 2. 训练步骤伪代码
def train_step(model, batch_input, batch_target, hidden):
    model.train()
    optimizer.zero_grad()
    # batch_input: (batch, seq_len)，每个元素是字符索引
    output, hidden = model(batch_input, hidden)
    loss = criterion(output, batch_target) # batch_target是下一个字符的索引
    loss.backward()
    # 梯度裁剪，防止RNN训练中的梯度爆炸
    torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
    optimizer.step()
    return loss.item(), hidden.detach() # 分离hidden，避免计算图无限增长

# 3. 文本生成函数
def generate_text(model, start_str, length=100, temperature=0.8):
    model.eval()
    chars = [start_str]
    hidden = model.init_hidden(1)
    # 用起始字符串初始化hidden
    for ch in start_str:
        input_idx = torch.tensor([[char_to_idx[ch]]])
        _, hidden = model(input_idx, hidden)

    # 开始生成
    for _ in range(length):
        input_idx = torch.tensor([[char_to_idx[chars[-1]]]])
        output, hidden = model(input_idx, hidden)
        # 应用温度参数控制随机性
        output_dist = output.data.view(-1).div(temperature).exp()
        top_idx = torch.multinomial(output_dist, 1)[0]
        predicted_char = idx_to_char[top_idx.item()]
        chars.append(predicted_char)
    return ‘‘.join(chars)

关键点解析 ：

• nn.Embedding : 将离散的字符索引映射为连续的向量表示，这是NLP的常见操作。
• nn.LSTM : 核心循环层。 batch_first=True 使输入输出张量的batch维度在第一维，更符合直觉。
• hidden : 一个元组 (h_n, c_n) ，分别代表隐藏状态和细胞状态，是RNN的“记忆”。
• clip_grad_norm_ : 训练RNN/LSTM时的必备技巧，防止梯度爆炸导致训练失败。
• temperature : 生成文本时的采样参数， temperature < 1 使分布更尖锐（确定性更强）， >1 更平滑（更随机、更有创造性）。

运行足够轮次后，模型会学会单词拼写、基本语法甚至一些文学风格。你可以用任何文本文件（如小说、代码、歌词）作为训练数据。

5. GAN实战：从噪声中创造图像

GAN包含一个生成器(G)和一个判别器(D)。G的目标是生成足以乱真的数据欺骗D，D的目标是区分真实数据和生成数据。两者在对抗中共同进化。

实战目标 ：构建一个DCGAN（深度卷积GAN），在MNIST数据集上生成手写数字图像。

import torch
import torch.nn as nn

# 1. 生成器定义：输入噪声向量，输出伪造图像
class Generator(nn.Module):
    def __init__(self, latent_dim=100):
        super(Generator, self).__init__()
        self.main = nn.Sequential(
            # 将噪声向量投影并重塑
            nn.Linear(latent_dim, 128 * 7 * 7),
            nn.BatchNorm1d(128 * 7 * 7),
            nn.ReLU(True),
            nn.Unflatten(1, (128, 7, 7)), # 重塑为 (batch, 128, 7, 7)
            # 转置卷积层（上采样）
            nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1, bias=False),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            # 输出层：生成1通道的28x28图像，使用Tanh将值约束到[-1,1]
            nn.ConvTranspose2d(64, 1, kernel_size=4, stride=2, padding=1, bias=False),
            nn.Tanh()
        )

    def forward(self, z):
        return self.main(z)

# 2. 判别器定义：输入图像，输出其为真的概率
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
            # 输入: (1, 28, 28)
            nn.Conv2d(1, 64, kernel_size=4, stride=2, padding=1, bias=False),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1, bias=False),
            nn.BatchNorm2d(128),
            nn.LeakyReLU(0.2, inplace=True),
            # 展平
            nn.Flatten(),
            nn.Linear(128 * 7 * 7, 1),
            nn.Sigmoid() # 输出一个0到1之间的概率值
        )

    def forward(self, img):
        return self.main(img).view(-1)

# 3. GAN训练循环核心
def train_gan(generator, discriminator, dataloader, num_epochs=50):
    criterion = nn.BCELoss() # 二分类交叉熵损失
    optimizer_G = optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))
    optimizer_D = optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))

    for epoch in range(num_epochs):
        for i, (real_imgs, _) in enumerate(dataloader):
            batch_size = real_imgs.size(0)
            real_labels = torch.ones(batch_size) # 真实标签为1
            fake_labels = torch.zeros(batch_size) # 伪造标签为0

            # ---------------------
            #  训练判别器 D
            # ---------------------
            optimizer_D.zero_grad()
            # 计算真实图像的损失
            real_output = discriminator(real_imgs)
            loss_D_real = criterion(real_output, real_labels)
            # 生成伪造图像
            z = torch.randn(batch_size, 100) # 噪声向量
            fake_imgs = generator(z).detach() # 阻止梯度传到G
            # 计算伪造图像的损失
            fake_output = discriminator(fake_imgs)
            loss_D_fake = criterion(fake_output, fake_labels)
            # 判别器总损失
            loss_D = loss_D_real + loss_D_fake
            loss_D.backward()
            optimizer_D.step()

            # ---------------------
            #  训练生成器 G
            # ---------------------
            optimizer_G.zero_grad()
            # 用新的噪声生成图像
            z = torch.randn(batch_size, 100)
            gen_imgs = generator(z)
            # 生成器的目标是让判别器认为其生成的图像是真的
            output = discriminator(gen_imgs)
            loss_G = criterion(output, real_labels) # 希望判别器输出接近1
            loss_G.backward()
            optimizer_G.step()

关键点解析 ：

• nn.ConvTranspose2d : 转置卷积（或称反卷积），用于上采样，将小特征图放大为图像。
• nn.BCELoss : 二元交叉熵损失，适用于判别器输出一个概率值的场景。
• 对抗训练 ：训练D时，固定G的参数；训练G时，固定D的参数。这是一个极小极大博弈。
• detach() : 在训练D时，从计算图中分离 fake_imgs ，防止梯度传播到G，确保只更新D的参数。
• 训练不稳定 ：GAN训练 notoriously difficult。使用 BatchNorm 、 LeakyReLU 、特定的优化器参数( betas )和标签平滑等都是稳定训练的常用技巧。

训练过程中，你可以定期保存生成器生成的图像，观察从噪声到清晰数字的演变过程。

6. Transformer实战：自注意力机制与文本分类

Transformer彻底改变了序列建模，其核心是 自注意力机制 ，它允许序列中的每个位置直接关注所有其他位置，从而高效捕捉长程依赖。

实战目标 ：实现一个简化版的Transformer编码器，用于文本分类任务（如情感分析）。

import torch
import torch.nn as nn
import math

# 1. 自注意力机制实现
class SelfAttention(nn.Module):
    def __init__(self, embed_size, heads):
        super(SelfAttention, self).__init__()
        self.embed_size = embed_size
        self.heads = heads
        self.head_dim = embed_size // heads
        assert self.head_dim * heads == embed_size, “Embed size needs to be divisible by heads”

        # 通过线性层生成Q, K, V
        self.values = nn.Linear(self.head_dim, self.head_dim, bias=False)
        self.keys = nn.Linear(self.head_dim, self.head_dim, bias=False)
        self.queries = nn.Linear(self.head_dim, self.head_dim, bias=False)
        self.fc_out = nn.Linear(heads * self.head_dim, embed_size)

    def forward(self, values, keys, query, mask=None):
        N = query.shape[0] # batch size
        value_len, key_len, query_len = values.shape[1], keys.shape[1], query.shape[1]

        # 分割嵌入维度到多个头
        values = values.reshape(N, value_len, self.heads, self.head_dim)
        keys = keys.reshape(N, key_len, self.heads, self.head_dim)
        queries = query.reshape(N, query_len, self.heads, self.head_dim)

        # 计算注意力分数: Q * K^T / sqrt(d_k)
        energy = torch.einsum(“nqhd,nkhd->nhqk”, [queries, keys])
        if mask is not None:
            energy = energy.masked_fill(mask == 0, float(“-1e20”))
        attention = torch.softmax(energy / (self.embed_size ** (1/2)), dim=3)

        # 应用注意力到V上
        out = torch.einsum(“nhql,nlhd->nqhd”, [attention, values])
        out = out.reshape(N, query_len, self.heads * self.head_dim)
        out = self.fc_out(out)
        return out

# 2. Transformer编码器块
class TransformerBlock(nn.Module):
    def __init__(self, embed_size, heads, dropout, forward_expansion):
        super(TransformerBlock, self).__init__()
        self.attention = SelfAttention(embed_size, heads)
        self.norm1 = nn.LayerNorm(embed_size)
        self.norm2 = nn.LayerNorm(embed_size)
        self.feed_forward = nn.Sequential(
            nn.Linear(embed_size, forward_expansion * embed_size),
            nn.ReLU(),
            nn.Linear(forward_expansion * embed_size, embed_size)
        )
        self.dropout = nn.Dropout(dropout)

    def forward(self, value, key, query, mask=None):
        attention = self.attention(value, key, query, mask)
        x = self.dropout(self.norm1(attention + query)) # 残差连接 & 层归一化
        forward = self.feed_forward(x)
        out = self.dropout(self.norm2(forward + x))
        return out

# 3. 用于分类的简化Transformer编码器
class TransformerEncoder(nn.Module):
    def __init__(self, vocab_size, embed_size, num_layers, heads, device, forward_expansion=4, dropout=0.1, max_length=100):
        super(TransformerEncoder, self).__init__()
        self.embed_size = embed_size
        self.device = device
        self.word_embedding = nn.Embedding(vocab_size, embed_size)
        self.position_embedding = nn.Embedding(max_length, embed_size)
        self.layers = nn.ModuleList([
            TransformerBlock(embed_size, heads, dropout, forward_expansion)
            for _ in range(num_layers)
        ])
        self.dropout = nn.Dropout(dropout)
        self.fc_out = nn.Linear(embed_size, 2) # 假设是二分类

    def forward(self, x, mask=None):
        N, seq_length = x.shape
        positions = torch.arange(0, seq_length).expand(N, seq_length).to(self.device)
        out = self.dropout(self.word_embedding(x) + self.position_embedding(positions))

        for layer in self.layers:
            out = layer(out, out, out, mask) # 在编码器中，Q,K,V都来自自身

        # 取第一个token的输出（[CLS]）或做平均池化用于分类
        out = out.mean(dim=1) # 平均池化
        out = self.fc_out(out)
        return out

关键点解析 ：

• SelfAttention : 核心计算。 einsum 是进行多维度张量乘法的强大工具。除以 sqrt(d_k) 是为了稳定梯度。
• LayerNorm : 层归一化，稳定训练。
• 残差连接 ： attention + query ，缓解深层网络梯度消失。
• 位置编码 ：因为自注意力本身没有顺序信息，必须通过 position_embedding 注入序列的位置信息。
• 编码器 ：在文本分类中，我们通常只使用Transformer的编码器部分（如BERT）。解码器用于生成任务（如GPT）。

这个编码器可以接入一个文本分类数据集（如IMDB影评），经过训练后判断文本情感。虽然这是一个简化版，但它完整包含了Transformer的核心思想。

7. GNN实战：图上的信息传播

GNN专门处理图结构数据。其核心思想是通过聚合邻居节点的信息来更新当前节点的表示。

实战目标 ：实现一个简单的图卷积网络（GCN）层，并在Cora引文数据集上进行节点分类。

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_geometric.nn import GCNConv # 需要安装 torch-geometric
from torch_geometric.datasets import Planetoid

# 1. 手动实现一个简单的GCN层（消息传递框架）
class SimpleGCNLayer(nn.Module):
    def __init__(self, in_features, out_features):
        super(SimpleGCNLayer, self).__init__()
        self.linear = nn.Linear(in_features, out_features)

    def forward(self, x, adjacency_matrix):
        # x: 节点特征矩阵 (num_nodes, in_features)
        # adjacency_matrix: 邻接矩阵 (num_nodes, num_nodes)，通常包含自环
        # 聚合邻居信息：A * X
        support = torch.mm(adjacency_matrix, x)
        # 线性变换
        output = self.linear(support)
        return F.relu(output)

# 2. 使用PyTorch Geometric库构建GCN模型（更标准）
class GCN(nn.Module):
    def __init__(self, num_features, hidden_channels, num_classes):
        super(GCN, self).__init__()
        self.conv1 = GCNConv(num_features, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, num_classes)
        self.dropout = nn.Dropout(0.5)

    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        # 第一层GCN
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = self.dropout(x)
        # 第二层GCN
        x = self.conv2(x, edge_index)
        return F.log_softmax(x, dim=1)

# 3. 加载Cora数据集并训练
def train_gnn():
    dataset = Planetoid(root=‘./data/Cora‘, name=‘Cora‘)
    data = dataset[0] # Cora图只有一个
    device = torch.device(‘cuda‘ if torch.cuda.is_available() else ‘cpu‘)
    model = GCN(dataset.num_features, 16, dataset.num_classes).to(device)
    data = data.to(device)
    optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
    criterion = nn.CrossEntropyLoss()

    model.train()
    for epoch in range(200):
        optimizer.zero_grad()
        out = model(data)
        loss = criterion(out[data.train_mask], data.y[data.train_mask]) # 仅用训练节点
        loss.backward()
        optimizer.step()
        if epoch % 20 == 0:
            print(f‘Epoch {epoch}, Loss: {loss.item():.4f}‘)

    # 测试
    model.eval()
    with torch.no_grad():
        pred = model(data).argmax(dim=1)
        correct = (pred[data.test_mask] == data.y[data.test_mask]).sum()
        acc = int(correct) / int(data.test_mask.sum())
        print(f‘Test Accuracy: {acc:.4f}‘)

关键点解析 ：

• 图数据 ：包含节点特征 x 、边索引 edge_index （表示节点间的连接）以及可选的边属性。
• GCNConv : PyTorch Geometric库提供的图卷积层，它封装了基于邻接矩阵的消息传递和聚合操作。
• 消息传递范式 ：1) 从邻居收集消息；2) 聚合消息；3) 更新节点特征。GCN是其中一种特化形式。
• 掩码 ： train_mask , val_mask , test_mask 是布尔张量，用于指定哪些节点用于训练/验证/测试。这是图节点分类任务的典型设置。
• 与CNN/RNN的区别 ：GNN直接在非规则的图结构上操作，不要求数据是网格或序列，使其适用于社交网络、分子图、推荐系统等。

8. 环境准备与工具链

要运行上述代码，你需要配置一个标准的Python深度学习环境。

1. 基础环境 ：

   • Python : 3.8 或以上版本。
   • 包管理 : 强烈建议使用 conda 或 venv 创建独立的虚拟环境。

2. 核心库安装 ：

   # 使用pip安装
   pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118  # 根据你的CUDA版本选择
   pip install numpy matplotlib tqdm
   # 对于Transformer示例，可能还需要安装sentencepiece, datasets等（根据具体NLP任务）
   # 对于GNN示例，需要安装PyTorch Geometric（安装稍复杂，请参考其官方文档）
   # pip install torch-geometric
   

3. 硬件要求 ：

   • CNN/GAN/Transformer训练 ：强烈推荐使用 NVIDIA GPU （显存>=4GB，如RTX 2060, 3060及以上）。CPU训练会非常慢。
   • RNN/简单GNN训练 ：可以在CPU上进行，但GPU能显著加速。
   • 推理/预测 ：大部分模型在CPU上也可运行，只是速度较慢。

4. 数据集获取 ：

   • MNIST/CIFAR-10 ： torchvision.datasets 内置，可自动下载。
   • 文本数据 ：准备你自己的 .txt 文件，或使用 torchtext 、 datasets 库。
   • 图数据 ： torch_geometric.datasets 提供了Cora, Citeseer, PubMed等标准数据集。

9. 模型选择与实战建议

学完五大模型，如何选择？

• 图像相关任务（分类、检测、分割） ：首选 CNN 及其变体（ResNet, EfficientNet, YOLO, U-Net）。这是经过充分验证的范式。
• 序列数据预测（股价、传感器） ：首选 RNN 变体（LSTM, GRU）或 Transformer 。对于长期依赖强的，Transformer更有优势。
• 自然语言处理（分类、生成） ：绝对主流是 Transformer （BERT用于理解，GPT用于生成）。RNN已基本被取代。
• 生成逼真数据（图像、音频） ： GAN 及其变体（StyleGAN, CycleGAN）。扩散模型（如Stable Diffusion）现在是更热门的图像生成选择。
• 关系型、拓扑结构数据 ： GNN 是唯一选择。例如社交网络、分子图、推荐系统、交通网络。

你的第一个实战项目路线图 ：

1. Week 1-2 : 彻底吃透 CNN 在MNIST/CIFAR-10上的实战。理解数据加载、模型定义、训练循环、评估指标。
2. Week 3 : 实现一个简单的 LSTM 进行文本生成或时间序列预测。理解序列数据的处理方式。
3. Week 4 : 复现一个基础的 GAN ，在MNIST上生成数字。体验对抗训练的独特性和不稳定性。
4. Week 5 : 深入研究 Transformer 的自注意力机制。尝试用Hugging Face transformers 库微调一个BERT模型进行情感分析。
5. Week 6 : 探索 GNN ，在Cora数据集上完成节点分类。理解消息传递的抽象。

10. 常见问题与排查指南

理解这五大神经网络模型，你就掌握了现代AI核心的建模范式。从CNN的局部感知到RNN的时序记忆，从GAN的创造对抗到Transformer的全局关联，再到GNN的关系推理，每一种都是对特定数据结构和问题的优雅抽象。真正的掌握源于动手实践。建议你从本文的任意一个代码片段开始，将其跑通，然后修改参数、调整结构、更换数据集，观察变化。在这个过程中，你不仅会学会使用这些工具，更将深入理解它们为何有效，从而真正具备解决新问题的能力。