• 【NLP】使用 BERT 和 PyTorch Lightning 进行多标签文本分类

     🔎大家好，我是Sonhhxg_柒，希望你看完之后，能对你有所帮助，不足请指正！共同学习交流🔎

    📝个人主页－Sonhhxg_柒的博客_CSDN博客 📃

    🎁欢迎各位→点赞👍 + 收藏⭐️ + 留言📝​

    📣系列专栏 - 机器学习【ML】 自然语言处理【NLP】  深度学习【DL】

    ​​

     🖍foreword

    ✔说明⇢本人讲解主要包括Python、机器学习（ML）、深度学习（DL）、自然语言处理（NLP）等内容。

    如果你对这个系列感兴趣的话，可以关注订阅哟👋

    文章目录

    数据

    预处理

    Tokenization

    数据集

    模型

    优化器调度器

    评估

    训练

    预测

    评估

    概括

    了解如何为多标签文本分类（标记）准备带有恶意评论的数据集。我们将使用 PyTorch Lightning 微调 BERT 并评估模型。

    多标签文本分类（或标记文本）是您在执行 NLP 时会遇到的最常见任务之一。现代基于 Transformer 的模型（如 BERT）利用对大量文本数据的预训练，可以更快地进行微调，使用更少的资源并且在较小的（更）数据集上更准确。

    在本教程中，您将学习如何：

    • 将文本数据加载、平衡和拆分成集合
    • 标记文本（使用 BERT 标记器）并创建 PyTorch 数据集
    • 使用 PyTorch Lightning 微调 BERT 模型
    • 了解热身步骤并使用学习率调度程序
    • 在训练期间使用 ROC 下的面积和二元交叉熵来评估模型
    • 如何使用微调的 BERT 模型进行预测
    • 评估每个类的模型性能（可能的注释标记）

    我们的模型对有害文本检测有用吗？

    1. import pandas as pd
    2. import numpy as np
    3.  
    4. from tqdm.auto import tqdm
    5.  
    6. import torch
    7. import torch.nn as nn
    8. from torch.utils.data import Dataset, DataLoader
    9.  
    10. from transformers import BertTokenizerFast as BertTokenizer, BertModel, AdamW, get_linear_schedule_with_warmup
    11.  
    12. import pytorch_lightning as pl
    13. from pytorch_lightning.metrics.functional import accuracy, f1, auroc
    14. from pytorch_lightning.callbacks import ModelCheckpoint, EarlyStopping
    15. from pytorch_lightning.loggers import TensorBoardLogger
    16.  
    17. from sklearn.model_selection import train_test_split
    18. from sklearn.metrics import classification_report, multilabel_confusion_matrix
    19.  
    20. import seaborn as sns
    21. from pylab import rcParams
    22. import matplotlib.pyplot as plt
    23. from matplotlib import rc
    24.  
    25. %matplotlib inline
    26. %config InlineBackend.figure_format='retina'
    27.  
    28. RANDOM_SEED = 42
    29.  
    30. sns.set(style='whitegrid', palette='muted', font_scale=1.2)
    31. HAPPY_COLORS_PALETTE = ["#01BEFE", "#FFDD00", "#FF7D00", "#FF006D", "#ADFF02", "#8F00FF"]
    32. sns.set_palette(sns.color_palette(HAPPY_COLORS_PALETTE))
    33. rcParams['figure.figsize'] = 12, 8
    34.  
    35. pl.seed_everything(RANDOM_SEED)

    数据

    我们的数据集包含潜在的攻击性（有毒）评论，来自有毒评论分类挑战。让我们从下载数据开始（从 Google 云端硬盘）：

    !gdown--ID1VQ-U7TtggShMeuRSA_hzC8qGDl2LRkr

    让我们加载并查看数据：

    1. df = pd.read_csv("toxic_comments.csv")
    2. df.head()
    idcomment_texttoxicsevere_toxicobscenethreatinsultidentity_hate
    00000997932d777bfExplanation\nWhy the edits made under my usern...000000
    1000103f0d9cfb60fD'aww! He matches this background colour I'm s...000000
    2000113f07ec002fdHey man, I'm really not trying to edit war. It...000000
    30001b41b1c6bb37e"\nMore\nI can't make any real suggestions on ...000000
    40001d958c54c6e35You, sir, are my hero. Any chance you remember...000000

    我们有文字（评论）和六种不同的毒性标签。请注意，我们也有干净的内容。

    让我们拆分数据：

    1. train_df, val_df = train_test_split(df, test_size=0.05)
    2. train_df.shape, val_df.shape

     ((151592, 8), (7979, 8))

    预处理

    让我们看看标签的分布：

    1. LABEL_COLUMNS = df.columns.tolist()[2:]
    2. df[LABEL_COLUMNS].sum().sort_values().plot(kind="barh");

    ​

     评论中的标签数量

    我们有一个严重的失衡案例。但这还不是全部。有毒与干净的评论呢？

    1. train_toxic = train_df[train_df[LABEL_COLUMNS].sum(axis=1) > 0]
    2. train_clean = train_df[train_df[LABEL_COLUMNS].sum(axis=1) == 0]
    3.  
    4. pd.DataFrame(dict(
    5.   toxic=[len(train_toxic)],
    6.   clean=[len(train_clean)]
    7. )).plot(kind='barh');

     ​

     数据集中的干净评论与有毒评论计数

     同样，我们对干净的评论存在严重的不平衡。为了解决这个问题，我们将从干净的评论中抽取 15,000 个示例并创建一个新的训练集：

    1. train_df = pd.concat([
    2.   train_toxic,
    3.   train_clean.sample(15_000)
    4. ])
    5.  
    6. train_df.shape, val_df.shape

    ((30427, 8), (7979, 8)) 

    Tokenization

    我们需要将原始文本转换为标记列表。为此，我们将使用内置的 BertTokenizer：

    1. BERT_MODEL_NAME = 'bert-base-cased'
    2. tokenizer = BertTokenizer.from_pretrained(BERT_MODEL_NAME)

    让我们在示例评论中尝试一下： 

    1. sample_row = df.iloc[16]
    2. sample_comment = sample_row.comment_text
    3. sample_labels = sample_row[LABEL_COLUMNS]
    4.  
    5. print(sample_comment)
    6. print()
    7. print(sample_labels.to_dict())

    Bye!

    Don't look, come or think of comming back! Tosser.

    {'toxic': 1, 'severe_toxic': 0, 'obscene': 0, 'threat': 0, 'insult': 0, 'identity_hate': 0}

    1. encoding = tokenizer.encode_plus(
    2.   sample_comment,
    3.   add_special_tokens=True,
    4.   max_length=512,
    5.   return_token_type_ids=False,
    6.   padding="max_length",
    7.   return_attention_mask=True,
    8.   return_tensors='pt',
    9. )
    10.  
    11. encoding.keys()

     dict_keys(['input_ids', 'attention_mask'])

    encoding["input_ids"].shape, encoding["attention_mask"].shape

    (torch.Size([1, 512]), torch.Size([1, 512])) 

    编码的结果是一个带有标记 idinput_ids和注意力掩码的字典attention_mask（模型应该使用哪些标记 1 - 使用或 0 - 不使用）。

    让我们看看它们的内容：

    encoding["input_ids"].squeeze()[:20]
    tensor([ 101, 17774, 106, 1790, 112, 189, 1440, 117, 1435, 1137,2 1341, 1104, 3254, 5031, 1171, 106, 1706, 14607, 119, 102])
    encoding["attention_mask"].squeeze()[:20]

    tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]) 

    您还可以反转标记化并从标记 ID 中取回（有点）单词：

    print(tokenizer.convert_ids_to_tokens(encoding["input_ids"].squeeze())[:20])

     ['[CLS]', 'Bye', '!', 'Don', "'", 't', 'look', ',', 'come', 'or', 'think', 'of', 'com', '##ming', 'back', '!', 'To', '##sser', '.', '[SEP]']

     我们需要在编码时指定最大的标记数（512 是我们可以做的最大值）。让我们检查每个评论的标记数：

    1. token_counts = []
    2.  
    3. for _, row in train_df.iterrows():
    4.   token_count = len(tokenizer.encode(
    5.     row["comment_text"],
    6.     max_length=512,
    7.     truncation=True
    8.   ))
    9.   token_counts.append(token_count)
    1. sns.histplot(token_counts)
    2. plt.xlim([0, 512]);

     ​

    每条评论的标记数 

     大多数评论包含少于 300 个令牌或超过 512 个。因此，我们将坚持 512 个的限制。

    MAX_TOKEN_COUNT = 512

    数据集

    我们将把标记化过程包装在 PyTorch 数据集中，同时将标签转换为张量：

    1. class ToxicCommentsDataset(Dataset):
    2.  
    3.   def __init__(
    4.     self,
    5.     data: pd.DataFrame,
    6.     tokenizer: BertTokenizer,
    7.     max_token_len: int = 128
    8.   ):
    9.     self.tokenizer = tokenizer
    10.     self.data = data
    11.     self.max_token_len = max_token_len
    12.  
    13.   def __len__(self):
    14.     return len(self.data)
    15.  
    16.   def __getitem__(self, index: int):
    17.     data_row = self.data.iloc[index]
    18.  
    19.     comment_text = data_row.comment_text
    20.     labels = data_row[LABEL_COLUMNS]
    21.  
    22.     encoding = self.tokenizer.encode_plus(
    23.       comment_text,
    24.       add_special_tokens=True,
    25.       max_length=self.max_token_len,
    26.       return_token_type_ids=False,
    27.       padding="max_length",
    28.       truncation=True,
    29.       return_attention_mask=True,
    30.       return_tensors='pt',
    31.     )
    32.  
    33.     return dict(
    34.       comment_text=comment_text,
    35.       input_ids=encoding["input_ids"].flatten(),
    36.       attention_mask=encoding["attention_mask"].flatten(),
    37.       labels=torch.FloatTensor(labels)
    38.     )

     让我们看一下数据集中的示例项目：

    1. train_dataset = ToxicCommentsDataset(
    2.   train_df,
    3.   tokenizer,
    4.   max_token_len=MAX_TOKEN_COUNT
    5. )
    6.  
    7. sample_item = train_dataset[0]
    8. sample_item.keys()

    dict_keys(['comment_text', 'input_ids', 'attention_mask', 'labels']) 

    sample_item["comment_text"]

    'Hi, ya fucking idiot. ^_^' 

    sample_item["labels"]

    tensor([1., 0., 1., 0., 1., 0.]) 

    sample_item["input_ids"].shape

    torch.Size([512]) 

    让我们加载 BERT 模型并通过以下方式传递批处理数据样本：

    1. bert_model = BertModel.from_pretrained(BERT_MODEL_NAME, return_dict=True)
    2.  
    3. sample_batch = next(iter(DataLoader(train_dataset, batch_size=8, num_workers=2)))
    4. sample_batch["input_ids"].shape, sample_batch["attention_mask"].shape

    (torch.Size([8, 512]), torch.Size([8, 512])) 

    1. output = bert_model(sample_batch["input_ids"], sample_batch["attention_mask"])
    2.  
    3. output.last_hidden_state.shape, output.pooler_output.shape

    (torch.Size([8, 512, 768]), torch.Size([8, 768])) 

    维度来自768BERT hidden size：

    bert_model.config.hidden_size

    768 

    较大版本的 BERT 具有更多的注意力头和更大的隐藏尺寸。

    我们会将自定义数据集包装到LightningDataModule中：

    1. class ToxicCommentDataModule(pl.LightningDataModule):
    2.  
    3.   def __init__(self, train_df, test_df, tokenizer, batch_size=8, max_token_len=128):
    4.     super().__init__()
    5.     self.batch_size = batch_size
    6.     self.train_df = train_df
    7.     self.test_df = test_df
    8.     self.tokenizer = tokenizer
    9.     self.max_token_len = max_token_len
    10.  
    11.   def setup(self, stage=None):
    12.     self.train_dataset = ToxicCommentsDataset(
    13.       self.train_df,
    14.       self.tokenizer,
    15.       self.max_token_len
    16.     )
    17.  
    18.     self.test_dataset = ToxicCommentsDataset(
    19.       self.test_df,
    20.       self.tokenizer,
    21.       self.max_token_len
    22.     )
    23.  
    24.   def train_dataloader(self):
    25.     return DataLoader(
    26.       self.train_dataset,
    27.       batch_size=self.batch_size,
    28.       shuffle=True,
    29.       num_workers=2
    30.     )
    31.  
    32.   def val_dataloader(self):
    33.     return DataLoader(
    34.       self.test_dataset,
    35.       batch_size=self.batch_size,
    36.       num_workers=2
    37.     )
    38.  
    39.   def test_dataloader(self):
    40.     return DataLoader(
    41.       self.test_dataset,
    42.       batch_size=self.batch_size,
    43.       num_workers=2
    44.     )

    ToxicCommentDataModule封装所有数据加载逻辑并返回必要的数据加载器。让我们创建一个数据模块的实例： 

    1. N_EPOCHS = 10
    2. BATCH_SIZE = 12
    3.  
    4. data_module = ToxicCommentDataModule(
    5.   train_df,
    6.   val_df,
    7.   tokenizer,
    8.   batch_size=BATCH_SIZE,
    9.   max_token_len=MAX_TOKEN_COUNT
    10. )

    模型

    我们的模型将使用预训练的BertModel和线性层将 BERT 表示转换为分类任务。我们会将所有内容打包到LightningModule中：

    1. class ToxicCommentTagger(pl.LightningModule):
    2.  
    3.   def __init__(self, n_classes: int, n_training_steps=None, n_warmup_steps=None):
    4.     super().__init__()
    5.     self.bert = BertModel.from_pretrained(BERT_MODEL_NAME, return_dict=True)
    6.     self.classifier = nn.Linear(self.bert.config.hidden_size, n_classes)
    7.     self.n_training_steps = n_training_steps
    8.     self.n_warmup_steps = n_warmup_steps
    9.     self.criterion = nn.BCELoss()
    10.  
    11.   def forward(self, input_ids, attention_mask, labels=None):
    12.     output = self.bert(input_ids, attention_mask=attention_mask)
    13.     output = self.classifier(output.pooler_output)
    14.     output = torch.sigmoid(output)
    15.     loss = 0
    16.     if labels is not None:
    17.         loss = self.criterion(output, labels)
    18.     return loss, output
    19.  
    20.   def training_step(self, batch, batch_idx):
    21.     input_ids = batch["input_ids"]
    22.     attention_mask = batch["attention_mask"]
    23.     labels = batch["labels"]
    24.     loss, outputs = self(input_ids, attention_mask, labels)
    25.     self.log("train_loss", loss, prog_bar=True, logger=True)
    26.     return {"loss": loss, "predictions": outputs, "labels": labels}
    27.  
    28.   def validation_step(self, batch, batch_idx):
    29.     input_ids = batch["input_ids"]
    30.     attention_mask = batch["attention_mask"]
    31.     labels = batch["labels"]
    32.     loss, outputs = self(input_ids, attention_mask, labels)
    33.     self.log("val_loss", loss, prog_bar=True, logger=True)
    34.     return loss
    35.  
    36.   def test_step(self, batch, batch_idx):
    37.     input_ids = batch["input_ids"]
    38.     attention_mask = batch["attention_mask"]
    39.     labels = batch["labels"]
    40.     loss, outputs = self(input_ids, attention_mask, labels)
    41.     self.log("test_loss", loss, prog_bar=True, logger=True)
    42.     return loss
    43.  
    44.   def training_epoch_end(self, outputs):
    45.  
    46.     labels = []
    47.     predictions = []
    48.     for output in outputs:
    49.       for out_labels in output["labels"].detach().cpu():
    50.         labels.append(out_labels)
    51.       for out_predictions in output["predictions"].detach().cpu():
    52.         predictions.append(out_predictions)
    53.  
    54.     labels = torch.stack(labels).int()
    55.     predictions = torch.stack(predictions)
    56.  
    57.     for i, name in enumerate(LABEL_COLUMNS):
    58.       class_roc_auc = auroc(predictions[:, i], labels[:, i])
    59.       self.logger.experiment.add_scalar(f"{name}_roc_auc/Train", class_roc_auc, self.current_epoch)
    60.  
    61.   def configure_optimizers(self):
    62.  
    63.     optimizer = AdamW(self.parameters(), lr=2e-5)
    64.  
    65.     scheduler = get_linear_schedule_with_warmup(
    66.       optimizer,
    67.       num_warmup_steps=self.n_warmup_steps,
    68.       num_training_steps=self.n_training_steps
    69.     )
    70.  
    71.     return dict(
    72.       optimizer=optimizer,
    73.       lr_scheduler=dict(
    74.         scheduler=scheduler,
    75.         interval='step'
    76.       )
    77.     )

     大多数实现只是一个样板。两个有趣的点是我们配置优化器的方式和计算 ROC 下的面积。接下来我们将深入探讨这些内容。

    优化器调度器

    调度器的工作是在训练期间改变优化器的学习率。这可能会导致我们的模型有更好的性能。我们将使用get_linear_schedule_with_warmup。

    让我们看一个简单的例子，让事情更清楚：

    1. dummy_model = nn.Linear(2, 1)
    2.  
    3. optimizer = AdamW(params=dummy_model.parameters(), lr=0.001)
    4.  
    5. warmup_steps = 20
    6. total_training_steps = 100
    7.  
    8. scheduler = get_linear_schedule_with_warmup(
    9.   optimizer,
    10.   num_warmup_steps=warmup_steps,
    11.   num_training_steps=total_training_steps
    12. )
    13.  
    14. learning_rate_history = []
    15.  
    16. for step in range(total_training_steps):
    17.   optimizer.step()
    18.   scheduler.step()
    19.   learning_rate_history.append(optimizer.param_groups[0]['lr'])
    20.  
    21. plt.plot(learning_rate_history, label="learning rate")
    22. plt.axvline(x=warmup_steps, color="red", linestyle=(0, (5, 10)), label="warmup end")
    23. plt.legend()
    24. plt.xlabel("Step")
    25. plt.ylabel("Learning rate")
    26. plt.tight_layout();

     ​

      训练步骤的线性学习率调度

    我们模拟 100 个训练步骤，并告诉调度程序在前 20 个进行预热。学习率在预热期间增长到初始固定值 0.001，然后（线性）下降到 0。

    要使用调度程序，我们需要计算训练和热身步骤的数量。每个时期的训练步数等于number of training examples / batch size。总训练步数为training steps per epoch * number of epochs：

    1. steps_per_epoch=len(train_df) // BATCH_SIZE
    2. total_training_steps = steps_per_epoch * N_EPOCHS

    我们将使用五分之一的训练步骤进行热身： 

    1. warmup_steps = total_training_steps // 5
    2. warmup_steps, total_training_steps

    (5070, 25350)

    我们现在可以创建模型的实例：

    1. model = ToxicCommentTagger(
    2.   n_classes=len(LABEL_COLUMNS),
    3.   n_warmup_steps=warmup_steps,
    4.   n_training_steps=total_training_steps
    5. )

    评估

    多标签分类归结为对每个标签/标记进行二进制分类。

    我们将使用二进制交叉熵来衡量每个标签的错误。PyTorch 有BCELoss，我们将把它与一个 sigmoid 函数结合起来（就像我们在模型实现中所做的那样）。让我们看一个例子：

    1. criterion = nn.BCELoss()
    2.  
    3. prediction = torch.FloatTensor(
    4.   [10.95873564, 1.07321467, 1.58524066, 0.03839076, 15.72987556, 1.09513213]
    5. )
    6. labels = torch.FloatTensor(
    7.   [1., 0., 0., 0., 1., 0.]
    8. )
    9.  
    10. torch.sigmoid(prediction)

    tensor([1.0000, 0.7452, 0.8299, 0.5096, 1.0000, 0.7493])

    criterion(torch.sigmoid(prediction), labels)
    tensor(0.8725)

    我们可以使用相同的方法来计算预测的损失：

    1. _, predictions = model(sample_batch["input_ids"], sample_batch["attention_mask"])
    2. predictions
    tensor([[0.3963, 0.6318, 0.6543, 0.5179, 0.4099, 0.4998],
[0.4008, 0.6165, 0.6733, 0.5460, 0.4378, 0.5083],
[0.3877, 0.6185, 0.6830, 0.5238, 0.4326, 0.5138],
[0.3910, 0.6206, 0.6658, 0.5431, 0.4396, 0.5002],
[0.3792, 0.6241, 0.6508, 0.5347, 0.4374, 0.5110],
[0.4069, 0.6106, 0.7019, 0.5484, 0.4450, 0.4995],
[0.3861, 0.6135, 0.6867, 0.5179, 0.4525, 0.5188],
[0.3819, 0.6081, 0.6821, 0.5227, 0.4419, 0.5246]],
grad_fn=)
    criterion(predictions, sample_batch["labels"])

    tensor(0.8056, grad_fn=)

    ROC 曲线

    我们将要使用的另一个指标是每个标签的接受者操作特征 (ROC) 下的面积。ROC 是通过绘制真阳性率 (TPR) 与假阳性率 (FPR) 来创建的：

    TPR=TP/(TP+FN)

    FPR=FP/(FP+TN​)

    1. from sklearn import metrics
    2.  
    3. fpr = [0.        , 0.        , 0.        , 0.02857143, 0.02857143,
    4.        0.11428571, 0.11428571, 0.2       , 0.4       , 1.        ]
    5.  
    6. tpr = [0.        , 0.01265823, 0.67202532, 0.76202532, 0.91468354,
    7.        0.97468354, 0.98734177, 0.98734177, 1.        , 1.        ]
    8.  
    9. _, ax = plt.subplots()
    10. ax.plot(fpr, tpr, label="ROC")
    11. ax.plot([0.05, 0.95], [0.05, 0.95], transform=ax.transAxes, label="Random classifier", color="red")
    12. ax.legend(loc=4)
    13. ax.set_xlabel("False positive rate")
    14. ax.set_ylabel("True positive rate")
    15. ax.set_title("Example ROC curve")
    16. plt.show();

    ​

     训练分类器与随机分类器的示例 ROC 值

    训练

    PyTorch Lightning 的美妙之处在于您可以构建您喜欢的标准管道并训练（几乎？）您可能想象的每个模型。我更喜欢使用至少 3 个组件。

    保存最佳模型的检查点（基于验证损失）：

    1. checkpoint_callback = ModelCheckpoint(
    2.   dirpath="checkpoints",
    3.   filename="best-checkpoint",
    4.   save_top_k=1,
    5.   verbose=True,
    6.   monitor="val_loss",
    7.   mode="min"
    8. )

    在 TensorBoard 中记录进度：

    logger = TensorBoardLogger("lightning_logs", name="toxic-comments")

    当损失在过去 2 个时期内没有改善时会触发提前停止（在实际项目中进行训练时，您可能想删除/重新考虑这一点）：

    early_stopping_callback = EarlyStopping(monitor='val_loss', patience=2)

    我们可以开始训练过程：

    1. trainer = pl.Trainer(
    2.   logger=logger,
    3.   checkpoint_callback=checkpoint_callback,
    4.   callbacks=[early_stopping_callback],
    5.   max_epochs=N_EPOCHS,
    6.   gpus=1,
    7.   progress_bar_refresh_rate=30
    8. )
    GPU available: True, used: True
TPU available: False, using: 0 TPU cores
    trainer.fit(model, data_module)
    LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]
| Name | Type | Params
-----------------------------------------
| bert | BertModel | 108 M
| classifier | Linear | 4.6 K
| criterion | BCELoss | 0
-----------------------------------------
108 M Trainable params
0 Non-trainable params
108 M Total params
433.260 Total estimated model params size (MB)
Epoch 0, global step 2535: val_loss reached 0.05723 (best 0.05723), saving model to "/content/checkpoints/best-checkpoint.ckpt" as top 1

Epoch 1, global step 5071: val_loss reached 0.04705 (best 0.04705), saving model to "/content/checkpoints/best-checkpoint.ckpt" as top 1

Epoch 2, step 7607: val_loss was not in top 1

Epoch 3, step 10143: val_loss was not in top 1

    该模型改进了（仅）2 个时期。我们必须对其进行评估，看看它是否有任何好处。让我们仔细检查验证损失：

    trainer.test()

    LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]

    --------------------------------------------------------------------------------DATALOADER:0 TEST RESULTS
{'test_loss': 0.04704693332314491}
--------------------------------------------------------------------------------[{'test_loss': 0.04704693332314491}]

    预测

    我喜欢在训练完成后查看一小部分预测样本。这建立了关于预测质量的直觉（定性评估）。

    让我们加载模型的最佳版本（根据验证损失）：

    1. trained_model = ToxicCommentTagger.load_from_checkpoint(
    2.   trainer.checkpoint_callback.best_model_path,
    3.   n_classes=len(LABEL_COLUMNS)
    4. )
    5.  
    6. trained_model.eval()
    7. trained_model.freeze()

    我们将我们的模型置于“评估”模式，我们准备好做出一些预测。这是对示例（完全虚构的）评论的预测：

    1. test_comment = "Hi, I'm Meredith and I'm an alch... good at supplier relations"
    2.  
    3. encoding = tokenizer.encode_plus(
    4.   test_comment,
    5.   add_special_tokens=True,
    6.   max_length=512,
    7.   return_token_type_ids=False,
    8.   padding="max_length",
    9.   return_attention_mask=True,
    10.   return_tensors='pt',
    11. )
    12.  
    13. _, test_prediction = trained_model(encoding["input_ids"], encoding["attention_mask"])
    14. test_prediction = test_prediction.flatten().numpy()
    15.  
    16. for label, prediction in zip(LABEL_COLUMNS, test_prediction):
    17.   print(f"{label}: {prediction}")
    toxic: 0.02174694836139679
severe_toxic: 0.0013127995189279318
obscene: 0.0035953170154243708
threat: 0.0015959267038851976
insult: 0.003400973277166486
identity_hate: 0.003609051927924156

    看起来不错。这个很干净。我们将通过阈值 (0.5) 来减少预测的噪音。我们将只采用高于（或等于）阈值的标签预测。让我们尝试一些有毒的东西：

    1. THRESHOLD = 0.5
    2.  
    3. test_comment = "You are such a loser! You'll regret everything you've done to me!"
    4. encoding = tokenizer.encode_plus(
    5.   test_comment,
    6.   add_special_tokens=True,
    7.   max_length=512,
    8.   return_token_type_ids=False,
    9.   padding="max_length",
    10.   return_attention_mask=True,
    11.   return_tensors='pt',
    12. )
    13.  
    14. _, test_prediction = trained_model(encoding["input_ids"], encoding["attention_mask"])
    15. test_prediction = test_prediction.flatten().numpy()
    16.  
    17. for label, prediction in zip(LABEL_COLUMNS, test_prediction):
    18.   if prediction < THRESHOLD:
    19.     continue
    20.   print(f"{label}: {prediction}")
    toxic: 0.9569520354270935
insult: 0.7289626002311707

    我绝对同意这些标签。看起来我们的模型在这两个例子上做了一些合理的事情。

    评估

    让我们更全面地了解我们模型的性能。我们将从验证集中的所有预测和标签开始：

    1. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    2. trained_model = trained_model.to(device)
    3.  
    4. val_dataset = ToxicCommentsDataset(
    5.   val_df,
    6.   tokenizer,
    7.   max_token_len=MAX_TOKEN_COUNT
    8. )
    9.  
    10. predictions = []
    11. labels = []
    12.  
    13. for item in tqdm(val_dataset):
    14.   _, prediction = trained_model(
    15.     item["input_ids"].unsqueeze(dim=0).to(device),
    16.     item["attention_mask"].unsqueeze(dim=0).to(device)
    17.   )
    18.   predictions.append(prediction.flatten())
    19.   labels.append(item["labels"].int())
    20.  
    21. predictions = torch.stack(predictions).detach().cpu()
    22. labels = torch.stack(labels).detach().cpu()

     一个简单的指标是模型的准确性：

    accuracy(predictions, labels, threshold=THRESHOLD)

    tensor(0.9813) 

    这很好，但你应该对这个结果持保留态度。我们有一个非常不平衡的数据集。让我们检查每个标签的 ROC：

    1. print("AUROC per tag")
    2. for i, name in enumerate(LABEL_COLUMNS):
    3.   tag_auroc = auroc(predictions[:, i], labels[:, i], pos_label=1)
    4.   print(f"{name}: {tag_auroc}")
    AUROC per tag
toxic: 0.985722541809082
severe_toxic: 0.990084171295166
obscene: 0.995059609413147
threat: 0.9909615516662598
insult: 0.9884428977966309
identity_hate: 0.9890572428703308

    非常好的结果，但就在我们去聚会之前，让我们检查一下每个班级的分类报告。为了使这项工作有效，我们必须对预测应用阈值：

    1. y_pred = predictions.numpy()
    2. y_true = labels.numpy()
    3.  
    4. upper, lower = 1, 0
    5.  
    6. y_pred = np.where(y_pred > THRESHOLD, upper, lower)
    7.  
    8. print(classification_report(
    9.   y_true,
    10.   y_pred,
    11.   target_names=LABEL_COLUMNS,
    12.   zero_division=0
    13. ))
    1. precision    recall  f1-score   support
    2.             toxic       0.68      0.91      0.78       748
    3.      severe_toxic       0.53      0.30      0.38        80
    4.           obscene       0.79      0.87      0.83       421
    5.            threat       0.23      0.38      0.29        13
    6.            insult       0.79      0.70      0.74       410
    7.     identity_hate       0.59      0.62      0.60        71
    8.         micro avg       0.72      0.81      0.76      1743
    9.         macro avg       0.60      0.63      0.60      1743
    10.      weighted avg       0.72      0.81      0.75      1743
    11.       samples avg       0.08      0.08      0.08      1743

    这让我们对整体表现有了更真实的了解。该模型在标签上出错会导致少量示例。你能为这个做什么？

    概括

    干得好，你有一个模型可以判断（在某种程度上）文本是否有毒（以及什么样的）！微调现代预训练的 Transformer 模型使您能够在各种 NLP 任务上获得高精度，而计算能力和数据集很小。

    在本教程中，您将学习如何：

    • 将文本数据加载、平衡和拆分成集合
    • 标记文本（使用 BERT 标记器）并创建 PyTorch 数据集
    • 使用 PyTorch Lightning 微调 BERT 模型
    • 了解热身步骤并使用学习率调度程序
    • 在训练期间使用 ROC 下的面积和二元交叉熵来评估模型
    • 如何使用微调的 BERT 模型进行预测
    • 评估每个类的模型性能（可能的注释标记）

    你能提高模型的准确性吗？更好的参数或不同的学习率调度怎么样？在评论中让我知道。

    1.  
    2.
    1

  • 相关阅读:
    Java编码规范--OOP规约
    Javascript 基础知识学习
    LeetCode 3. 无重复字符的最长子串
    PostgreSql 数据库，根据库名称，查询这个库下面的所有表名称和这个表的注释
    Spring MVC入口Servlet原理简介说明(HttpServletBean,FrameworkServlet,DispatcherServlet)
    前端常用布局方式大全——细致讲解
    Oracle数据库修改序列，Oracle中的主键值和序列中的值对应不上时的处理方式
    如何使用Plex在Windows系统上搭建一个全能私人媒体影音站点
    香港的Web3从业者们 出走新加坡还是选择留下？
    Linux(常用命令)
  • 原文地址：https://blog.csdn.net/sikh_0529/article/details/127932503