沿着 AI 的发展脉络，本系列文章从Seq2Seq到RNN，再到Transformer，直至今日强大的GPT模型，我们将带你一步步深入了解这些关键技术背后的原理与实现细节。无论你是初学者还是有经验的开发者，相信读完这个系列文章后，不仅能掌握Transformer的核心概念，还能对其在整个NLP领域中的位置有一个全面而深刻的认识。那就让我们一起开始这段学习之旅吧！
在深度学习的语境里“模型”是一个高频出现的词汇，我们听说过识别手写数字的 CNN 模型，处理自然语言的 Transformer 模型，还有能写文章、做对话的 GPT 模型，这么多模型我们在解决业务问题时候应该如何做选型？
模型与模型架构
仔细观察还会发现一个问题 —— GPT 模型只有一个，而 CNN、Transformer 却有很多，比如 ResNet、VGG 属于 CNN 家族，BERT、GPT 又都和 Transformer 相关，这些概念之间究竟是怎样的关系？
我们首先需要了解机器学习中两个关键概念——模型架构（Model Architecture）与具体模型（Trained Model）的区别。就像建筑设计中「蓝图」与「建成的房子」的关系 ——CNN 和 Transformer 是模型架构，类似于可复用的「设计蓝图」，允许开发者根据需求调整细节（如层数、参数），从而衍生出无数具体实现；而 GPT 则是基于 Transformer 蓝图构建并训练完成的「成品模型」，是前者的一个典型实例。
以之前讨论的手写数字分类任务为例：
model = keras.Sequential([ keras.Input(shape=(28, 28, 1)), # 输入层（图像尺寸） keras.layers.Conv2D(32, (3, 3), activation='relu'), # 卷积层 keras.layers.MaxPooling2D((2, 2)), # 池化层 keras.layers.Flatten(), # 展平层 keras.layers.Dense(128, activation='relu'), # 全连接层 keras.layers.Dense(10, activation='softmax') # 输出层 ])
这里定义的是架构，描述了模型的层次、各层的类型、连接方式以及数据流动的路径。它是模型的 “骨架”，决定了模型如何处理输入数据、提取特征以及生成输出。
# 训练模型 model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) model.fit( train_images.reshape(-1, 28, 28, 1), train_labels, epochs=5, batch_size=32, validation_data=(val_images.reshape(-1, 28, 28, 1), val_labels) )
当上述架构通过model.fit()训练后，学习到具体的权重和偏置，也就产生了包含具体参数的模型，能够对新图像进行分类预测。因此可以这样理解
- 模型架构是模型的 “设计图纸”，决定了模型的结构和计算逻辑（无参数）。
- 模型是架构经过训练后的 “实例”，包含可学习的参数，能够实现具体的预测功能。
常见模型架构类型
个人理解工程同学首先要对常见的模型眼熟，比如目标检测任务能联想到 CNN、YOLO，这样 AI 就能帮大家开写代码了
卷积神经网络 (Convolutional Neural Networks, CNNs)
CNNs 通过卷积操作高效提取数据的局部空间特征，特别适用于具有网格状结构的数据，如图像。
典型模型：
- LeNet-5：早期的 CNN，用于手写数字识别。
- AlexNet：在 ImageNet 竞赛中显著提升图像分类性能，推动深度学习的发展。
- VGGNet：通过加深网络（如 VGG16、VGG19）提升性能。
- ResNet (Residual Networks)：引入残差模块，解决深层网络的梯度消失问题。
- EfficientNet：通过复合缩放方法优化模型规模与性能平衡。
- YOLO（You Only Look Once）：为目标检测设计，提供了图像分类、目标检测、实例分割、关键点检测等任务支持
循环神经网络 (Recurrent Neural Networks, RNNs)
RNNs 通过其循环结构处理序列数据，能够捕捉时间上的依赖关系，适用于需要处理时序信息的任务。
典型模型：
- 标准RNN：基础循环网络，存在梯度消失问题。
- 长短期记忆网络 (Long Short-Term Memory, LSTM)：引入门控机制，解决梯度消失问题。
- 门控循环单元 (Gated Recurrent Units, GRU)：结构更简洁，计算效率更高，功能类似于LSTM。
- 双向 RNN (Bi-directional RNNs)：双向处理序列，提高信息捕捉能力。
Transformer 模型
Transformer 基于自注意力机制，能够并行处理整个序列，擅长捕捉长距离依赖关系，广泛应用于 NLP 和计算机视觉领域。
典型模型：
- Transformer (原始模型)：用于机器翻译任务。
- BERT (Bidirectional Encoder Representations from Transformers)：预训练语言模型，用于多种 NLP 任务。
- GPT (Generative Pre-trained Transformer) 系列：用于文本生成、对话系统等。
- Vision Transformer (ViT)：将 Transformer 应用于图像分类。
- DETR (DEtection TRansformer)：用于目标检测任务。
生成对抗网络 (Generative Adversarial Networks, GANs)
GANs 通过生成器与判别器的对抗训练，实现高质量数据的生成，广泛应用于生成任务和数据增强。
典型模型：
- 原始 GAN：最基础的生成对抗框架。
- DCGAN (Deep Convolutional GAN)：结合卷积神经网络提升图像生成效果。
- StyleGAN：生成高质量的人脸图像，并可控制样式特征。
- CycleGAN：实现无监督的图像到图像转换，如马到斑马。
- BigGAN：大规模GAN模型，提升生成图像的质量与多样性。
图神经网络 (Graph Neural Networks, GNNs)
GNNs 专为处理图结构数据设计，通过节点间的连接关系传递和聚合信息，适用于复杂的关系数据。
典型模型：
- Graph Convolutional Networks (GCNs)：基于图卷积操作进行特征提取。
- Graph Attention Networks (GATs)：引入注意力机制，动态分配邻居节点的权重。
- GraphSAGE：通过采样邻居节点，实现大规模图数据的高效训练。
总结
不同架构因设计原理的差异，在数据处理、特征提取和任务适配上各有专攻，适用于不同类型的任务：
- 计算机视觉：CNN、ResNet、ViT（Vision Transformer）
- 自然语言处理：RNN、LSTM、GRU、Transformer（如 BERT、GPT）
- 生成任务：GAN、VAE
- 图结构数据：GNN、GCN
- 序列与时间数据：RNN、LSTM、GRU、Transformer
开始选择模型
拿到业务需求、收集数据、确定目标、选择模型架构，就可以开始进行模型训练了，但在机器学习开发的日常实践中，完全 从零开始训练模型的情况已越来越少，大多数开发者会基于任务需求与数据特性，优先选择在预训练模型基础上进行微调优化。这种站在巨人肩膀上的策略，既充分利用了大规模数据预训练积累的通用特征表示，又能通过轻量化的适配过程快速满足特定场景需求。
预训练模型
预训练模型（Pre-trained Models）是在特定模型架构基础上，通过在大规模通用数据集上进行初步训练，学习到通用特征或知识，设定了具体参数的神经网络模型。
比如基于 Transformer 架构的 BERT、GPT 系列模型，基于 CNN 架构的 ResNet-101、VGG16 等，都是预训练模型。这些预训练模型覆盖了自然语言处理、计算机视觉、音频处理、多模态任务和推荐系统等多个领域。开发者可以在 Hugging Face Hub、PyTorch Hub、TensorFlow Hub等平台，获取这些预训练模型。
Hugging Face Hub：https://huggingface.co/models
PyTorch Hub：https://pytorch.org/hub/
TensorFlow Hub：https://www.tensorflow.org/hub
现在回头看 GPT (Generative Pre-trained Transformer) 是不是知道大概是什么意思了。
微调 Fine-tuning
因为预训练模型一般使用通用数据集训练，为了更好的支持业务需求，开发者会对预训练模型进行微调。微调是指在预训练模型上，针对特定任务或特定数据集，进行少量参数的调整和训练，以使模型更好地适应新的任务需求。
随着模型规模的不断增大和应用场景的多样化，出现了多种微调方法，以提高效率、减少计算资源消耗或提升模型性能。
1. 标准微调（Standard Fine-tuning）
标准微调是最基本的微调方法，即将预训练模型在特定任务的数据集上进行全量参数的进一步训练。通常情况下，微调时会采用较低的学习率，以避免破坏预训练模型中学到的通用特征。
- 优点：简单直接，效果较好，尤其适用于目标任务与预训练任务相似的情况。
- 缺点：大模型全量微调计算资源消耗高，可能导致过拟合，尤其在目标任务数据量较小时。
2. 监督微调（Supervised Fine-Tuning, SFT）
监督微调是在标准微调基础上，利用有标注数据进行进一步训练，旨在提升模型在特定监督任务上的表现。SFT 通常应用于需要明确标签的任务，如分类、序列标注等。
- 自然语言处理：文本分类、命名实体识别、机器翻译等。
- 计算机视觉：图像分类、目标检测、图像分割等。
3. 低秩适配（Low-Rank Adaptation, LoRA）
LoRA 是一种 PEFT 的微调方法，通过在预训练模型的权重矩阵中引入低秩矩阵来适配新任务，而无需大幅调整原有模型的参数。这种方法能够显著减少微调过程中新增的参数量，同时保持或提升模型性能。
在矩阵理论中，秩（Rank）指的是矩阵中线性无关行或列的最大数量。一个矩阵的秩决定了其线性独立性的程度。满秩矩阵：如果一个 m×n 矩阵的秩 r 等于其最小维度 min(m,n)，则称其为满秩矩阵。低秩矩阵：如果一个 m×n 矩阵的秩 r满足 r≪min(m,n)，即远小于其最小维度，则称其为低秩矩阵。
- 低秩矩阵：在保持模型表现的同时，通过引入低秩矩阵在特定层（如 Transformer 的自注意力层）中调整权重。
- 参数冻结：预训练模型的原始参数冻结，仅训练新增的低秩矩阵参数。
4. 知识蒸馏（Knowledge Distillation）
知识蒸馏是通过将大型复杂模型（教师模型）的知识传递给小型高效模型（学生模型），以实现模型压缩和性能优化的技术。尽管知识蒸馏主要用于模型压缩，但它也可以作为微调的一种补充技术，进一步提升模型在特定任务上的表现。
基本原理：
- 教师模型：在大规模数据集上训练好的高性能模型。
- 学生模型：结构更简单、参数更少的模型，旨在模仿教师模型的行为。
- 蒸馏过程：通过让学生模型学习教师模型的输出（如软概率分布、特征表示等），传递教师模型的知识。
小小成本就能干大事，2025 年初 DeepSeek-R1 横空出世，671B 参数，训练仅消耗 278.8 万 GPU 小时，成本约为 GPT-4 的 1/200。是不是可以理解为什么 OpenAI 会公开质疑 DeepSeek 可能通过蒸馏 “窃取” 其技术成果。
当然已被《DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning》打脸https://arxiv.org/abs/2501.12948
Hugging face
Hugging Face提供了 模型 + 数据集 + 工具 + 社区 的一站式 AI 开发者平台，无论是想快速调用预训练模型的新手，还是需要大规模分布式训练的企业，都能在平台上找到对应的解决方案：
- 海量预训练模型：提供超过 10 万 + 预训练模型，支持 NLP、计算机视觉、语音处理、多模态等任务，覆盖分类、生成、翻译、摘要、问答等多种场景。
- 丰富的公开数据集：收录超 5 万 + 公开数据集，涵盖文本、图像、语音、表格等类型，如 IMDB 影评、MNIST、COCO、维基百科等，支持一键加载。
- 数据处理工具：提供 datasets 库，支持数据清洗、预处理、分拆（如训练集 / 验证集 / 测试集），兼容多种格式（CSV、JSON、Parquet 等）。
- 快速部署演示：通过 “Hugging Face Spaces”，用户可直接在浏览器中部署模型演示（Demo），支持 Gradio、Streamlit、HTML 等界面，无需复杂服务器配置。
- 开源生态：核心库（Transformers、Datasets 等）完全开源，社区贡献活跃，文档丰富，适合研究者、开发者和企业使用。
学习使用的预训练模型及数据集都可以在 Hugging face 获取，也可以瞅瞅 ModelScope。
使用预训练模型
IMDB 影评数据集包含 5 万条电影评论（2.5 万训练/2.5 万测试），标注为正面/负面情感，是情感分析领域的标杆数据集。
- 文本长度适中（平均 200-300 词），适合验证模型的长文本理解能力。
- 已完成预处理（去除 HTML 标签、统一格式），可直接使用。
接下来我们使用预训练的 bert-base-uncased 模型，对 IMDB 电影评论数据集进行情感分析，也就是判断评论是积极的还是消极的
因为需要下载 Hugging face 的数据集与预训练模型，代码本地运行需要保证对 Hugging face 的访问畅通。
导入必要的库
import torch from torch.utils.data import Dataset, DataLoader from torch.optim import AdamW from transformers import BertTokenizer, BertForSequenceClassification, get_linear_schedule_with_warmup from datasets import load_dataset import numpy as np from sklearn.metrics import accuracy_score, f1_score
- torch: PyTorch 的核心库。
- Dataset, DataLoader: Dataset 用于定义数据集，DataLoader 用于批量加载数据。
- AdamW: 一种基于 Adam 优化器的变体，添加了权重衰减（weight decay）。
- Transformers: Hugging Face 提供的预训练模型库
- BertTokenizer 用于分词
- BertForSequenceClassification 用于序列分类任务
- get_linear_schedule_with_warmup 是学习率调度器，线性递减并带有预热阶段
- datasets: Hugging Face 的数据集库，load_dataset 用于加载各种公开数据集。
- accuracy_score, f1_score: sklearn 提供的评估指标，用于计算准确率和 F1 分数。
定义数据集类
IMDBDataset 继承自 PyTorch 的 Dataset 类，用于封装 IMDB 数据集：
# 自定义数据集类：将 IMDB 数据集转换为 PyTorch 可用的格式 class IMDBDataset(Dataset): """ 自定义数据集类，用于处理IMDB电影评论数据 参数: dataset: Hugging Face数据集对象 tokenizer: BERT 分词器 max_length: 序列最大长度 """ def __init__(self, dataset, tokenizer, max_length): self.dataset = dataset # 原始数据集 self.tokenizer = tokenizer # BERT分词器 self.max_length = max_length # 序列最大长度 def __len__(self): """返回数据集中样本的数量""" return len(self.dataset) def __getitem__(self, idx): """获取指定索引的数据样本并进行预处理""" # 获取文本和标签 text = self.dataset[idx]['text'] label = self.dataset[idx]['label'] # 使用BERT分词器对文本进行编码 encoding = self.tokenizer.encode_plus( text, add_special_tokens=True, # 添加[CLS]和[SEP]特殊标记 max_length=self.max_length, # 最大序列长度 padding='max_length', # 填充到最大长度 truncation=True, # 截断超长序列 return_tensors='pt' # 返回PyTorch张量 ) # 返回模型所需的输入格式 return { 'input_ids': encoding['input_ids'].flatten(), # 输入ID 'attention_mask': encoding['attention_mask'].flatten(), # 注意力掩码 'labels': torch.tensor(label, dtype=torch.long) # 标签 }
加载 IMDB 数据集
使用 load_dataset 从 Hugging Face 的数据集库中加载 IMDB 数据集：
print("1. 数据准备阶段") print("正在加载 IMDB 数据集...") # 从 Hugging Face 加载 IMDB 电影评论数据集 imdb_dataset = load_dataset('imdb') print("成功加载 IMDB 数据集")
划分训练集和验证集
使用 Hugging Face 数据集库自带的 train_test_split 方法，将训练集划分为训练集和验证集，比例为 80% 训练，20% 验证。
# 将训练集分割为训练集和验证集（80%-20%分割） print("划分训练集和验证集...") train_val_split = imdb_dataset['train'].train_test_split(test_size=0.2, seed=42) train_data = train_val_split['train'] # train_test_split 验证集被命名为 'test' val_data = train_val_split['test'] print(f"训练集样本数: {len(train_data)}, 验证集样本数: {len(val_data)}")
加载分词器和模型
# 2. 模型初始化阶段 print("2. 模型初始化阶段") print("加载 BERT 模型和分词器...") # 加载预训练的BERT分词器和模型 tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2) print("成功加载 BERT 模型和分词器")
- 分词器 (BertTokenizer)：
- 加载预训练的 bert-base-uncased 分词器，该分词器将文本分割成小的词片段，并将其转换为对应的词汇表索引。
- uncased 表示分词器会将文本转换为小写，忽略大小写信息。
- 模型 (BertForSequenceClassification)：
- 加载预训练的 bert-base-uncased 模型，并在顶部添加一个用于序列分类的全连接层。
- num_labels=2 表示分类任务有两个类别（正面和负面）。
bert-base-uncased 模型，包含 1.1 亿个参数，每个参数通常以 32 位浮点数（FP32） 存储，每个 FP32 占 4 字节，下载和占用磁盘空间 440M 左右。
定义数据集和数据加载器
使用前面定义的 IMDBDataset 类，将训练集、验证集和测试集封装为 PyTorch 数据集对象。
# 设置序列最大长度并创建数据集对象 max_length = 128 print(f"创建数据集对象，序列最大长度: {max_length}") train_dataset = IMDBDataset(train_data, tokenizer, max_length) val_dataset = IMDBDataset(val_data, tokenizer, max_length) test_dataset = IMDBDataset(imdb_dataset['test'], tokenizer, max_length)
max_length=128 指定每条文本的最大长度为 128 个 token，超出部分会被截断，未达到的部分会被填充。
# 创建数据加载器 batch_size = 16 print(f"创建数据加载器，批次大小: {batch_size}") train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) val_dataloader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False) test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
shuffle=True 表示每个 epoch 前会打乱数据，增强模型的泛化能力。
定义优化器和学习率调度器
# 设置优化器和学习率调度器 print("配置优化器和学习率调度器") learning_rate = 2e-5 optimizer = AdamW(model.parameters(), lr=learning_rate) # 计算总训练步数 num_epochs = 3 total_steps = len(train_dataloader) * num_epochs # 创建学习率调度器，在训练过程中逐步降低学习率 scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=0, num_training_steps=total_steps)
- 使用 AdamW 优化器，根据损失函数的梯度信息，调整模型参数（如权重、偏置），以最小化损失函数。
- get_linear_schedule_with_warmup 创建一个线性学习率调度器，该调度器会在训练过程中逐步调整学习率，帮助模型更好地收敛
- num_warmup_steps=0: 无预热阶段，从一开始就使用线性递减。
- num_training_steps=total_steps: 总训练步数，等于每个 epoch 的步数乘以 epoch 数。
设备设置
检查是否有可用的 GPU（cuda），如果有，则使用 GPU 加速训练，否则使用 CPU。
# 设置运行设备(GPU/CPU) device = torch.device('cuda'if torch.cuda.is_available() else'cpu') print(f"运行设备: {device}") model.to(device) # 将模型移动到指定设备
如果没有 GPU 预计需要 3 小时左右跑完。
训练模型
训练三轮，每一轮中先进行训练，再进行验证，计算训练损失、验证损失和验证准确率。如果当前验证准确率超过之前的最佳值，更新 best_val_accuracy 并保存模型的状态字典到 best_model.pth。
# 3. 模型训练阶段 print("\n3. 模型训练阶段") print(f"开始训练，总周期数: {num_epochs}") best_val_accuracy = 0 for epoch in range(num_epochs): print(f"\n开始第 {epoch + 1}/{num_epochs} 个训练周期") # 训练模式 model.train() total_train_loss = 0 print("训练中...") for batch in train_dataloader: # 将数据移动到指定设备 input_ids = batch['input_ids'].to(device) attention_mask = batch['attention_mask'].to(device) labels = batch['labels'].to(device) # 清除之前的梯度 optimizer.zero_grad() # 前向传播 outputs = model(input_ids, attention_mask=attention_mask, labels=labels) loss = outputs.loss total_train_loss += loss.item() # 反向传播 loss.backward() # 更新参数 optimizer.step() scheduler.step() # 更新学习率 # 计算平均训练损失 avg_train_loss = total_train_loss / len(train_dataloader) # 验证模式 print("验证中...") model.eval() # 设置为评估模式 val_predictions = [] val_true_labels = [] total_val_loss = 0 with torch.no_grad(): # 不计算梯度 for batch in val_dataloader: # 将数据移动到指定设备 input_ids = batch['input_ids'].to(device) attention_mask = batch['attention_mask'].to(device) labels = batch['labels'].to(device) # 前向传播 outputs = model(input_ids, attention_mask=attention_mask, labels=labels) loss = outputs.loss total_val_loss += loss.item() # 获取预测结果 logits = outputs.logits preds = torch.argmax(logits, dim=1) # 收集预测结果和真实标签 val_predictions.extend(preds.cpu().tolist()) val_true_labels.extend(labels.cpu().tolist()) # 计算验证指标 avg_val_loss = total_val_loss / len(val_dataloader) val_accuracy = accuracy_score(val_true_labels, val_predictions) print(f'第 {epoch + 1} 个周期: 训练损失 = {avg_train_loss:.4f}, 验证损失 = {avg_val_loss:.4f}, 验证准确率 = {val_accuracy:.4f}') # 保存最佳模型 if val_accuracy > best_val_accuracy: best_val_accuracy = val_accuracy print(f"发现更好的模型，保存模型权重 (准确率: {val_accuracy:.4f})") torch.save(model.state_dict(), 'best_model.pth')
前向传播（Forward Propagation）和反向传播（Backward Propagation）是深度学习中两个至关重要的概念，它们共同构成了神经网络模型训练的核心流程
- 前向传播是指将输入数据（代码中的 input_ids 和 attention_mask）依次通过神经网络的各个层，经过一系列的线性变换和非线性激活函数处理，最终得到模型的预测输出。
- 反向传播是在得到损失值之后，通过链式法则计算损失函数对模型中每个参数的梯度。通过计算梯度，可以知道应该如何调整模型的参数，使得损失函数的值减小，从而提高模型的性能。
第 1 个周期: 训练损失 = 0.3398, 验证损失 = 0.2854, 验证准确率 = 0.8792 发现更好的模型，保存模型权重 (准确率: 0.8792) 第 2 个周期: 训练损失 = 0.1799, 验证损失 = 0.2949, 验证准确率 = 0.8864 发现更好的模型，保存模型权重 (准确率: 0.8864) 第 3 个周期: 训练损失 = 0.0822, 验证损失 = 0.3687, 验证准确率 = 0.8888 发现更好的模型，保存模型权重 (准确率: 0.8888)
模型评估
# 4. 模型评估阶段 print("\n4. 模型评估阶段") # 加载训练过程中保存的最佳模型 print("加载最佳模型权重...") model.load_state_dict(torch.load('best_model.pth')) # 在测试集上评估模型 print("在测试集上评估模型...") model.eval() # 设置为评估模式 predictions = [] true_labels = [] with torch.no_grad(): # 不计算梯度 for batch in test_dataloader: # 将数据移动到指定设备 input_ids = batch['input_ids'].to(device) attention_mask = batch['attention_mask'].to(device) labels = batch['labels'].to(device) # 前向传播 outputs = model(input_ids, attention_mask=attention_mask) logits = outputs.logits preds = torch.argmax(logits, dim=1) # 收集预测结果和真实标签 predictions.extend(preds.cpu().tolist()) true_labels.extend(labels.cpu().tolist()) # 计算评估指标 accuracy = accuracy_score(true_labels, predictions) f1 = f1_score(true_labels, predictions) print(f'测试集准确率: {accuracy:.4f}') print(f'测试集F1分数: {f1:.4f}')
自定义测试
自定义一个测试函数：
# 定义情感预测函数：用于对新文本进行情感分析 def predict_sentiment(text, tokenizer, model, max_length=128, device='cpu'): """ 使用训练好的BERT模型对文本进行情感分析 参数: text: 要分析的文本字符串 tokenizer: BERT分词器 model: 训练好的BERT模型 max_length: 序列最大长度 device: 运行设备('cpu'或'cuda') 返回: 包含情感预测结果的字典 """ # 预处理文本 encoding = tokenizer.encode_plus( text, add_special_tokens=True, max_length=max_length, padding='max_length', truncation=True, return_tensors='pt' ) # 将张量移动到指定设备 input_ids = encoding['input_ids'].to(device) attention_mask = encoding['attention_mask'].to(device) # 预测阶段 model.eval() # 设置为评估模式 with torch.no_grad(): # 不计算梯度，节省内存 outputs = model(input_ids, attention_mask=attention_mask) logits = outputs.logits # 转换为概率值 prob = torch.softmax(logits, dim=1).squeeze().cpu().numpy() # 解析结果 negative_prob = prob[0] # 负面情感概率 positive_prob = prob[1] # 正面情感概率 sentiment = 'positive'if positive_prob > 0.5else'negative' # 情感判断 # 返回预测结果 return { 'text': text, 'sentiment': sentiment, 'negative_prob': f'{negative_prob:.4f}', 'positive_prob': f'{positive_prob:.4f}' }
对自定义文本进行测试：
# 5. 自定义文本测试 print("\n5. 自定义文本测试") print("对自定义文本进行情感分析...") custom_text = "This film is a masterpiece! The cinematography and soundtrack are unparalleled." print(f"输入文本: {custom_text}") result = predict_sentiment(custom_text, tokenizer, model, device=device) print(f"预测结果: {result['sentiment']} (积极概率: {result['positive_prob']}, 消极概率: {result['negative_prob']})")
输出：
测试集准确率: 0.8857 测试集F1分数: 0.8842 5. 自定义文本测试 对自定义文本进行情感分析... 输入文本: This film is a masterpiece! The cinematography and soundtrack are unparalleled. 预测结果: positive (积极概率: 0.9983, 消极概率: 0.0017)
done！
# 程序完成 print("\n程序执行完毕!")
来源 | 阿里云开发者公众号
作者 | 谦行
