深度学习之神经网络简介（FNN+CNN+RNN+LSTM+GRU+GAN+GNN+Transformer）

深度学习是机器学习的一个子集，而神经网络是深度学习的核心模型和基础架构，深度神经网络是实现深度学习的具体方法

神经网络是基础模型：它由输入层、若干隐藏层和输出层组成，通过连接神经元来传递和处理信息。一个经典的"标准"神经网络，其隐藏层通常只有几层（比如3-5层），这种网络也能学习不少模式。
深度学习的关键在于"深度"：这里的"深"指的是神经网络中隐藏层的数量非常多（比如几十、上百甚至上千层）。深度学习就是指训练和使用这种深层神经网络的技术总称。正是因为层数深，模型才能自动从数据中逐层提取特征------比如在图像识别中，浅层识别边缘、中层识别形状、深层识别物体整体。

模型	核心思想	使用场景
前馈神经网络FNN（也叫多层感知机MLP）	信号单向流动，不行成循环，是最基础的神经网络结构	入门级任务：简单的分类和回归。结构化数据：处理标准化、表格形式的特征数据
卷积神经网络CNN	通过卷积核提取图像的局部空间特征，具有参数共享和平移不变性	计算机视觉：图像分类、物体检测、图像分割、人脸识别。医学影像分析：如CT、MRI中的病灶检测。视频分析：动作识别
循环神经网络RNN	通过循环连接如记忆，能有效处理序列数据	自然语言处理：文本生成、机器翻译、情感分析。时间序列分析：股票预测。天气预测。语音识别
长短期记忆网络LSTM	RNN的升级版，通过门控结构解决了RNN的长期依赖问题	长序列处理：机器翻译、语音识别、文本生成。重要时间序列：金融预测、流量预测、气象预测。音乐生成等任务
门控循环单元GRU	LSTM的简化版，将遗忘门和输入门合并为更新门，参数更少	与LSTM类似，常用于机器翻译、语音识别等序列建模任务
自编码器Autoencoder	无监督学习，先将输入数据压缩，再尝试解码还原，核心是学习数据的低维表示（编码）	降维和数据压缩、异常检测、数据去噪、特征学习
生成对抗网络GAN	由生成器和判别器两个网络相互博弈、共同进化，最终生成以假乱真的数据	图像生成：生成逼真的人脸、艺术作品。数据增强：生成合成数据、扩充训练集。风格迁移。超分辨率：提高图像清晰度
Transformer	完全基于自注意力机制，能捕捉序列中任意两个元素之间的关系，可并行处理序列	大预言模型LLM：GPT、BERT系列。机器翻译、文本摘要、问答系统。计算机视觉：VIT模型用于图像分类。多模态任务：如图文生成
图神经网络GNN	转为处理非欧几里得空间的图数据设计，能捕捉节点间的复杂关系	社交网络分析：好友推荐、社区发现。知识图谱推理。药物发现与分子性质预测（化学信息学）。推荐系统

深度信念网络 (DBN) 曾是历史上有影响力的模型，由多个受限玻尔兹曼机 (RBM) 堆叠而成，主要用于无监督预训练。但因GAN和VAE等模型的兴起和应用上的限制，近年来已较少使用。

选择哪种模型，取决于数据和任务：

结构化数据（表格）------>前馈神经网络FNN，
图像/视频------>卷积神经网络CNN
文本或时间序列：传统方案选Transformer；若资源受限或数据较小可选LSTM/GRU；简单序列任务选RNN
生成数据：追求逼真度优先选GAN，追求多样性优先选自编码器VAE
图结构数据：图神经网络GNN

不同模型的优缺点

| 模型 | 优点 |缺点|

|--|--|

| 前馈神经网络FNN | 结构简单，易于理解和实现，计算速度快，适合处理静态数据 |无法处理序列数据：如时间序列或文本。参数较多容易过拟合|

| 卷积神经网络CNN | 强空间特征提取能力，参数共享，大幅减少参数量，训练更高效。平移不变性，对物体的位置变化不敏感 |依赖于大规模标注数据，对集合变换敏感，例如旋转或缩放|

| 循环神经网络RNN | 天生适合处理序列数据，能捕捉时间依赖性，记忆上下文信息，可处理不定长序列 |梯度消失/爆炸导致难以学习长距离的依赖关系，即记忆力有限。训练慢，难以并行化|

| 长短期记忆神经网路LSTM | 解决了RNN梯度消失问题，能记住长期信息，性能强大是目前序列建模的重要基石 |结构复杂、训练时间长，计算量大，对数据要求高，需要大量数据才能发挥优势|

| 门控循环单元GRU | 结构比LSTM简单，参数更少，训练更快。再许多中等规模任务上性能与LSTM相当 |表达能力可能弱于LSTM，超复杂的任务上性能稍逊一筹|

| 自编码Autoencoder | 无监督学习，不需要标签数据，强大的特征提取能力 |结果可解释性差，学习到的编码含义不明确，生成能力有限，生成的样本比较模糊|

| 生成对抗网络GAN | 能生成逼真的数据，效果惊艳。无需复杂的马尔可夫链，生成速度快 |训练不稳定，可能出现模式崩溃（生成样本单一），评估困难，难以量化生成图像的质量，计算资源消耗大|

| Transformer | 强大的长距离依赖建模能力，高度并行化，训练效率远超RNN/LSTM，可扩展性极强，模型越大效果越好 |计算和内存消耗大，尤其实在处理超长序列时，需要海量数据才能训练好，否则易过拟合。缺乏归纳偏置，在小数据集上表现可能不如CNN|

| 图神经网络GNN | 处理非欧数据能力强，是图结构数据的首选。捕捉关系依赖，能有效利用节点间的关联信息 |训练复杂，尤其是大规模图数据上的训练。过平滑问题，层数过多导致节点特征趋于一致。计算开销大，扩展性面临挑战|

前馈神经网络 (FNN / MLP) ------ 处理表格数据

python 复制代码

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

class FNNModel(nn.Module):
	def __init__(self):
		super().__init__()
		self.model = nn.Sequential(
			nn.Linear(8,6), # 输入特征8个
			nn.ReLU(),
			nn.Linear(6,4),
			nn.ReLU(),
			nn.ReLU(4,1),# 二分类输出
			nn.Sigmoid()
		)

	def forward(self,x):
		return self.model(x)

model = FNNModel()
criterion = nn.BCELoss()
optimizer = optim.SGD(model.parameters(),lr=0.1)

# 循环序列
for epoch in range(num_epochs):
	outputs = model(num_epochs)
	loss = criterion(outputs,labels)
	optimizer.zero_grad()
	loss.backward()
	optimizer.step()

卷积神经网络 (CNN) ------ 提取图像特征

python 复制代码

import torch.nn.functional as F

class CNNModel(nn.Module):
	def __init__(self):
		super().__init__()
		self.conv1 = nn.Conv2d(3,6,5) # 定义卷积层，输入通道数，输出通道数，卷积核尺寸
		self.pool = nn.MaxPool2d(2,2) # 池化层
		self.conv2 = nn.Conv2d(6,16,5)
		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(F.relu(self.conv1(x)))
		x = self.pool(F.relu(self.conv2(x)))
		x = torch.flatten(x,1)
		x = F.relu(self.fc1(x))
		x = F.relu(self.fc2(x))
		x = self.fc3(x)
		return x

循环神经网络 (RNN) ------ 处理序列数据

需要关注数据维度(batch,seq_len,input_size)，RNN存在梯度问题，不适合长序列

python 复制代码

class RNNNodel(nn.Module):
	# num_layers=2表示堆叠两层
	def __init__(self,input_size,hidden_size,output_size):
		super().__init__()
		self.hidden_size = hidden_size
		# bidirectional=True表示双向，双向的输出维度会翻倍hidden_size * 2
		# self.num_layers = num_layers 表示堆叠两层
		self.rnn = nn.RNN(input_size,hidden_size,batch_first=True)
		self.fc = nn.Linear(hidden_size,output_size)
		
	def forward(self,x):
		# out:每个时间步输出，_:最后一个时间步的隐藏状态
		out,_ = self.rnn(x)
		out = self.fc(out[:,-1,:]) # 取最后一个时间步的输出
		return out

LSTM与GRU------RNN进阶版

python 复制代码

"""
	通过门控机制解决长序列的梯度消失问题，适用于时间序列预测和自然语言处理
	nn.LSTM(...,bidrectional=True,num_layers=3) 构建深层双向网络
"""
class LSTMModel(nn.Module):
	def __init__(self,input_size,hidden_size,output_size):
		super().__init__()
		# GRU的实现与LSTM几乎相同，只需将 `nn.LSTM` 替换为 `nn.GRU` 即可
		self.lstm = nn.LSTM(input_size,hidden_size,batch_first=True)
		self.fc = nn.Linear(hidden_size,output_size)

	def forward(self,x):
		out,_ = self.lstm() # # LSTM返回输出和隐藏状态
		out = self.fc(out[:,-1,:])

自编码器 (Autoencoder) ------ 学习压缩表示

python 复制代码

"""
它的目标是将输入编码成低维特征再解码回原始数据。适用于降维、去噪等
自编码器的损失函数通常为均方误差MSE，目标是让模型尽可能复现输入
"""
class Autoencoder(nn.Module):
	def __init__(self):
		super().__init__()
		self.encoder = nn.Sequential(
			nn.Linear(28*28,128),
			nn.ReLU(),
			nn.Linear(128,64),
			nn.ReLU(),
			nn.Linear(64,32) # 压缩后的低维特征
		)
		self.decoder = nn.Sequential(
			nn.Linear(32, 64),
            nn.ReLU(),
            nn.Linear(64, 128),
            nn.ReLU(),
            nn.Linear(128, 28*28),
            nn.Sigmoid()        # 输出值映射到[0,1]
		)

		def forward(self,x):
			encoded = self.encoder(x)
			decoded = self.decoder(encoded)
			return decoded

生成对抗网络 (GAN) ------ 以假乱真

python 复制代码

"""
包含生成器G和判别器D，两个相互博弈的网络，适用于图像生成
GAN的训练是交替的，计算两个独立的损失
"""
# 生成器：从随机噪声生成图片
class Generator(nn.Module):
	def __init__(self,latent_dim=100)
		super().__init__()
		self.model = nn.Sequential(
			nn.Linear(latent_dim,256),
			nn.ReLU(),
			nn.Linear(256,512),
			nn.ReLU(),
			nn.Linear(512,28*28)
			nn.Tanh()  # 输出值映射到[-1,1]	
		)

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

# 判别器：判断真假图片
class Discriminator(nn.Module):
	def __init__(self):
		super().__init__()
		self.model = nn.Sequential(
			nn.Linear(28*28,512),
			nn.LeakyReLU(0.2),
			nn.Linear(512,256),
			nn.LeakyReLU(0.2),
			nn.Sigmoid() # 输出是0到1间的概率
		)
	def forward(self,img):
		return self.model(img)

Transformer ------ 注意力机制

python 复制代码

"""
基于自注意力机制，替代了循环结构，适用于长文本理解，机器翻译
输入维度(seq_len,batch,features)，nhead是注意力头数，是核心超参数
"""
class TransformerClassifier(nn.Module):
	def __init__(self,input_dim,hidden_dim,num_layers,num_classes):
		super().__init__()
		encouder_layer = nn.TransformerEncoderLayer(d_model=hidden_dim,nhead=8)
		self.transformer = nn.TransformerEncoder(encoder_layer,num_layers=num_layers)
		self.fc = nn.Linear(hidden_dim,num_classes)

	def forward(self,src):
		# (seq_len,batch_size,input_dim)
		output = self.transformer(src)
		output = output.mean(dim=0) # 取所有时间步的均值作为特征
		return self.fc(output) # 分类

图神经网络 (GNN) ------ 处理图数据

GNN通过消息传递来聚合邻居节点信息。适用于社交网络分析、分子性质预测

python 复制代码

"""
GNN通常依赖如PyG等专用库，需要处理edge_index（图的连接关系），这是最核心的数据结构
"""
import torch.nn.functional as F
from torch_geometric.nn.import GCNConv

class GNN(torch.nn.Module):
	def __init__(self,in_channels,hidden_channels,out_channels):
	super().__init__()
	self.conv1 = GCNConv(in_channels,hidden_channels)
	self.conv2 = GCNConv(hidden_channels,out_channels)
	
	def forward(self,x,edge_index):
		# x:节点特征，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)

总结：

设计模式相同点

统一的基类：网络模型都继承自torch.nn.Module
结构化的代码组织：每个模型都遵循__init__定义层，forward定义前向传播的范式
标准化的训练流程：训练循环都遵循zero_grad -> forward -> loss -> backward -> step 的标准五步
模块化的网络层：所有模型的构建方式一致，都通过组合torch.nn中的基础层完成
可微分的损失函数：不同任务只是选择不同的Torch损失函数

不同点：

层与数据处理逻辑：FNN通过Linear层堆叠，CNN用Conv2d和MaxPool2d，RNN类只需要nn.LSTM一个层，但需要关注隐藏状态的处理，而GNN核心是edge_index来处理图结构
数据维度处理：CNN的卷积是（C，H，W）通道格式，需flatten展平；RNN类默认(seq_len,batch,features)，需要设置batch_first=True方便使用
参数共享机制：CNN的卷积核在不同位置权值共享；RNN类在每个时间步共享相同的网络参数；Transformer全部注意力头是并行计算；GAN有两个独立模型参数

不同模型的使用和优化要点

FNN：过于简单，复杂任务需要加深网络并配合BatchNorm等技巧
CNN：图像增广非常重要；图像数据量大时可考虑迁移学习如ResNet
RNN/LSTM：核心是解决梯度消失的长期记忆问题；可以通过堆叠多层RNN提升容量
GAN：训练最难且不稳定，需要使用LeakyReLU等技巧
Transformer：计算重，对超长序列可尝试稀疏注意力；若资源有限，Hugging Face非常方便
GNN：依赖图结构，通常需要torch-geometric等外置库