深度学习，在人工智能领域不断取得了发展成就。其中，RNN、CNN、Transformer、BERT以及GPT五种深度学习模型，凭借其独特的优势，在计算机视觉、自然语言处理等诸多领域实现了重要突破。

本文将从四大维度——关键技术、数据处理、应用场景以及经典案例，对这五种模型进行简要介绍。首先，在关键技术方面，这五种模型各具特色，它们通过不同的算法和结构来提取数据中的深层信息，实现了高效的特征学习和模式识别。

学习籽料合集戳这个连接自行或取学习~！！https://wcnbx01287rr.feishu.cn/wiki/ZkFUwE5S4idgcbkValZchcmwnPf?from=from_copylink

1、RNN（循环神经网络）

时间：起始于20世纪90年代

关键技术：依托独特的循环结构与记忆单元

处理数据：尤其擅长应对时间序列数据的处理

应用场景：广泛应用于自然语言处理、语音识别、时间序列预测等诸多领域

RNN，作为一种高效的神经网络模型，其核心架构呈现为独特的循环体形式，使之能够有效应对序列数据的处理需求。其最显著的特点在于，RNN在处理当前输入信息的同时，亦能够将之前的信息有效储存于记忆单元之中，进而形成持续性的记忆能力。这种设计赋予了RNN在处理具有时序关系的数据时得天独厚的优势，因此，在自然语言处理、语音识别等任务中，RNN均展现出了卓越的性能与广泛的应用前景。

经典案例：RNN文本分类Python代码示例

import torch
import torch.nn as nn
import torch.optim as optim
from torchtext.legacy import data, datasets
from torchtext.legacy import Field

# 定义设备
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# 定义文本字段和标签字段
TEXT = Field(tokenize='spacy', lower=True)
LABEL = Field(sequential=False, use_vocab=False)

# 定义数据集和迭代器
train_data, test_data = datasets.IMDB.splits(TEXT, LABEL)
train_iterator, test_iterator = data.BucketIterator.splits(
    (train_data, test_data), 
    batch_size=64, 
    device=device  # 使用预先定义的device
)

# 加载预训练词向量
TEXT.build_vocab(train_data, max_size=10000, vectors="glove.6B.100d", unk_init=torch.Tensor.normal_)

class RNN(nn.Module):
    def __init__(self, input_dim, embedding_dim, hidden_dim, output_dim):
        super().__init__()
        
        self.embedding = nn.Embedding(input_dim, embedding_dim)
        self.rnn = nn.RNN(embedding_dim, hidden_dim)
        self.fc = nn.Linear(hidden_dim, output_dim)
    
    def forward(self, text):
        # 将文本转化为词嵌入
        embedded = self.embedding(text)
        
        # 对词嵌入应用RNN
        output, hidden = self.rnn(embedded)
        
        # 取RNN的最后一个输出
        assert torch.equal(output[-1,:,:], hidden.squeeze(0))
        
        # 通过全连接层进行分类
        return self.fc(hidden.squeeze(0))

INPUT_DIM = len(TEXT.vocab)
EMBEDDING_DIM = 100
HIDDEN_DIM = 256
OUTPUT_DIM = 1

model = RNN(INPUT_DIM, EMBEDDING_DIM, HIDDEN_DIM, OUTPUT_DIM)

# 将预训练词向量加载到嵌入层
pretrained_embeddings = TEXT.vocab.vectors
model.embedding.weight.data.copy_(pretrained_embeddings)

# 移动模型到设备
model = model.to(device)
optimizer = optim.Adam(model.parameters())
criterion = nn.BCEWithLogitsLoss()

def train(model, iterator, optimizer, criterion):
    model.train()
    epoch_loss = 0
    
    for batch in iterator:
        # 获取文本和标签并移动到设备
        text = batch.text.to(device)
        labels = batch.label.float().unsqueeze(1).to(device)
        
        optimizer.zero_grad()
        
        predictions = model(text)  # 移除多余的squeeze，保持与标签形状一致
        
        loss = criterion(predictions, labels)
        
        loss.backward()
        
        optimizer.step()
        
        epoch_loss += loss.item()
    
    return epoch_loss / len(iterator)

N_EPOCHS = 5

for epoch in range(N_EPOCHS):
    train_loss = train(model, train_iterator, optimizer, criterion)
    print(f'Epoch: {epoch+1:02}, Train Loss: {train_loss:.3f}')

2、CNN（卷积神经网络）

时间：20世纪90年代末至21世纪初

关键技术：卷积运算与池化操作

处理数据：尤为擅长处理图像数据

应用场景：广泛应用于计算机视觉、图像分类、物体检测等领域

CNN作为一种独特的神经网络模型，其核心结构由多个卷积层与池化层精妙组合而成。卷积层通过精巧的计算方法，能够有效地从图像中提炼出各类局部特征；而池化层则发挥着至关重要的作用，通过降低特征数量，显著提升了计算效率。正是这样的结构特点，使得CNN在处理计算机视觉任务时表现出色，如图像分类、物体检测等任务皆能游刃有余。相较于RNN，CNN在处理图像数据方面更胜一筹，它能够自动学习图像中的局部特征，无需人工设计繁琐的特征提取器，从而实现了更高效、更精准的处理效果。

经典案例：CNN猫狗识别Python代码示例

# 导入所需的库
import numpy as np
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D
from tensorflow.keras.layers import Activation, Dropout, Flatten, Dense
from tensorflow.keras import backend as K

# 图像的尺寸
img_width, img_height = 150, 150

# 设定训练数据和验证数据的路径
train_data_dir = 'data/train'
validation_data_dir = 'data/validation'
nb_train_samples = 2000
nb_validation_samples = 800
epochs = 50
batch_size = 16

if K.image_data_format() == 'channels_first':
    input_shape = (3, img_width, img_height)
else:
    input_shape = (img_width, img_height, 3)

# 构建CNN模型
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape=input_shape))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Flatten())  # 将3D特征图展平为1D特征向量
model.add(Dense(64))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(1))
model.add(Activation('sigmoid'))  # 二分类问题使用sigmoid激活函数

# 编译模型
model.compile(loss='binary_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])

# 数据增强，增加模型的泛化能力
train_datagen = ImageDataGenerator(
    rescale=1. / 255,
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True)

test_datagen = ImageDataGenerator(rescale=1. / 255)

train_generator = train_datagen.flow_from_directory(
    train_data_dir,
    target_size=(img_width, img_height),
    batch_size=batch_size,
    class_mode='binary')

validation_generator = test_datagen.flow_from_directory(
    validation_data_dir,
    target_size=(img_width, img_height),
    batch_size=batch_size,
    class_mode='binary')

# 训练模型（使用fit替代fit_generator，fit已支持生成器输入）
model.fit(
    train_generator,
    steps_per_epoch=nb_train_samples // batch_size,
    epochs=epochs,
    validation_data=validation_generator,
    validation_steps=nb_validation_samples // batch_size)

# 评估模型（使用evaluate替代evaluate_generator）
score = model.evaluate(
    validation_generator,
    steps=nb_validation_samples // batch_size
)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

3、Transformer

时间：2017年

关键技术：自注意力机制与多头注意力机制的完美融合

处理数据：针对长序列数据展现卓越处理能力

应用场景：广泛应用于自然语言处理、机器翻译、文本生成等诸多领域

Transformer，作为一种基于自注意力机制的神经网络模型，凭借其独特的架构和机制，成为了深度学习领域的璀璨明星。其精妙之处在于由多个编码器和解码器共同构建的基本结构，编码器负责将输入的序列精妙地转换为向量表示，而解码器则负责将这一向量表示巧妙地还原为输出序列。

Transformer的创新之处在于引入了自注意力机制，这一机制赋予了模型捕捉序列中长距离依赖关系的非凡能力。它不再局限于传统的局部信息处理，而是能够洞察全局，把握整体，从而在处理长序列数据时表现出色。

在自然语言处理领域，Transformer以其卓越的性能赢得了广泛的赞誉和应用。无论是机器翻译中的精确翻译，还是文本生成中的流畅表达，Transformer都展现出了令人瞩目的成果。它的出现，无疑为自然语言处理领域的发展注入了新的活力。

经典案例：Transformer进行文本生成的Python代码示例

from transformers import GPT2LMHeadModel, GPT2Tokenizer

# 加载预训练的模型和分词器
model_name = "gpt2-medium"
tokenizer = GPT2Tokenizer.from_pretrained(model_name)
# GPT2默认没有pad_token，这里将eos_token设为pad_token避免警告
tokenizer.pad_token = tokenizer.eos_token
model = GPT2LMHeadModel.from_pretrained(model_name)

# 输入的文本
input_text = "The quick brown fox"

# 对输入文本进行编码，添加padding和截断处理
input_ids = tokenizer(
    input_text,
    return_tensors="pt",
    padding=True,
    truncation=True,
    max_length=512  # GPT2的最大输入长度
)["input_ids"]  # 只需要input_ids

# 生成文本时添加更多控制参数，提升生成质量
generated = model.generate(
    input_ids,
    max_length=50,
    num_return_sequences=1,
    do_sample=True,  # 启用采样，避免重复
    temperature=0.7,  # 控制随机性，值越小越确定
    top_k=50,  # 只从top_k个词中采样
    pad_token_id=tokenizer.pad_token_id,  # 指定pad_token_id
    eos_token_id=tokenizer.eos_token_id   # 指定eos_token_id
)

# 解码生成的文本
output_text = tokenizer.decode(generated[0], skip_special_tokens=True)

print(output_text)

4、BERT

时间：2018年

关键技术：双向Transformer编码器与预训练微调技术

处理数据：擅长处理双向上下文信息，为语言理解提供了强大的基础

应用场景：自然语言处理、文本分类、情感分析等

BERT是一种基于Transformer的预训练语言模型，其最大的创新在于引入了双向Transformer编码器。这一设计使得模型能够综合考虑输入序列的前后上下文信息，极大地提升了语言理解的准确性。通过在海量文本数据上进行预训练，BERT成功地捕捉并学习了丰富的语言知识。随后，只需针对特定任务进行微调，如文本分类、情感分析等，便可轻松实现高效的应用。

BERT在自然语言处理领域取得了显著的成就，并广泛应用于各类NLP任务，成为当前自然语言处理领域的翘楚。

经典案例：

基于BERT的文本生成Python代码示例：

import torch
from transformers import BertTokenizer, BertForMaskedLM

# 初始化BERT模型和分词器
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForMaskedLM.from_pretrained('bert-base-uncased')
model.eval()  # 预测时切换到评估模式，关闭dropout等

# 待预测的句子（手动添加[MASK]标记）
# 示例：让模型预测"BERT is a [MASK] NLP model"中的掩码词
sentence = "BERT is a [MASK] NLP model that can be used for a wide range of tasks, including text generation. It is based on the Transformer architecture and has been pre-trained on a large corpus of text."

# 对句子进行分词和编码
inputs = tokenizer(sentence, return_tensors="pt")  # 推荐使用tokenizer()而非手动encode
input_ids = inputs["input_ids"]

# 找到[MASK]的位置
masked_index = torch.where(input_ids == tokenizer.mask_token_id)[1]

# 如果存在掩码位置，则进行预测
if len(masked_index) > 0:
    # 不计算梯度，节省资源
    with torch.no_grad():
        outputs = model(**inputs)  # 直接传入inputs字典
    predictions = outputs.logits  # 模型输出的logits
    
    # 获取每个掩码位置概率最高的词
    predicted_token_ids = torch.argmax(predictions[0, masked_index], dim=-1)
    predicted_tokens = tokenizer.convert_ids_to_tokens(predicted_token_ids.tolist())
    
    # 输出结果
    for idx, token in zip(masked_index.tolist(), predicted_tokens):
        print(f"在位置 {idx} 预测的词: {token}")
else:
    print("句子中没有找到[MASK]标记，请添加掩码后重试。")

5、GPT

时间：2018年

关键技术：单向Transformer编码器与预训练微调技术

处理数据：擅长生成连贯且富有逻辑的文本

应用场景：自然语言处理、文本生成、摘要提取等

GPT，作为一种基于Transformer架构的预训练语言模型，其独特的创新之处在于引入了单向Transformer编码器。这一设计使得模型能够更精准地捕捉输入序列的上下文信息，从而生成更为连贯的文本内容。通过在庞大的文本数据集中进行预训练，GPT积累了丰富而深入的语言知识。之后，在针对特定任务进行微调时，GPT能够展现出强大的适应性和灵活性，如文本生成、摘要提取等。

GPT在自然语言处理领域获得了显著的突破和广泛的应用，成为众多NLP任务中的佼佼者。无论是智能对话、内容创作还是信息提取，GPT都展现出了其卓越的性能和潜力。

GPT文本生成的Python代码示例如下：

from transformers import GPT2LMHeadModel, GPT2Tokenizer
import torch

# 初始化tokenizer和model
tokenizer = GPT2Tokenizer.from_pretrained('gpt2-medium')
# GPT2默认没有pad_token，将eos_token设为pad_token以避免警告
tokenizer.pad_token = tokenizer.eos_token
model = GPT2LMHeadModel.from_pretrained('gpt2-medium')

# 定义初始文本，并使用更规范的tokenizer调用方式
context = "人工智能的发展给社会带来了巨大变革，"
inputs = tokenizer(
    context,
    return_tensors='pt',
    truncation=True,  # 确保输入不超过模型最大长度
    max_length=1024   # GPT2的最大输入长度
)
input_ids = inputs['input_ids']

# 设置生成文本的总长度（包含初始文本）
total_length = 100  # 生成后总长度为100 tokens

# 设置为评估模式
model.eval()

# 生成文本（添加采样参数提升生成质量）
with torch.no_grad():
    output = model.generate(
        **inputs,  # 直接传入inputs字典，更简洁
        max_length=total_length,
        pad_token_id=tokenizer.pad_token_id,
        eos_token_id=tokenizer.eos_token_id,
        do_sample=True,  # 启用采样模式，避免重复
        temperature=0.8,  # 控制随机性（0-1，值越小越确定）
        top_k=50,  # 只从概率前50的词中采样
        repetition_penalty=1.2  # 惩罚重复出现的词
    )

# 解码生成的文本（包含初始文本）
full_text = tokenizer.decode(output[0], skip_special_tokens=True)
# 也可以只打印新增的部分
generated_only = full_text[len(context):]

print("完整文本：")
print(full_text)
# 或者只打印生成的部分
# print("\n仅生成部分：")
# print(generated_only)