深度学习每周学习总结N3（文本分类实战：基本分类（熟悉流程）、textCNN分类（通用模型）、Bert分类（模型进阶））

• 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
• 🍖 原作者：K同学啊 | 接辅导、项目定制

0. 总结：

之前有学习过文本预处理的环节，对文本处理的主要方式有以下三种：

1：词袋模型（one-hot编码）

2：TF-IDF

3：词向量(Word Embedding)以及Word2vec(Word Embedding 的方法之一))

详细介绍及中英文分词详见pytorch文本分类（一）：文本预处理

上期主要介绍Embedding,及EmbeddingBag 使用示例（对词索引向量转化为词嵌入向量）

本期将主要介绍基本分类（熟悉流程）、拓展：textCNN分类（通用模型）、拓展：Bert分类（模型进阶）

1. 前期准备

环境安装

这是一个使用PyTorch实现的简单文本分类实战案例。在这个例子中，我们将使用AG News数据集进行文本分类。

AG News（AG’s News Topic Classification Dataset）是一个广泛用于文本分类任务的数据集，尤其是在新闻领域。该数据集是由AG’s Corpus of News Articles收集整理而来，包含了四个主要的类别：世界、体育、商业和科技。

首先，确保已经安装了torchtext与portalocker库

注：相近版本也可，不必完全一致

安装版本参考

PyTorch version	torchtext version	Supported Python version
nightly build	main	>=3.8, <=3.11
2.3.0	0.18.0	>=3.8, <=3.11
2.2.0	0.17.0	>=3.8, <=3.11
2.1.0	0.16.0	>=3.8, <=3.11
2.0.0	0.15.0	>=3.8, <=3.11
1.13.0	0.14.0	>=3.7, <=3.10
1.12.0	0.13.0	>=3.7, <=3.10
1.11.0	0.12.0	>=3.6, <=3.9
1.10.0	0.11.0	>=3.6, <=3.9
1.9.1	0.10.1	>=3.6, <=3.9
1.9	0.10	>=3.6, <=3.9
1.8.1	0.9.1	>=3.6, <=3.9
1.8	0.9	>=3.6, <=3.9
1.7.1	0.8.1	>=3.6, <=3.9
1.7	0.8	>=3.6, <=3.8
1.6	0.7	>=3.6, <=3.8
1.5	0.6	>=3.5, <=3.8
1.4	0.5	2.7, >=3.5, <=3.8
0.4 and below	0.2.3	2.7, >=3.5, <=3.8

# 根据上述表格检查自己的python版本及 pytorch版本
import sys
print(sys.version)

3.8.17 | packaged by conda-forge | (default, Jun 16 2023, 07:01:59) [MSC v.1929 64 bit (AMD64)]

import torch
print(torch.__version__)

2.0.0+cpu

综上torchtext应该安装的版本号是 0.15.0

import torchtext
import portalocker

print(torchtext.__version__)
print(portalocker.__version__)

0.15.0
2.10.0

2. 文本分类基本流程

a. 加载数据

import torch
import torch.nn as nn
# import torchvision
# from torchvision import transforms,datasets
import os,PIL,pathlib,warnings

warnings.filterwarnings("ignore")

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device

C:\Users\Cheng\.conda\envs\pytorch_env_cuda12_0\lib\site-packages\torchvision\io\image.py:13: UserWarning: Failed to load image Python extension: 'Could not find module 'C:\Users\Cheng\.conda\envs\pytorch_env_cuda12_0\Lib\site-packages\torchvision\image.pyd' (or one of its dependencies). Try using the full path with constructor syntax.'If you don't plan on using image functionality from `torchvision.io`, you can ignore this warning. Otherwise, there might be something wrong with your environment. Did you have `libjpeg` or `libpng` installed before building `torchvision` from source?
  warn(





device(type='cpu')

from torchtext.datasets import AG_NEWS

train_iter = AG_NEWS('./data/ag_news',split='train') # 加载 AG News 数据集 ,注意最好指定路径，默认路径可能会报错

torchtext.datasets.AG_NEWS()是一个用于加载 AG News 数据集的 TorchText 数据集类。AG News 数据集是一个用于文本分类任务的常见数据集，其中包含四个类别的新闻文章：世界、科技、体育和商业。torchtext.datasets.AG_NEWS() 类加载的数据集是一个列表，其中每个条目都是一个元组，包含以下两个元素：

●
一条新闻文章的文本内容。

●
新闻文章所属的类别（一个整数，从1到4，分别对应世界、科技、体育和商业）。

b.构建词典

try:
    import portalocker
    print("库已安装")
except ImportError:
    print("库未安装")

库已安装

from torchtext.data.utils import get_tokenizer          # 导入用于获取分词器的get_tokenizer函数
from torchtext.vocab import build_vocab_from_iterator   # 用于从迭代器构建词汇表的build_vocab_from_iterator函数

tokenizer = get_tokenizer('basic_english') # 获取分词器

# 定义生成器函数 yield_tokens
def yield_tokens(data_iter):
    for _,text in data_iter:  # 从数据迭代器 data_iter 中提取文本
        yield tokenizer(text) # 对于每一条数据，tokenizer(text) 会返回一个单词列表，并通过 yield 语句将其生成器输出
        
vocab = build_vocab_from_iterator(yield_tokens(train_iter),specials=["<unk>"]) # 使用 yield_tokens(train_iter) 生成的单词列表构建词汇表
vocab.set_default_index(vocab["<unk>"]) # 设置默认索引，如果找不到单词，则会选择默认索引<unk>

数据处理示例：

(0, "This is a sentence")
(1, "Another sentence")

处理过程如下：

1. 分词：

   • “This is a sentence” -> ['this', 'is', 'a', 'sentence']
   • “Another sentence” -> ['another', 'sentence']

2. 构建词汇表：

   • 词汇表将包含：['this', 'is', 'a', 'sentence', 'another', '<unk>']

3. 设置默认索引：

   • 对于词汇表中不存在的单词，例如 “unknown”，将被映射为 <unk> 的索引。

这样，通过分词和构建词汇表，可以将原始文本数据转换为模型可以处理的数值形式（单词索引），从而进行后续的训练和预测。

4. 文本数据转换：
   • “vocab([‘this’, ‘is’, ‘a’, ‘sentence’, ‘another’, ‘’])” -> [52, 21, 5, 2993, 206, 0]

c.生成数据批次和迭代器

# 自定义函数
text_pipeline = lambda x: vocab(tokenizer(x)) #用于将输入的文本通过分词器分词，然后映射到词汇表的索引序列上
label_pipeline = lambda x: int(x) - 1 # 将标签转换为整数并减去 1。这里假设标签从 1 开始，因此减去 1 以适应从 0 开始的索引。

# 自定义函数使用说明
text_pipeline('here is the an example')

[475, 21, 2, 30, 5297]

# 自定义函数使用说明
label_pipeline('10'),label_pipeline('11') 

(9, 10)

from torch.utils.data import DataLoader

def collate_batch(batch):
    label_list,text_list,offsets = [],[],[0] # 初始化为空列表，其中 offsets 初始化为 [0]。
    
    for (_label,_text) in batch: # 遍历批处理中的每个数据项。_label 是标签，_text 是文本。
        # 标签列表
        label_list.append(label_pipeline(_label)) # 将处理后的标签添加到 label_list。
        # 文本列表
        processed_text = torch.tensor(text_pipeline(_text),dtype=torch.int64) # 将处理后的文本转换为 PyTorch 的 tensor 并指定数据类型为 int64
        text_list.append(processed_text) # 将处理后的文本添加到 text_list
        
        # 偏移量，即语句的总词汇量
        offsets.append(processed_text.size(0)) # 记录每个文本的长度，作为偏移量
        
    label_list = torch.tensor(label_list,dtype = torch.int64) # 将标签列表转换为 PyTorch 的 tensor
    text_list = torch.cat(text_list)                          # 将所有处理后的文本拼接成一个长的 tensor
    offsets = torch.tensor(offsets[:-1]).cumsum(dim = 0)      # 返回维度dim中输入元素的累计和
    
    return label_list.to(device),text_list.to(device),offsets.to(device) # 计算每个文本的偏移量，使用累计和来表示每个文本在拼接后的长 tensor 中的起始位置

# 数据加载器
dataloader = DataLoader(
    train_iter,
    batch_size = 8,
    shuffle = False,
    collate_fn = collate_batch # 指定批处理函数 collate_batch 用于将一批数据合并为一个小批次。
)

疑问解答：解释为什么文本数据需要在处理后立即转换为 tensor，而标签数据则可以延迟到最后统一转换

其实，文本数据处理后立即转换为 tensor 并拼接，与标签数据在最后统一转换是两种不同的数据处理策略，它们各自有其原因和意义。以下是详细的原因和可能的改进方法：

• 1. 标签处理：延迟转换

label_list.append(label_pipeline(_label))

标签数据处理非常简单，只是将标签值转换为整数，并不涉及复杂的操作或大规模的数据处理。因此，将所有标签处理完成后再一次性转换为 tensor 是可行且高效的。

• 2. 文本处理：立即转换并拼接

processed_text = torch.tensor(text_pipeline(_text), dtype=torch.int64)
text_list.append(processed_text)

立即转换为 tensor 并拼接主要是为了方便后续的拼接操作和偏移量计算。这种方式确保每个文本处理后的格式一致，也避免了额外的遍历和类型转换操作。

• 统一转换的可行性
  为了统一操作，可以将所有文本处理完后再进行转换和拼接。以下是修改后的代码示例：

• 修改后的 collate_batch 函数(虽然代码更简洁，但处理大规模数据或比较复杂的预处理时仍然建议不使用这种修改)

def collate_batch(batch):
    label_list, text_list, offsets = [], [], [0]
    
    for (_label, _text) in batch:
        label_list.append(label_pipeline(_label))
        text_list.append(text_pipeline(_text))  # 先将文本处理为索引列表，暂时不转换为 tensor
        offsets.append(len(text_list[-1]))  # 记录每个文本的长度
    
    label_list = torch.tensor(label_list, dtype=torch.int64)  # 统一转换为 tensor
    
    # 统一转换 text_list 并拼接
    text_list = [torch.tensor(text, dtype=torch.int64) for text in text_list]
    text_list = torch.cat(text_list)
    
    offsets = torch.tensor(offsets[:-1]).cumsum(dim=0)  # 计算偏移量
    
    return label_list.to(device), text_list.to(device), offsets.to(device)

d.定义模型及实例

这里我们定义TextClassificationModel模型，首先对文本进行嵌入，然后对句子嵌入之后的结果进行均值聚合。

from torch import nn

class TextClassificationModel(nn.Module):
    def __init__(self,vocab_size,embed_dim,num_class):
        super(TextClassificationModel,self).__init__() # 调用父类 nn.Module 的初始化函数
        # 词嵌入层，它能够对一系列词嵌入的输入进行平均或求和
        self.embedding = nn.EmbeddingBag(
            vocab_size, # 词典大小
            embed_dim,  # 嵌入的维度
            sparse = False
        )
        # 全连接层，它接受嵌入向量的维度 embed_dim 作为输入，并输出 num_class 个类别的得分
        self.fc = nn.Linear(embed_dim,num_class)
        self.init_weights()
        
    # 初始化函数，用于设置模型中各层的初始权重
    def init_weights(self):
        initrange = 0.5 # 初始化范围
        self.embedding.weight.data.uniform_(-initrange,initrange) # 将嵌入层的权重初始化为均匀分布，范围在 [-0.5, 0.5] 之间
        self.fc.weight.data.uniform_(-initrange,initrange) # 将全连接层的权重初始化为均匀分布，范围在 [-0.5, 0.5] 之间
        self.fc.bias.data.zero_() # 将全连接层的偏置初始化为 0
        
    def forward(self,text,offsets):
        embedded = self.embedding(text,offsets) # 将输入的 text 和 offsets 传入嵌入层，得到嵌入向量
        return self.fc(embedded) # 将嵌入向量传入全连接层，得到每个类别的得分

self.embedding.weight.data.uniform_(-initrange, initrange)这段代码是在 PyTorch 框架下用于初始化神经网络的词嵌入层（embedding layer）权重的一种方法。这里使用了均匀分布的随机值来初始化权重，具体来说，其作用如下：

1
self.embedding: 这是神经网络中的词嵌入层（embedding layer）。词嵌入层的作用是将离散的单词表示（通常为整数索引）映射为固定大小的连续向量。这些向量捕捉了单词之间的语义关系，并作为网络的输入。

2
self.embedding.weight: 这是词嵌入层的权重矩阵，它的形状为 (vocab_size, embedding_dim)，其中 vocab_size 是词汇表的大小，embedding_dim 是嵌入向量的维度。

3
self.embedding.weight.data: 这是权重矩阵的数据部分，我们可以在这里直接操作其底层的张量。

4
.uniform_(-initrange, initrange): 这是一个原地操作（in-place operation），用于将权重矩阵的值用一个均匀分布进行初始化。均匀分布的范围为 [-initrange, initrange]，其中 initrange 是一个正数。

通过这种方式初始化词嵌入层的权重，可以使得模型在训练开始时具有一定的随机性，有助于避免梯度消失或梯度爆炸等问题。在训练过程中，这些权重将通过优化算法不断更新，以捕捉到更好的单词表示。

# 定义实例
num_class = len(set([label for (label,text) in train_iter]))
vocab_size = len(vocab)
em_size = 64
model = TextClassificationModel(vocab_size,em_size,num_class).to(device)

e. 定义训练函数

import time

def train(dataloader):
    model.train() # 切换为训练模式
    total_acc,train_loss,total_count = 0,0,0
    log_interval = 500 # 设定日志记录间隔，每 500 个批次输出一次训练日志
    start_time = time.time()
    
    for idx,(label,text,offsets) in enumerate(dataloader):
        
        predicted_label = model(text,offsets)
        
        optimizer.zero_grad()                   # grad属性归零
        loss = criterion(predicted_label,label) # 计算网络输出和真实值之间的差距，label为真实值
        loss.backward()  # 反向传播
        optimizer.step() # 每一步自动更新
        
        # 记录acc 与loss
        total_acc += (predicted_label.argmax(1) == label).sum().item()
        train_loss += loss.item()
        total_count += label.size(0)
        
        if idx % log_interval == 0 and idx > 0:
            elapesd = time.time() - start_time
            print('| epoch{:1d} | {:4d}/{:4d} batches '
                  '| train_acc {:4.3f} train_loss {:4.5f}'.format(epoch,idx,len(dataloader),
                                                                  total_acc/total_count,
                                                                  train_loss/total_count)
                 )
            total_acc,train_loss,total_count = 0,0,0
            start_time = time.time()

f.定义评估函数

def evaluate(dataloader):
    model.eval() # 切换为测试模式
    total_acc,train_loss,total_count = 0,0,0
    
    with torch.no_grad():
        for idx,(label,text,offsets) in enumerate(dataloader):
            predicted_label = model(text,offsets)
            
            loss = criterion(predicted_label,label) # 计算loss值
            # 记录测试数据
            total_acc = (predicted_label.argmax(1) == label).sum().item()
            train_loss += loss.item()
            total_count += label.size(0)
            
    return total_acc/total_count,train_loss/total_count

g. 拆分数据集并训练模型

from torch.utils.data.dataset import random_split
from torchtext.data.functional import to_map_style_dataset

# 超参数
EPOCH = 10      # epoch
LR = 5          # 学习率
BATCH_SIZE = 64 # batch size for training

criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(),lr = LR)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,1.0,gamma = 0.1)
total_accu = None

train_iter,test_iter = AG_NEWS() # 加载数据
train_dataset = to_map_style_dataset(train_iter)
test_dataset = to_map_style_dataset(test_iter)
num_train = int(len(train_dataset) * 0.95)

split_train_,split_valid_ = random_split(
    train_dataset,
    [num_train,len(train_dataset) - num_train]
)
train_dataloader = DataLoader(split_train_,
                              batch_size = BATCH_SIZE,
                              shuffle = True,
                              collate_fn = collate_batch) # 使用前面定义的 collate_batch 函数来处理批数据
valid_dataloader = DataLoader(split_valid_,
                             batch_size = BATCH_SIZE,
                             shuffle = True,
                             collate_fn = collate_batch)
test_dataloader = DataLoader(test_dataset,
                             batch_size = BATCH_SIZE,
                             shuffle = True,
                             collate_fn = collate_batch)

for epoch in range(1,EPOCH + 1):
    epoch_start_time = time.time()
    train(train_dataloader) # 调用训练函数，使用训练数据加载器进行训练
    val_acc,val_loss = evaluate(valid_dataloader) # 调用评估函数，使用验证数据加载器计算验证准确率和损失
    
    if total_accu is not None and total_accu > val_acc:
        scheduler.step()
    else:
        total_accu = val_acc
    print('=' * 61)
    print('| epoch {:1d} | time:{:4.2f}s | '
          'valid_acc {:4.3f} valid_loss {:4.3f}'.format(epoch,time.time() - epoch_start_time,val_acc,val_loss)
         )
    print('=' * 61)

| epoch1 |  500/1782 batches | train_acc 0.904 train_loss 0.00454
| epoch1 | 1000/1782 batches | train_acc 0.903 train_loss 0.00452
| epoch1 | 1500/1782 batches | train_acc 0.909 train_loss 0.00433
=============================================================
| epoch 1 | time:31.01s | valid_acc 0.007 valid_loss 0.005
=============================================================
| epoch2 |  500/1782 batches | train_acc 0.918 train_loss 0.00378
| epoch2 | 1000/1782 batches | train_acc 0.919 train_loss 0.00379
| epoch2 | 1500/1782 batches | train_acc 0.916 train_loss 0.00386
=============================================================
| epoch 2 | time:32.03s | valid_acc 0.007 valid_loss 0.005
=============================================================
| epoch3 |  500/1782 batches | train_acc 0.929 train_loss 0.00328
| epoch3 | 1000/1782 batches | train_acc 0.922 train_loss 0.00356
| epoch3 | 1500/1782 batches | train_acc 0.927 train_loss 0.00340
=============================================================
| epoch 3 | time:32.34s | valid_acc 0.007 valid_loss 0.004
=============================================================
| epoch4 |  500/1782 batches | train_acc 0.943 train_loss 0.00269
| epoch4 | 1000/1782 batches | train_acc 0.945 train_loss 0.00268
| epoch4 | 1500/1782 batches | train_acc 0.944 train_loss 0.00272
=============================================================
| epoch 4 | time:32.00s | valid_acc 0.007 valid_loss 0.004
=============================================================
| epoch5 |  500/1782 batches | train_acc 0.946 train_loss 0.00261
| epoch5 | 1000/1782 batches | train_acc 0.947 train_loss 0.00258
| epoch5 | 1500/1782 batches | train_acc 0.946 train_loss 0.00262
=============================================================
| epoch 5 | time:32.56s | valid_acc 0.008 valid_loss 0.004
=============================================================
| epoch6 |  500/1782 batches | train_acc 0.948 train_loss 0.00257
| epoch6 | 1000/1782 batches | train_acc 0.950 train_loss 0.00252
| epoch6 | 1500/1782 batches | train_acc 0.946 train_loss 0.00256
=============================================================
| epoch 6 | time:41.89s | valid_acc 0.007 valid_loss 0.004
=============================================================
| epoch7 |  500/1782 batches | train_acc 0.948 train_loss 0.00252
| epoch7 | 1000/1782 batches | train_acc 0.950 train_loss 0.00245
| epoch7 | 1500/1782 batches | train_acc 0.949 train_loss 0.00249
=============================================================
| epoch 7 | time:38.78s | valid_acc 0.007 valid_loss 0.004
=============================================================
| epoch8 |  500/1782 batches | train_acc 0.950 train_loss 0.00249
| epoch8 | 1000/1782 batches | train_acc 0.950 train_loss 0.00245
| epoch8 | 1500/1782 batches | train_acc 0.950 train_loss 0.00244
=============================================================
| epoch 8 | time:37.05s | valid_acc 0.008 valid_loss 0.004
=============================================================
| epoch9 |  500/1782 batches | train_acc 0.951 train_loss 0.00238
| epoch9 | 1000/1782 batches | train_acc 0.949 train_loss 0.00251
| epoch9 | 1500/1782 batches | train_acc 0.950 train_loss 0.00245
=============================================================
| epoch 9 | time:39.89s | valid_acc 0.007 valid_loss 0.004
=============================================================
| epoch10 |  500/1782 batches | train_acc 0.949 train_loss 0.00252
| epoch10 | 1000/1782 batches | train_acc 0.951 train_loss 0.00250
| epoch10 | 1500/1782 batches | train_acc 0.948 train_loss 0.00246
=============================================================
| epoch 10 | time:33.48s | valid_acc 0.007 valid_loss 0.004
=============================================================

torchtext.data.functional.to_map_style_dataset 函数的作用是将一个迭代式的数据集（Iterable-style dataset）转换为映射式的数据集（Map-style dataset）。这个转换使得我们可以通过索引（例如：整数）更方便地访问数据集中的元素。

在 PyTorch 中，数据集可以分为两种类型：Iterable-style 和 Map-style。Iterable-style 数据集实现了 iter() 方法，可以迭代访问数据集中的元素，但不支持通过索引访问。而 Map-style 数据集实现了 getitem() 和 len() 方法，可以直接通过索引访问特定元素，并能获取数据集的大小。

TorchText 是 PyTorch 的一个扩展库，专注于处理文本数据。torchtext.data.functional 中的 to_map_style_dataset 函数可以帮助我们将一个 Iterable-style 数据集转换为一个易于操作的 Map-style 数据集。这样，我们可以通过索引直接访问数据集中的特定样本，从而简化了训练、验证和测试过程中的数据处理。

h. 使用测试集数据评估模型

print('Checking the results of test dataset.')
test_acc, test_loss = evaluate(test_dataloader)
print('test accuracy {:8.3f}'.format(test_acc))

Checking the results of test dataset.
test accuracy    0.006

3. 拓展：textCNN分类（通用模型）

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchtext.datasets import AG_NEWS
from torchtext.data.utils import get_tokenizer
from torchtext.vocab import build_vocab_from_iterator
import torch.nn.functional as F
import torch.optim as optim

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device

device(type='cuda')

tokenizer = get_tokenizer('basic_english')
train_iter = AG_NEWS(split='train')

def yield_tokens(data_iter):
    for _, text in data_iter:
        yield tokenizer(text)

vocab = build_vocab_from_iterator(yield_tokens(train_iter), specials=["<unk>"])
vocab.set_default_index(vocab["<unk>"])

# text_pipeline = lambda x: vocab(tokenizer(x))
label_pipeline = lambda x: int(x) - 1

def text_pipeline(x):
    return [vocab[token] for token in tokenizer(x)]

def collate_batch(batch):
    label_list, text_list = [], []
    max_length = 512  # 设定统一的文本长度
    
    for (_label, _text) in batch:
        label_list.append(label_pipeline(_label))
        # 将文本转换为词汇表索引列表
        tokenized_text = [vocab[token] for token in tokenizer(_text)]
        processed_text = torch.tensor(tokenized_text, dtype=torch.int64)
        # 根据max_length截断或填充文本
        if processed_text.size(0) < max_length:
            # 文本长度不足时填充
            processed_text = F.pad(processed_text, (0, max_length - processed_text.size(0)), "constant", 0)
        else:
            # 文本长度超过max_length时截断
            processed_text = processed_text[:max_length]
        text_list.append(processed_text)
        # print(processed_text.size())  # 打印每个处理后的文本尺寸 torch.Size([512])
    
    label_list = torch.tensor(label_list, dtype=torch.int64)
    # print("Before stack, single text shape:", text_list[0].shape)  # 检查单个文本的形状
    text_list = torch.stack(text_list, dim=0)  # 现在应该可以正确堆叠
    # print("After stack, texts shape:", text_list.shape)  # 检查堆叠后的形状
    return label_list, text_list

from torch.utils.data.dataset import random_split
from torchtext.data.functional import to_map_style_dataset

# 首先，转换生成器为具有映射样式的数据集
train_iter, test_iter = AG_NEWS()
train_dataset = to_map_style_dataset(train_iter)
test_dataset = to_map_style_dataset(test_iter)

# 计算训练集和验证集的大小
num_train = int(len(train_dataset) * 0.8)
num_valid = len(train_dataset) - num_train

# 划分数据集
train_data, valid_data = random_split(train_dataset, [num_train, num_valid])

# 定义DataLoader
train_dataloader = DataLoader(train_data, batch_size=64, shuffle=True, collate_fn=collate_batch)
valid_dataloader = DataLoader(valid_data, batch_size=64, shuffle=False, collate_fn=collate_batch)

class MyModel(nn.Module):
    def __init__(self, vocab_size, embedding_dim, num_filters, filter_sizes, output_dim, dropout=0.5):
        super(MyModel, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.convs = nn.ModuleList([
            nn.Conv2d(1, num_filters, (fs, embedding_dim)) for fs in filter_sizes
        ])
        self.fc = nn.Linear(num_filters * len(filter_sizes), output_dim)
        self.dropout = nn.Dropout(dropout)

    def forward(self, text):
        # print("Initial text shape:", text.shape)
        embedded = self.embedding(text)
        # print("After embedding:", embedded.shape)
        embedded = embedded.unsqueeze(1)
        # print("After unsqueeze:", embedded.shape)

        conved = [F.relu(conv(embedded)).squeeze(3) for conv in self.convs]
        #for i, conv in enumerate(conved):
        #    print(f"After conv {i} and squeeze:", conv.shape)

        pooled = [F.max_pool1d(conv, conv.shape[2]).squeeze(2) for conv in conved]
        #for i, pool in enumerate(pooled):
        #    print(f"After pooling {i}:", pool.shape)

        cat = torch.cat(pooled, dim=1)
        #print("After concatenation:", cat.shape)
        cat = self.dropout(cat)
        output = self.fc(cat)
        #print("Model output shape:", output.shape)
        return output

def train(dataloader, model, loss_fn, optimizer):
    import os
    os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'
    
    model.train()
    total_acc, total_loss, total_count = 0, 0, 0
    
    for labels, texts in dataloader:
        #print("Batch texts shape:", texts.shape)  # 查看批次文本的形状
        #print("Batch labels shape:", labels.shape)  # 查看批次标签的形状
        labels, texts = labels.to(device), texts.to(device)
        
        optimizer.zero_grad()
        pred = model(texts)
        
        #print("Model output shape:", pred.shape)  # 查看模型输出的形状
        
        loss = loss_fn(pred, labels)
        loss.backward()
        optimizer.step()
        
        total_acc += (pred.argmax(1) == labels).sum().item()
        total_loss += loss.item()
        total_count += labels.size(0)
    
    return total_acc / total_count, total_loss / total_count

def evaluate(dataloader, model, loss_fn):
    model.eval()
    total_acc, total_loss, total_count = 0, 0, 0
    
    with torch.no_grad():
        for labels, texts in dataloader:
            labels, texts = labels.to(device), texts.to(device)
            pred = model(texts)
            loss = loss_fn(pred, labels)
            
            total_acc += (pred.argmax(1) == labels).sum().item()
            total_loss += loss.item()
            total_count += labels.size(0)
    
    return total_acc / total_count, total_loss / total_count

vocab_size = len(vocab)
embed_dim = 100
num_class = len(set([label for (label, text) in AG_NEWS(split='train')]))
model = MyModel(vocab_size, embed_dim, num_filters=10, filter_sizes=[2, 3, 4], output_dim=num_class).to(device)

loss_fn = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
lambda1 = lambda epoch: 0.95 ** epoch  # 逐步减少学习率
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda1)

import copy

epochs     = 10

train_loss = []
train_acc  = []
test_loss  = []
test_acc   = []

best_acc = 0    # 设置一个最佳准确率，作为最佳模型的判别指标

for epoch in range(epochs):
    # 更新学习率（使用自定义学习率时使用）
    # adjust_learning_rate(optimizer, epoch, learn_rate)
    
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dataloader, model, loss_fn, optimizer)
    scheduler.step() # 更新学习率（调用官方动态学习率接口时使用）
    
    model.eval()
    epoch_test_acc, epoch_test_loss = evaluate(valid_dataloader, model, loss_fn)
    
    # 保存最佳模型到 best_model
    if epoch_test_acc > best_acc:
        best_acc   = epoch_test_acc
        best_model = copy.deepcopy(model)
    
    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)
    
    # 获取当前的学习率
    lr = optimizer.state_dict()['param_groups'][0]['lr']
    
    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr:{:.2E}')
    print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, 
                          epoch_test_acc*100, epoch_test_loss, lr))
    
# 保存最佳模型到文件中
PATH = './best_model.pth'  # 保存的参数文件名
torch.save(model.state_dict(), PATH)

print('Done')

Epoch: 1, Train_acc:60.2%, Train_loss:0.015, Test_acc:84.7%, Test_loss:0.007, Lr:9.50E-04
Epoch: 2, Train_acc:81.8%, Train_loss:0.008, Test_acc:88.1%, Test_loss:0.006, Lr:9.02E-04
Epoch: 3, Train_acc:86.0%, Train_loss:0.007, Test_acc:89.1%, Test_loss:0.005, Lr:8.57E-04
Epoch: 4, Train_acc:88.1%, Train_loss:0.006, Test_acc:89.8%, Test_loss:0.005, Lr:8.15E-04
Epoch: 5, Train_acc:89.3%, Train_loss:0.005, Test_acc:90.0%, Test_loss:0.005, Lr:7.74E-04
Epoch: 6, Train_acc:90.2%, Train_loss:0.005, Test_acc:90.3%, Test_loss:0.005, Lr:7.35E-04
Epoch: 7, Train_acc:90.9%, Train_loss:0.004, Test_acc:90.4%, Test_loss:0.005, Lr:6.98E-04
Epoch: 8, Train_acc:91.7%, Train_loss:0.004, Test_acc:90.4%, Test_loss:0.005, Lr:6.63E-04
Epoch: 9, Train_acc:92.1%, Train_loss:0.004, Test_acc:90.4%, Test_loss:0.005, Lr:6.30E-04
Epoch:10, Train_acc:92.6%, Train_loss:0.004, Test_acc:90.4%, Test_loss:0.005, Lr:5.99E-04
Done

import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore")               #忽略警告信息
plt.rcParams['font.sans-serif']    = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False      # 用来正常显示负号
plt.rcParams['figure.dpi']         = 100        #分辨率

epochs_range = range(epochs)

plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

4. 拓展：Bert分类（模型进阶）

代码部分

import torch
from torch.utils.data import DataLoader, Dataset
from transformers import BertTokenizer, BertForSequenceClassification, AdamW
import matplotlib.pyplot as plt
from torchtext.datasets import AG_NEWS

# 数据加载
train_iter = AG_NEWS(split='train')
test_iter = AG_NEWS(split='test')

# 统计文本长度
import matplotlib.pyplot as plt

def compute_text_lengths(data_iter):
    lengths = []
    for _, text in data_iter:
        # 计算每个文本的单词数
        word_count = len(text.split())
        lengths.append(word_count)
    return lengths

# 计算长度
lengths = compute_text_lengths(train_iter)

# 绘制文本长度的分布
plt.figure(figsize=(10, 6))
plt.hist(lengths, bins=50, alpha=0.75)
plt.title('Distribution of Text Lengths in AG_NEWS Dataset')
plt.xlabel('Text Length (number of words)')
plt.ylabel('Frequency')
plt.grid(True)
plt.show()

​

​

from transformers import BertTokenizer
from torch.utils.data import DataLoader, Dataset
import torch

# 指定本地模型文件路径
local_model_path = './pretrained_transformers/bert-base-uncased'

class AGNewsDataset(Dataset):
    def __init__(self, dataset_iter, tokenizer, max_length=100):
        self.samples = []
        for label, text in dataset_iter:
            label = label - 1  # 将标签从1-4转换为0-3
            encoding = tokenizer(text, truncation=True, max_length=max_length, padding='max_length', return_tensors="pt")
            self.samples.append((label, encoding['input_ids'].squeeze(0), encoding['attention_mask'].squeeze(0)))

    def __len__(self):
        return len(self.samples)

    def __getitem__(self, idx):
        return self.samples[idx]

# 实例化分词器
tokenizer = BertTokenizer.from_pretrained(local_model_path)

# 实例化数据集
train_dataset = AGNewsDataset(train_iter, tokenizer)
test_dataset = AGNewsDataset(test_iter, tokenizer)

# 为了有效地训练，我们通常使用 DataLoader 来批量加载数据
def collate_fn(batch):
    labels = torch.tensor([item[0] for item in batch])
    input_ids = torch.stack([item[1] for item in batch])
    attention_masks = torch.stack([item[2] for item in batch])
    return labels, input_ids, attention_masks

train_dataloader = DataLoader(train_dataset, batch_size=16, shuffle=True, collate_fn=collate_fn)
test_dataloader = DataLoader(test_dataset, batch_size=16, shuffle=False, collate_fn=collate_fn)

import torch

def train_epoch(model, dataloader, optimizer, device):
    model.train()
    total_loss, total_accuracy = 0, 0

    for labels, input_ids, masks in dataloader:
        labels, input_ids, masks = labels.to(device), input_ids.to(device), masks.to(device)
        optimizer.zero_grad()
        outputs = model(input_ids, token_type_ids=None, attention_mask=masks, labels=labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()

        total_loss += loss.item()
        # 计算准确率方法一，使用 pred.argmax(1)，我的习惯用法
        total_accuracy += (outputs.logits.argmax(1) == labels).sum().item()
        
        # 计算准确率方法二，非习惯用法
        # _, predicted_labels = torch.max(outputs.logits, 1)
        # total_accuracy += (predicted_labels == labels).sum().item()

    avg_loss = total_loss / len(dataloader)
    avg_accuracy = total_accuracy / len(dataloader.dataset)
    return avg_loss, avg_accuracy

def evaluate(model, dataloader, device):
    model.eval()
    total_loss, total_accuracy = 0, 0

    with torch.no_grad():
        for labels, input_ids, masks in dataloader:
            labels, input_ids, masks = labels.to(device), input_ids.to(device), masks.to(device)
            outputs = model(input_ids, token_type_ids=None, attention_mask=masks, labels=labels)
            loss = outputs.loss

            total_loss += loss.item()
            # 使用 argmax(1) 计算准确率
            total_accuracy += (outputs.logits.argmax(1) == labels).sum().item()

            # _, predicted_labels = torch.max(outputs.logits, 1)
            # total_accuracy += (predicted_labels == labels).sum().item()

    avg_loss = total_loss / len(dataloader)
    avg_accuracy = total_accuracy / len(dataloader.dataset)
    return avg_loss, avg_accuracy

from transformers import AdamW

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = BertForSequenceClassification.from_pretrained(local_model_path, num_labels=4)
model.to(device)
optimizer = AdamW(model.parameters(), lr=5e-5)

epochs = 4
train_losses, train_accuracies = [], []
test_losses, test_accuracies = [], []

for epoch in range(epochs):
    train_loss, train_accuracy = train_epoch(model, train_dataloader, optimizer, device)
    test_loss, test_accuracy = evaluate(model, test_dataloader, device)

    train_losses.append(train_loss)
    train_accuracies.append(train_accuracy)
    test_losses.append(test_loss)
    test_accuracies.append(test_accuracy)
    print(f'Epoch {epoch + 1}/{epochs}: Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy:.4f}, Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy:.4f}')

Some weights of BertForSequenceClassification were not initialized from the model checkpoint at ./pretrained_transformers/bert-base-uncased and are newly initialized: ['classifier.bias', 'classifier.weight']
You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
D:\Anacanda3\envs\pytorch_cuda12_0_py310\lib\site-packages\transformers\optimization.py:591: FutureWarning: This implementation of AdamW is deprecated and will be removed in a future version. Use the PyTorch implementation torch.optim.AdamW instead, or set `no_deprecation_warning=True` to disable this warning
  warnings.warn(
D:\Anacanda3\envs\pytorch_cuda12_0_py310\lib\site-packages\transformers\models\bert\modeling_bert.py:439: UserWarning: 1Torch was not compiled with flash attention. (Triggered internally at ..\aten\src\ATen\native\transformers\cuda\sdp_utils.cpp:263.)
  attn_output = torch.nn.functional.scaled_dot_product_attention(


Epoch 1/4: Train Loss: 0.2336, Train Accuracy: 0.9206, Test Loss: 0.1912, Test Accuracy: 0.9379
Epoch 2/4: Train Loss: 0.1535, Train Accuracy: 0.9486, Test Loss: 0.1828, Test Accuracy: 0.9425
Epoch 3/4: Train Loss: 0.1237, Train Accuracy: 0.9595, Test Loss: 0.1977, Test Accuracy: 0.9379
Epoch 4/4: Train Loss: 0.0982, Train Accuracy: 0.9681, Test Loss: 0.2179, Test Accuracy: 0.9396

import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore")               #忽略警告信息
plt.rcParams['font.sans-serif']    = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False      # 用来正常显示负号
plt.rcParams['figure.dpi']         = 100        #分辨率

plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.plot(train_accuracies, label='Train Accuracy')
plt.plot(test_accuracies, label='Test Accuracy')
plt.title('Accuracy over epochs')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(train_losses, label='Train Loss')
plt.plot(test_losses, label='Test Loss')
plt.title('Loss over epochs')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()

plt.show()

​

疑问解答：

使用镜像模型下载模型方法记录：

网站记录：
[下载huggingface模型——全方法总结](如何快速下载huggingface模型——全方法总结 - padeoe的文章 - 知乎
https://zhuanlan.zhihu.com/p/663712983)
模型下载镜像网站

镜像网站下载方法：
在完成设置环境变量后，你可以使用 Hugging Face CLI 工具将模型下载到 D 盘中的指定目录。下面是具体步骤：

• 1. 安装依赖

你已经完成了这一步，确保 huggingface_hub 已经安装：

pip install -U huggingface_hub

• 2. 设置环境变量

你已经完成了这一步，在 PowerShell 中设置环境变量：

$env:HF_ENDPOINT = "https://hf-mirror.com"

• 3. 下载模型

使用 Hugging Face CLI 工具下载模型 google-bert/bert-base-uncased 到 D 盘中的指定目录，例如 D:\huggingface\models。

• 创建目标目录（如果不存在）

首先，确保目标目录存在。如果不存在，可以创建它：

New-Item -ItemType Directory -Path "D:\huggingface\models" -Force

• 下载模型

然后，使用以下命令下载模型：

huggingface-cli download google-bert/bert-base-uncased --local-dir D:\huggingface\models\bert-base-uncased --resume-download --local-dir-use-symlinks False

这个命令将模型下载到 D:\huggingface\models\bert-base-uncased 目录中，并禁用文件软链接。

• 完整流程示例

1. 确保安装了 huggingface_hub：

   pip install -U huggingface_hub
   

2. 设置环境变量：

   $env:HF_ENDPOINT = "https://hf-mirror.com"
   

3. 创建目标目录：

   New-Item -ItemType Directory -Path "D:\huggingface\models" -Force
   

4. 下载模型：

   huggingface-cli download google-bert/bert-base-uncased --local-dir D:\huggingface\models\bert-base-uncased --resume-download --local-dir-use-symlinks False
   

通过这些步骤，你应该能够成功将模型下载到 D 盘中的指定目录。
C:\Users\Cheng>huggingface-cli download google-bert/bert-base-uncased --local-dir D:\DataAnalysis\jupyter_notebook_warehouse\pytorch学习\pretrained_transformers\bert-base-uncased --resume-download --local-dir-use-symlinks False

提问：AGNewsDataset类代码解析

代码解析：这段代码定义了一个名为 AGNewsDataset 的类，这个类继承自 PyTorch 的 Dataset 类，并用于处理 AG_NEWS 文本数据集以适配 BERT 模型的输入格式。以下是逐句的详细解析：

类定义和初始化方法 __init__

class AGNewsDataset(Dataset):

这行代码定义了一个新的类 AGNewsDataset，它继承自 PyTorch 的 Dataset 类。继承 Dataset 类是创建自定义数据集类的典型方法，用于与 PyTorch 的其他数据加载和处理工具（如 DataLoader）无缝集成。

def __init__(self, dataset_iter, tokenizer, max_length=512):
    self.samples = []

• __init__ 方法是类的构造函数，用于初始化新创建的对象。它接收三个参数：dataset_iter（数据集迭代器），tokenizer（用于文本分词的 BERT 分词器），以及一个可选参数 max_length（最大序列长度，默认为512）。
• self.samples = [] 初始化一个空列表，用来存储处理后的数据样本。

for label, text in dataset_iter:
    label = label - 1  # 将标签从1-4转换为0-3

• 这个循环遍历数据集迭代器中的每一条数据。每条数据包含一个标签和一个文本字符串。
• label = label - 1 将标签从原始的 1-4 范围调整到 0-3，因为 PyTorch 通常期望类标签从0开始。

encoding = tokenizer(text, truncation=True, max_length=max_length, padding='max_length', return_tensors="pt")

• 这行代码使用传入的 BERT 分词器对文本进行编码。truncation=True 表示如果文本长度超过 max_length，则将其截断。padding='max_length' 确保所有文本编码后长度相同，不足的部分用填充符补齐。return_tensors="pt" 表示返回的编码格式为 PyTorch 张量。

self.samples.append((label, encoding['input_ids'].squeeze(0), encoding['attention_mask'].squeeze(0)))

• 这行代码将处理好的标签、输入ID张量和注意力掩码张量添加到 samples 列表中。使用 .squeeze(0) 是为了去除多余的维度，使得每个样本的输入ID和注意力掩码都是一维的。

数据集长度方法 __len__

def __len__(self):
    return len(self.samples)

• __len__ 方法返回数据集中的样本数，这是 Dataset 类必须实现的方法之一。它使得 PyTorch 的 DataLoader 能够知道数据集的大小。

获取单个项目方法 __getitem__

def __getitem__(self, idx):
    return self.samples[idx]

• __getitem__ 方法根据提供的索引 idx 返回相应的样本。这是另一个 Dataset 类必须实现的方法，它允许 DataLoader 按需索引数据集中的元素。

这样，AGNewsDataset 类就可以被 DataLoader 使用，用于按批次加载和准备数据，进而供模型训练使用。

提问：解析自定义的数据批量加载函数 collate_fn：

这段代码定义了一个 collate_fn 函数，并用它来创建 PyTorch 的 DataLoader 对象，分别为训练集和测试集。下面是详细的解析：

1. collate_fn 函数

collate_fn 函数是用来决定如何将多个数据样本（这些样本组成了一个 batch）组合到一起的。这在处理那些需要特定方式合并数据的情况下非常有用，尤其是当数据项的形状或类型不一致时。

def collate_fn(batch):
    labels = torch.tensor([item[0] for item in batch])
    input_ids = torch.stack([item[1] for item in batch])
    attention_masks = torch.stack([item[2] for item in batch])
    return labels, input_ids, attention_masks

• batch: 这是一个列表，其中每个元素都是 Dataset.__getitem__ 方法返回的数据样本。在这个例子中，每个样本包括三个部分：标签、输入 ID 和注意力掩码。

• labels: 从 batch 中提取每个样本的第一个元素（标签），并将这些标签转换为一个 PyTorch 张量。这里使用了列表推导式来收集所有标签。

• input_ids: 从 batch 中提取每个样本的第二个元素（输入 ID），并使用 torch.stack 将这些输入 ID 堆叠成一个新的张量。torch.stack 是将一系列张量沿着一个新的维度合并，这里即是在 batch 维度上堆叠。

• attention_masks: 同样地，从 batch 中提取每个样本的第三个元素（注意力掩码），并使用 torch.stack 合并成一个张量。

这个函数最终返回一组张量：labels, input_ids, attention_masks，它们都是整个 batch 的合集，形状通常为 [batch_size, sequence_length]，labels 的形状则为 [batch_size]。

2. DataLoader 对象

train_dataloader = DataLoader(train_dataset, batch_size=16, shuffle=True, collate_fn=collate_fn)
test_dataloader = DataLoader(test_dataset, batch_size=16, shuffle=False, collate_fn=collate_fn)

• DataLoader: 是 PyTorch 中用于加载数据集的工具，它可以自动处理数据的批次化、打乱、多线程加载等操作。

• train_dataset 和 test_dataset: 这些是之前定义好的数据集对象。

• batch_size: 指定了每个 batch 包含的样本数，这里设置为 16。

• shuffle: 指定是否在每个 epoch 开始时打乱数据（仅对训练数据设置为 True）。打乱数据有助于减少模型训练过程中的过拟合。

• collate_fn: 为 DataLoader 指定了 collate_fn 函数，这是自定义的数据批处理方式，用于处理以上提到的输入 ID 和注意力掩码。

通过这样的设置，您的训练和测试 DataLoader 将能够有效地为模型训练和评估提供预处理好的数据批次。这是实现高效和有效训练的关键步骤之一。

提问：统计文本长度并调整max_length的长度该如何实现

统计文本长度并据此调整 max_length 是一项实用的数据预处理步骤，可以帮助您更好地理解数据集并优化模型的性能。下面我会详细说明如何用 Python 实现这一过程：

1. 统计文本长度

首先，我们需要计算数据集中每个文本条目的长度（可以是单词数或字符数）。这里，我们将以单词数为例：

from torchtext.datasets import AG_NEWS
import matplotlib.pyplot as plt

def compute_text_lengths(data_iter):
    lengths = []
    for _, text in data_iter:
        # 计算每个文本的单词数
        word_count = len(text.split())
        lengths.append(word_count)
    return lengths

# 加载数据集
train_iter = AG_NEWS(split='train')

# 计算长度
lengths = compute_text_lengths(train_iter)

# 绘制文本长度的分布
plt.figure(figsize=(10, 6))
plt.hist(lengths, bins=50, alpha=0.75)
plt.title('Distribution of Text Lengths in AG_NEWS Dataset')
plt.xlabel('Text Length (number of words)')
plt.ylabel('Frequency')
plt.grid(True)
plt.show()

这段代码将加载 AG_NEWS 训练数据集，并统计每个新闻条目的单词数量，然后绘制这些长度的直方图。

2. 分析结果并选择 max_length

通过观察直方图，您可以大致了解大多数文本的长度。选择 max_length 的策略如下：

• 选择覆盖大部分数据的长度：如果直方图显示大多数文本的长度在 200 词以内，那么设置 max_length 为 200 或稍高一点可能是合理的。
• 考虑模型和资源限制：虽然可能想要覆盖尽可能多的文本内容，但也要考虑到更长的序列会增加计算复杂性和内存需求。BERT 模型的默认最大长度是 512，这通常是一个安全的上限。

3. 验证调整后的 max_length

一旦选择了一个新的 max_length，您可以通过在模型训练前重新处理数据集来实施它。确保使用新的 max_length 更新数据编码过程：

from transformers import BertTokenizer

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
new_max_length = 200  # 假设您根据分析选择了这个长度

def encode_texts(tokenizer, texts, max_length):
    return tokenizer(texts, truncation=True, padding='max_length', max_length=max_length, return_tensors="pt")

# 示例文本编码
encoded_data = encode_texts(tokenizer, "Example text for encoding.", new_max_length)

这样，您就能够根据实际数据分布合理设置 max_length，从而在保证效率的同时最大化模型的性能。如果数据集变化或模型更换，您可能需要重新进行这些步骤来调整参数。

提问：统计文本长度分布的方法发现，文本长度集中在25-50个单词，超过75个单词的文本很少，文本最大长度在200左右，该如何确定max_length

回答：
既然您已经分析了 AG_NEWS 数据集中的文本长度分布，发现大部分文本长度集中在 25-50 个单词，超过 75 个单词的非常少，且最长文本大约在 200 个单词，这为确定 max_length 提供了实际的依据。

如何选择 max_length

1. 考虑覆盖大多数样本：

   • 由于超过 75 个单词的文本很少，选择一个稍大于这个值的 max_length 可以覆盖绝大多数情况。例如，您可以选择 max_length 为 80 或 100，这样可以处理大部分文本而不需要截断太多内容。

2. 权衡性能与计算成本：

   • 较短的 max_length 可以减少计算量，加快模型训练速度，同时也可能减少内存使用。但是，太短可能无法充分利用上下文信息，特别是对于少数较长的文本。
   • 如果实际应用中对速度和资源消耗特别敏感，甚至可以考虑更短的长度，如 50 或 60。

3. 实验验证：

   • 您可以通过实验来验证不同的 max_length 如何影响模型性能。具体来说，可以在几个不同的长度（如 50、75、100 和 125）上训练模型，然后比较它们在验证集上的表现。选择在保持良好性能的同时，计算成本最低的配置。

4. 考虑特定任务的需求：

   • 如果任务对文本的精确理解非常敏感，可能需要选择较长的 max_length 以避免丢失信息。如果任务只需捕捉关键信息，可以使用较短的长度。

实施建议
根据您的描述，一个合理的起始点可能是设置 max_length 为 100，然后观察模型的性能。如果发现模型性能不佳，并怀疑是由于截断导致重要信息丢失，可以适当增加长度。相反，如果模型训练非常慢，可以尝试缩短长度到 80 或更少，特别是如果大多数文本都非常短的情况下。

最后，通过多次迭代和调整，结合实际应用场景的需求，您可以找到最合适的 max_length 设置。

提问：其他模型，比如textCNN 模型 中的max_length是否也应该是同样的设置方法，其对文本的处理方式是embedding

回答：

是的，对于使用文本CNN模型的场景，选择 max_length 的方法和考虑因素与使用BERT类似，但可能需要根据模型架构的不同稍作调整。TextCNN和其他基于卷积的模型通常对序列长度的灵活性更强一些，因为卷积层可以适应不同长度的输入。下面是具体到TextCNN模型时设置 max_length 的一些特殊考虑和步骤。

文本CNN的特殊考虑

1. 模型架构：

   • TextCNN使用多个不同大小的卷积核来捕捉不同范围的上下文信息。因此，即使文本相对较短，使用较长的 max_length 也可能有助于模型捕捉更广泛的上下文特征。

2. 灵活性：

   • 与BERT不同，TextCNN不需要特定长度的位置嵌入，因此在理论上对输入长度的要求更为灵活。这意味着您可以根据实际文本长度分布更自由地调整 max_length。

3. 计算效率：

   • TextCNN通常比BERT在计算上更高效，因为它不涉及大量的自注意力计算。这可能允许您在资源许可的情况下使用较长的输入序列。

设置 max_length 的步骤

与之前类似，确定 TextCNN 的 max_length 也应基于数据的实际分析：

1. 数据分析：

   • 如之前所述，首先分析数据集中文本的长度分布。这有助于确定大多数文本的长度范围。

2. 实验验证：

   • 尝试不同的 max_length 设置，观察模型在验证集上的性能。特别是要注意不同长度设置对模型准确率和训练时间的影响。

3. 模型适应性测试：

   • 可以测试模型对于不同 max_length 的敏感性，看看长度变化对性能的影响是否显著。

总的来说，选择 max_length 应基于对数据的理解、模型架构的需求和计算资源的考虑，同时通过实验来找到最佳设置。

提问：以下这两种代码写法可以互换吗

total_acc += (pred.argmax(1) == labels).sum().item() 

与

_, predicted_labels = torch.max(outputs.logits, 1)
total_accuracy += (predicted_labels == labels).sum().item()

回答：

是的，这两行代码基本上是执行相同的操作，只是写法略有不同。它们都用于计算模型预测的准确性。我们可以对比这两种方法来看看它们是如何工作的：

方法 1

total_acc += (pred.argmax(1) == labels).sum().item()

这里的代码做了以下几件事：

1. pred.argmax(1)：这个方法从预测结果 pred 中沿着指定的维度（这里是维度 1，即类别概率维度）取出最大值的索引。如果 pred 是模型的 logits 或 softmax 输出，则 argmax(1) 会返回每个样本最可能的类别索引。
2. (pred.argmax(1) == labels)：这个操作生成一个布尔类型的张量，表示预测类别是否与真实标签相同。
3. .sum()：统计预测正确的数量。
4. .item()：将这个 Python 数字从一个单元素张量中取出来，用于后续的累加操作。

方法 2

_, predicted_labels = torch.max(outputs.logits, 1)
total_accuracy += (predicted_labels == labels).sum().item()

这行代码的工作流程如下：

1. torch.max(outputs.logits, 1)：这个函数返回两个结果，第一个是每行的最大值，第二个是这些最大值所在的索引（即 predicted_labels）。这里通过下划线 _ 忽略了第一个返回值，只取类别索引。
2. (predicted_labels == labels)：同样生成一个布尔张量，表示预测是否正确。
3. .sum() 和 .item() 的操作与方法 1 相同。

可以互换吗？
这两种方法可以互换使用，因为它们实际上都在做同样的事情：计算模型在一个批次中正确预测的样本数。方法 2 明确使用了 torch.max()，它在语义上可能更清晰一些，尤其是当与一些文档或教程相比较时，因为 torch.max() 显式地返回最大值和其索引，使得代码的意图更加直观。

选择哪一种方式主要取决于个人偏好或团队的编码规范。如果代码的可读性是一个考量因素，可能更倾向于使用方法 2，因为它更直观地表明了正在找寻最大的 logits 并获取它们的索引。但在性能上，两种方法没有显著差异。

代码改写：使用 argmax(1) 计算准确率

# 使用 argmax(1) 计算准确率
total_accuracy += (outputs.logits.argmax(1) == labels).sum().item()