🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度

在实际 AI 和深度学习项目中，面对图像、文本、序列、图结构等不同类型的数据，开发者常常困惑于如何选择合适的神经网络模型。CNN、RNN、GAN、Transformer、GNN 这五大模型各自解决了特定领域的核心问题，但它们的原理、适用场景和实现细节却大相径庭。很多教程要么过于理论化，要么只讲代码不讲“为什么”，导致读者虽然能跑通一个示例，却无法举一反三，遇到新问题依然无从下手。

本文旨在为有一定 Python 和深度学习基础的开发者，提供一个从原理到实战的贯通式指南。我们将逐一拆解这五大模型的核心思想、工作机制和典型应用场景，并辅以可运行的 PyTorch 代码片段，帮助你不仅知道“怎么用”，更理解“为什么能用”以及“什么时候该用”。学完后，你将能够根据手头的数据类型和任务目标，清晰地判断该选用哪种模型架构，并具备搭建一个最小可行原型的能力。

1. 卷积神经网络：从图像中提取空间特征的利器

卷积神经网络是处理具有网格状拓扑结构数据（如图像）的标配。其核心思想在于利用卷积核（滤波器）在输入数据上滑动，局部地、分层地提取特征，从而显著减少参数数量并保留空间信息。

1.1 CNN 的核心组件与工作流程

一个典型的 CNN 由卷积层、池化层和全连接层交替堆叠而成。

卷积层是特征提取的主力。每个卷积核负责检测一种特定的局部模式（如边缘、纹理）。通过多个卷积核，网络可以学习到从简单到复杂的多层次特征。卷积操作的本质是局部连接和权值共享，这使其参数效率远高于全连接网络。

import torch import torch.nn as nn import torch.nn.functional as F class SimpleCNN(nn.Module): def __init__(self): super(SimpleCNN, self).__init__() # 卷积层1: 输入通道1（灰度图），输出通道6，卷积核大小5x5 self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5) # 卷积层2: 输入通道6，输出通道16，卷积核大小5x5 self.conv2 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5) # 全连接层 self.fc1 = nn.Linear(16 * 4 * 4, 120) # 需要根据输入尺寸计算 self.fc2 = nn.Linear(120, 84) self.fc3 = nn.Linear(84, 10) # 假设10分类 def forward(self, x): # 卷积 -> ReLU激活 -> 最大池化 (2x2窗口) x = F.max_pool2d(F.relu(self.conv1(x)), 2) x = F.max_pool2d(F.relu(self.conv2(x)), 2) # 展平特征图 x = x.view(-1, 16 * 4 * 4) # 全连接层 x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return x # 示例：创建一个网络并处理一个随机图像批次 net = SimpleCNN() input = torch.randn(1, 1, 28, 28) # 批次大小1， 1通道， 28x28图像 output = net(input) print(f"输出形状: {output.shape}") # 应为 torch.Size([1, 10])

池化层（通常是最大池化或平均池化）跟在卷积层之后，用于对特征图进行下采样。其主要作用是降低特征图的空间尺寸，从而减少计算量、参数数量，并引入一定的平移不变性。

全连接层通常位于网络末端，将经过多次卷积和池化后提取到的高级抽象特征映射到最终的输出空间（如分类类别）。

1.2 CNN 实战：手写数字识别

以经典的 MNIST 数据集为例，一个完整的训练流程包括数据加载、模型定义、损失函数与优化器选择、训练循环和评估。

import torchvision import torchvision.transforms as transforms from torch.utils.data import DataLoader # 1. 数据准备 transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) # MNIST 的均值和标准差 ]) trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform) trainloader = DataLoader(trainset, batch_size=64, shuffle=True) testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform) testloader = DataLoader(testset, batch_size=1000, shuffle=False) # 2. 模型、损失函数、优化器 model = SimpleCNN() criterion = nn.CrossEntropyLoss() optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9) # 3. 训练循环（简化版） def train(epoch): model.train() for batch_idx, (data, target) in enumerate(trainloader): optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() if batch_idx % 100 == 0: print(f'Train Epoch: {epoch} [{batch_idx * len(data)}/{len(trainloader.dataset)}] Loss: {loss.item():.6f}') # 4. 测试评估 def test(): model.eval() test_loss = 0 correct = 0 with torch.no_grad(): for data, target in testloader: output = model(data) test_loss += criterion(output, target).item() pred = output.argmax(dim=1, keepdim=True) correct += pred.eq(target.view_as(pred)).sum().item() test_loss /= len(testloader.dataset) accuracy = 100. * correct / len(testloader.dataset) print(f'Test set: Average loss: {test_loss:.4f}, Accuracy: {correct}/{len(testloader.dataset)} ({accuracy:.2f}%)')

1.3 CNN 的常见陷阱与调优

1. 输入尺寸与全连接层不匹配：这是新手最常见的错误。卷积和池化会改变特征图的尺寸，如果输入图像尺寸变化，全连接层的输入维度必须重新计算。在上面的SimpleCNN中，我们假设输入是28x28，经过两次5x5卷积和2x2池化后，特征图尺寸变为(28-5+1)/2 -> 12, (12-5+1)/2 -> 4，因此fc1的输入是16 * 4 * 4。如果输入尺寸改变，这个值需要重新计算。
2. 过拟合：CNN 参数量大，容易在小数据集上过拟合。解决方法包括：使用数据增强（随机裁剪、翻转、颜色抖动）、添加 Dropout 层、使用 L2 权重衰减、以及使用更深的网络配合早停法。
3. 梯度消失/爆炸：在非常深的 CNN 中（如 ResNet），梯度在反向传播时可能变得极小或极大。使用 ReLU 及其变体（如 Leaky ReLU）作为激活函数、采用批归一化、以及使用残差连接是解决此问题的关键。

2. 循环神经网络：处理序列数据的记忆网络

循环神经网络专为处理序列数据而设计，如时间序列、文本、语音。其核心特点是具有“循环”结构，使得网络能够保留之前时间步的信息，即拥有“记忆”。

2.1 RNN 的基本结构与变体

最基本的 RNN 单元结构简单，但在处理长序列时容易遇到梯度消失或爆炸问题，导致难以学习长期依赖关系。

import torch.nn as nn class SimpleRNN(nn.Module): def __init__(self, input_size, hidden_size, output_size): super(SimpleRNN, self).__init__() self.hidden_size = hidden_size # RNN 层 self.rnn = nn.RNN(input_size, hidden_size, batch_first=True) # 全连接输出层 self.fc = nn.Linear(hidden_size, output_size) def forward(self, x): # x 形状: (batch_size, sequence_length, input_size) # out 形状: (batch_size, sequence_length, hidden_size) # h_n 形状: (1, batch_size, hidden_size) out, h_n = self.rnn(x) # 取最后一个时间步的输出用于预测 out = self.fc(out[:, -1, :]) return out # 示例：处理一个序列 model = SimpleRNN(input_size=10, hidden_size=20, output_size=1) input_seq = torch.randn(5, 8, 10) # 批次5，序列长度8，特征维度10 output = model(input_seq) print(f"输出形状: {output.shape}") # 应为 torch.Size([5, 1])

为了解决长期依赖问题，出现了两种重要的 RNN 变体：长短期记忆网络和门控循环单元。

• LSTM：引入了细胞状态和三个门（输入门、遗忘门、输出门），可以更精细地控制信息的保留与遗忘。
• GRU：LSTM 的简化版，将细胞状态和隐藏状态合并，并使用更新门和重置门，参数更少，计算更快。

在 PyTorch 中，可以轻松地将nn.RNN替换为nn.LSTM或nn.GRU。

# 使用 LSTM lstm = nn.LSTM(input_size=10, hidden_size=20, batch_first=True) # 使用 GRU gru = nn.GRU(input_size=10, hidden_size=20, batch_first=True)

2.2 RNN 实战：文本情感分类

假设我们有一个简单的电影评论数据集，任务是判断评论是正面还是负面。

# 假设已有词汇表和文本向量化工具（如 torchtext 或自定义） class SentimentRNN(nn.Module): def __init__(self, vocab_size, embed_dim, hidden_dim, output_dim, n_layers): super().__init__() self.embedding = nn.Embedding(vocab_size, embed_dim) # 使用双向 LSTM 以捕获前后文信息 self.rnn = nn.LSTM(embed_dim, hidden_dim, num_layers=n_layers, bidirectional=True, batch_first=True, dropout=0.5) self.fc = nn.Linear(hidden_dim * 2, output_dim) # 双向，所以是 hidden_dim * 2 self.dropout = nn.Dropout(0.5) def forward(self, text): # text 形状: (batch_size, sequence_length) embedded = self.dropout(self.embedding(text)) # embedded 形状: (batch_size, sequence_length, embed_dim) output, (hidden, cell) = self.rnn(embedded) # 取双向 LSTM 最后时刻的前向和后向隐藏状态，拼接 hidden = torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim=1) # hidden 形状: (batch_size, hidden_dim * 2) return self.fc(self.dropout(hidden))

2.3 RNN 与 CNN 在处理序列数据上的区别

这是一个常见困惑点。虽然两者都能处理序列，但思路不同：

注意：Transformer 的出现很大程度上解决了 RNN 并行化差和长程依赖学习难的问题，但在某些对顺序敏感的任务中，RNN 及其变体仍有其价值。

3. 生成对抗网络：让机器学会“创造”

生成对抗网络的核心思想源于博弈论，它通过让两个神经网络（生成器和判别器）相互对抗、共同进化，从而学习到真实数据的分布，并生成以假乱真的新数据。

3.1 GAN 的基本原理与训练动态

GAN 包含两个部分：

• 生成器：接收一个随机噪声向量（如高斯分布），并试图生成与真实数据相似的样本。它的目标是“欺骗”判别器。
• 判别器：接收一个样本（来自真实数据集或生成器），并判断它是“真实的”还是“伪造的”。它的目标是尽可能准确地区分真假。

两者的目标函数是对抗的：

min_G max_D V(D, G) = E_{x~p_data(x)}[log D(x)] + E_{z~p_z(z)}[log(1 - D(G(z)))]

其中，D(x)是判别器认为样本x来自真实数据的概率。G(z)是生成器根据噪声z生成的样本。

# 定义生成器 class Generator(nn.Module): def __init__(self, latent_dim, img_shape): super(Generator, self).__init__() self.img_shape = img_shape def block(in_feat, out_feat, normalize=True): layers = [nn.Linear(in_feat, out_feat)] if normalize: layers.append(nn.BatchNorm1d(out_feat, 0.8)) layers.append(nn.LeakyReLU(0.2, inplace=True)) return layers self.model = nn.Sequential( *block(latent_dim, 128, normalize=False), *block(128, 256), *block(256, 512), *block(512, 1024), nn.Linear(1024, int(np.prod(img_shape))), nn.Tanh() # 输出在 [-1, 1] 之间，与归一化的图像数据匹配 ) def forward(self, z): img = self.model(z) img = img.view(img.size(0), *self.img_shape) return img # 定义判别器 class Discriminator(nn.Module): def __init__(self, img_shape): super(Discriminator, self).__init__() self.model = nn.Sequential( nn.Linear(int(np.prod(img_shape)), 512), nn.LeakyReLU(0.2, inplace=True), nn.Linear(512, 256), nn.LeakyReLU(0.2, inplace=True), nn.Linear(256, 1), nn.Sigmoid(), # 输出一个概率值 ) def forward(self, img): img_flat = img.view(img.size(0), -1) validity = self.model(img_flat) return validity

3.2 GAN 训练流程与挑战

训练 GAN 是一个交替优化的过程：

1. 固定生成器，训练判别器：用真实数据和生成器产生的假数据训练判别器，使其能更好地区分真假。
2. 固定判别器，训练生成器：训练生成器使其产生的数据能“骗过”当前判别器。

# 训练循环核心部分 for epoch in range(num_epochs): for i, (imgs, _) in enumerate(dataloader): # 真实数据 real_imgs = imgs.to(device) # 训练判别器 optimizer_D.zero_grad() # 真实数据的损失 real_validity = discriminator(real_imgs) d_real_loss = adversarial_loss(real_validity, real_label) # 生成假数据 z = torch.randn(imgs.size(0), latent_dim).to(device) fake_imgs = generator(z) # 假数据的损失 fake_validity = discriminator(fake_js.detach()) # 注意 detach，防止梯度传到生成器 d_fake_loss = adversarial_loss(fake_validity, fake_label) # 判别器总损失 d_loss = (d_real_loss + d_fake_loss) / 2 d_loss.backward() optimizer_D.step() # 训练生成器 optimizer_G.zero_grad() # 生成器希望判别器将假数据判为真 fake_validity = discriminator(fake_imgs) g_loss = adversarial_loss(fake_validity, real_label) # 注意标签是 real_label g_loss.backward() optimizer_G.step()

GAN 训练 notoriously difficult，常见问题有：

• 模式崩溃：生成器只学会生成少数几种样本，缺乏多样性。解决方法：使用 Mini-batch Discrimination、Unrolled GAN、或改用 WGAN-GP 等改进架构。
• 训练不稳定：生成器和判别器的损失剧烈振荡，难以收敛。解决方法：仔细调整学习率、使用 Adam 优化器、尝试不同的网络架构、使用梯度惩罚。
• 评估困难：如何定量评估生成图像的质量？常用指标有 Inception Score 和 Fréchet Inception Distance。

4. Transformer：彻底改变序列建模的注意力机制

Transformer 完全摒弃了循环和卷积结构，仅依赖自注意力机制来建立序列中元素之间的全局依赖关系，实现了高度的并行化和对长程依赖的有效建模。

4.1 自注意力机制详解

自注意力机制的核心是计算序列中每个元素与其他所有元素的相关性（注意力权重），然后根据这些权重对所有元素的值进行加权求和，得到该元素的新表示。

import math import torch import torch.nn as nn 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" 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): N = query.shape[0] # 批次大小 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) # 计算注意力分数 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) # 应用注意力权重到 values 上 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

4.2 Transformer 编码器块

一个 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): 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

4.3 Transformer 实战：简易文本分类

虽然 Transformer 最初用于序列到序列任务，但其编码器部分可以很好地用于文本分类。

class TransformerClassifier(nn.Module): def __init__(self, vocab_size, embed_size, num_layers, heads, device, forward_expansion, dropout, max_length, num_classes): super(TransformerClassifier, 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=dropout, forward_expansion=forward_expansion) for _ in range(num_layers) ] ) self.dropout = nn.Dropout(dropout) self.fc_out = nn.Linear(embed_size, num_classes) def forward(self, x, mask): 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) # 取序列第一个位置（[CLS] token）的输出作为句子表示，用于分类 out = out[:, 0, :] out = self.fc_out(out) return out

4.4 Transformer 的优势与演进

Transformer 的优势在于：

• 并行计算：自注意力机制可以同时计算序列中所有位置的关系。
• 长程依赖：任何两个位置的距离都是常数级的，解决了 RNN 的长程依赖问题。
• 可解释性：注意力权重可以可视化，显示模型在做决策时关注了输入的哪些部分。

基于 Transformer 的演进模型层出不穷，如 BERT（仅用编码器，双向上下文）、GPT（仅用解码器，自回归生成）、Vision Transformer（将图像分块处理为序列）等，它们已成为 NLP 和 CV 领域的基石模型。

5. 图神经网络：处理非欧几里得数据的强大工具

图神经网络专门处理图结构数据，其中实体（节点）通过关系（边）连接。社交网络、分子结构、推荐系统、知识图谱等都是图数据的典型例子。

5.1 GNN 的核心思想：消息传递

GNN 的核心范式是消息传递。在每一层，每个节点会聚合来自其邻居节点的信息，并结合自身的信息进行更新。经过多层传播后，每个节点的表示都包含了其多跳邻域的结构和特征信息。

import torch from torch_geometric.nn import MessagePassing from torch_geometric.utils import add_self_loops, degree class GCNConv(MessagePassing): def __init__(self, in_channels, out_channels): super(GCNConv, self).__init__(aggr='add') # 聚合方式为求和 self.lin = torch.nn.Linear(in_channels, out_channels) def forward(self, x, edge_index): # x 形状: [num_nodes, in_channels] # edge_index 形状: [2, num_edges] # 步骤1: 添加自环 edge_index, _ = add_self_loops(edge_index, num_nodes=x.size(0)) # 步骤2: 线性变换节点特征 x = self.lin(x) # 步骤3: 计算归一化系数 row, col = edge_index deg = degree(col, x.size(0), dtype=x.dtype) deg_inv_sqrt = deg.pow(-0.5) deg_inv_sqrt[deg_inv_sqrt == float('inf')] = 0 norm = deg_inv_sqrt[row] * deg_inv_sqrt[col] # 步骤4: 开始消息传递 return self.propagate(edge_index, x=x, norm=norm) def message(self, x_j, norm): # x_j 形状: [num_edges, out_channels] # norm 形状: [num_edges] return norm.view(-1, 1) * x_j

5.2 GNN 实战：Cora 数据集节点分类

Cora 是一个经典的引文网络数据集，节点代表论文，边代表引用关系，任务是对论文进行主题分类。

import torch.nn.functional as F from torch_geometric.datasets import Planetoid from torch_geometric.nn import GCNConv class GCN(torch.nn.Module): def __init__(self, num_features, num_classes): super(GCN, self).__init__() self.conv1 = GCNConv(num_features, 16) self.conv2 = GCNConv(16, num_classes) def forward(self, data): x, edge_index = data.x, data.edge_index x = self.conv1(x, edge_index) x = F.relu(x) x = F.dropout(x, training=self.training) x = self.conv2(x, edge_index) return F.log_softmax(x, dim=1) # 加载数据集 dataset = Planetoid(root='/tmp/Cora', name='Cora') data = dataset[0] # 创建模型、优化器 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = GCN(dataset.num_features, dataset.num_classes).to(device) data = data.to(device) optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4) # 训练函数 def train(): model.train() optimizer.zero_grad() out = model(data) loss = F.nll_loss(out[data.train_mask], data.y[data.train_mask]) loss.backward() optimizer.step() return loss # 测试函数 def test(): model.eval() out = model(data) pred = out.argmax(dim=1) accs = [] for mask in [data.train_mask, data.val_mask, data.test_mask]: correct = pred[mask].eq(data.y[mask]).sum().item() acc = correct / mask.sum().item() accs.append(acc) return accs # 训练循环 for epoch in range(1, 201): loss = train() if epoch % 50 == 0: train_acc, val_acc, test_acc = test() print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}, Train: {train_acc:.4f}, Val: {val_acc:.4f}, Test: {test_acc:.4f}')

5.3 GNN 的挑战与变体

1. 过平滑：随着 GNN 层数加深，所有节点的表示会趋向于相同，丢失区分度。解决方法：使用残差连接、跳跃连接、或更精细的聚合方式。
2. 计算效率：大规模图的邻接矩阵非常稀疏，直接操作效率低。使用稀疏矩阵运算库和采样技术是关键。
3. 异构图：现实中的图往往包含多种节点和边类型。需要使用异构图神经网络。

常见的 GNN 变体包括：

• GraphSAGE：通过采样邻居进行聚合，适用于大规模图。
• GAT：引入注意力机制，为不同邻居分配不同的重要性权重。
• Graph Isomorphism Network：理论上具有更强的图结构区分能力。

6. 模型选型与实战避坑指南

面对具体任务，如何选择模型？下表提供了一个快速决策参考：

6.1 实战中的通用排查路径

无论使用哪种模型，遇到问题都可以按以下顺序排查：

1. 数据问题：
   • 现象：损失不下降、准确率随机。
   • 检查：数据加载是否正确（打印几个样本查看）、标签是否对应、数据是否归一化/标准化、类别是否均衡、训练/验证集是否有重叠。
2. 模型结构问题：
   • 现象：损失为 NaN、输出全为同一值。
   • 检查：模型初始化是否正确、激活函数是否适合（如最后一层分类用 Softmax）、输入输出维度是否匹配、是否有梯度流动（打印中间层输出）。
3. 训练过程问题：
   • 现象：过拟合（训练集损失下降，验证集损失上升）或欠拟合（两者都高）。
   • 检查：学习率是否合适（尝试学习率查找器）、正则化是否足够（Dropout, L2）、模型容量是否匹配数据复杂度、训练轮数是否足够。
4. 实现细节问题：
   • 现象：结果不可复现、GPU 内存溢出。
   • 检查：是否设置了随机种子、model.train()和model.eval()模式是否正确切换、批次大小是否超出内存、是否有内存泄漏（如张量累积）。

6.2 生产环境考量

将模型从实验推向生产，还需要考虑：

• 模型轻量化：使用模型剪枝、量化、知识蒸馏等技术减小模型体积，提升推理速度。
• 服务化部署：使用 TorchServe、TensorFlow Serving、ONNX Runtime 或 Triton Inference Server 进行高效、稳定的服务部署。
• 监控与日志：记录模型的输入、输出、延迟和资源使用情况，设置异常检测和性能告警。
• 持续集成/持续部署：建立自动化的模型训练、验证、打包和部署流水线。

理解这五大神经网络模型的核心原理和适用场景，是构建有效 AI 应用的基础。建议从简单的数据集和模型开始，亲手实现一遍训练和评估流程，并尝试调整超参数、修改网络结构，观察其对结果的影响。在实践中，模型的选择和组合往往比追求单一模型的极致性能更重要。例如，可以使用 CNN 提取图像特征，再用 RNN 处理图像描述生成序列；或者用 GNN 学习分子结构，再将节点特征输入到全连接网络进行属性预测。掌握这些基本模块，你就能像搭积木一样，设计出解决复杂问题的定制化神经网络架构。

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度