基于Transformer怎么实现电影评论星级分类任务

开发技术作者：iii 2024-05-08 01:40:01

这篇文章主要讲解了“基于Transformer怎么实现电影评论星级分类任务”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来�...

这篇文章主要讲解了“基于Transformer怎么实现电影评论星级分类任务”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“基于Transformer怎么实现电影评论星级分类任务”吧！

Transformer模型概述

Transformer是一种用于序列到序列学习的神经网络架构，专门用于处理输入和输出序列之间的依赖关系。该模型被广泛应用于机器翻译、音频转录、语言生成等多个自然语言处理领域。

Transformer基于attention机制来实现序列到序列的学习。在RNN（循环神经网络）中，网络必须按顺序遍历每个单词，并在每个时间步计算隐层表示。这样，在长段文本中，信息可能会从网络的起点传递到终点，这导致了难以捕捉远距离依赖关系的问题。而attention机制可以根据输入序列中的词与其它所有词的相关性分配不同的权重，从而突破了序列到序列中的局限。

具体来说，一个Transformer模型由编码器（encoder）和解码器（decoder）两部分组成。编码器用于接收输入序列，解码器用于生成输出序列。每个编码器和解码器均包含多头attention机制、前馈网络以及残差连接等组件。

在一个典型的Transformer模型中，首先将输入序列通过嵌入层进行向量化，然后将向量表示作为Transformer的第一层输入。处理完输入向量之后，下一层就是多头attention层，其中每个头（head）都可以计算出不同的注意力权重向量（也称为attention mask）。最后，利用残差连接和skip connection机制使transformer更易于训练。

数据集准备

在此任务中，我们将使用来自IMDB的电影评论数据集，该数据集包含50,000条有标签的电影评论，每个评论标记为正面或负面情感。其中25,000个用于训练，另外25,000个用于测试。

由于Transformer是对token进行操作，所以我们需要对文本的每个单词进行编码。一种常用的方法是使用Bert Tokenizer。GPT-2等预训练模型会使用特定的tokenizer。选择最新版本的transformers包可以快速实现这些操作：

!pip install transformers

接着加载tokenizer：

from transformers import BertTokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

上述操作将下载并加载适用于bert的tokenizer。下一步是读取IMDB数据集的内容。在本文中，我们将使用此处的已处理好的CSV形式数据：drive.google.com/file/d/1b_b…

import pandas as pd
train_df = pd.read_csv('imdb_train.csv')
test_df = pd.read_csv('imdb_test.csv')

由于Transformer模型需要固定长度的输入序列，我们选择了max_length为100并对所有评论进行padding操作：

train_inputs = tokenizer(list(train_df['review']), padding=True, truncation=True, max_length=100)
test_inputs = tokenizer(list(test_df['review']), padding=True, truncation=True, max_length=100)

现在我们可以将输入和标签分别转换成torch Tensor类型：

import torch
train_labels = torch.tensor(list(train_df['sentiment'].replace({'pos': 1, 'neg':0})))
test_labels = torch.tensor(list(test_df['sentiment'].replace({'pos': 1, 'neg':0})))

train_encoded_dict = {
    'input_ids': torch.tensor(train_inputs['input_ids']),
    'token_type_ids': torch.tensor(train_inputs['token_type_ids']),
    'attention_mask': torch.tensor(train_inputs['attention_mask']),
    'labels': train_labels
}

test_encoded_dict = {
    'input_ids': torch.tensor(test_inputs['input_ids']),
    'token_type_ids': torch.tensor(test_inputs['token_type_ids']),
    'attention_mask': torch.tensor(test_inputs['attention_mask']),
    'labels': test_labels
}

模型训练

在此任务中，我们将使用PyTorch库实现Transformer模型。 PyTorch是一种基于Python的科学计算包，其灵活性和易用性使其成为深度学习领域最常用的库之一。

可以使用Hugging Face的Transformers实现预先训练好的BERT模型：

from transformers import BertForSequenceClassification, AdamW, BertConfig
model = BertForSequenceClassification.from_pretrained(
    "bert-base-uncased",
    num_labels = 2,
    output_attentions = False,
    output_hidden_states = False,
)

然后，我们需要定义优化器、损失函数和批大小等训练超参数：

optimizer = AdamW(model.parameters(), lr = 2e-5, eps = 1e-8)

from torch.utils.data import DataLoader, RandomSampler, SequentialSampler
batch_size = 32
train_dataloader = DataLoader(train_encoded_dict, sampler = RandomSampler(train_encoded_dict), batch_size = batch_size)
test_dataloader = DataLoader(test_encoded_dict, sampler = SequentialSampler(test_encoded_dict), batch_size = batch_size)

from transformers import get_linear_schedule_with_warmup
epochs = 4
total_steps = len(train_dataloader) * epochs
scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps = 0, num_training_steps = total_steps)
loss_fn = torch.nn.CrossEntropyLoss()

最后，我们可以定义模型的训练过程，并进行模型训练：

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

total_train_loss = 0
for epoch_i in range(epochs):
    print(f"{'':^5}Epoch:{epoch_i + 1:^3}")
    for step, batch in enumerate(train_dataloader):
        b_input_ids = batch['input_ids'].to(device)
        b_token_type_ids = batch['token_type_ids'].to(device)
        b_attention_mask = batch['attention_mask'].to(device)
        b_labels = batch['labels'].to(device)

        model.zero_grad()

        outputs = model(b_input_ids,
                        token_type_ids=b_token_type_ids, 
                        attention_mask=b_attention_mask, 
                        labels=b_labels)
        
        loss = outputs.loss
        total_train_loss += loss.item()
    
        loss.backward()

        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)

        optimizer.step()

        scheduler.step()

    avg_train_loss = total_train_loss / len(train_dataloader)            
    print("   Average training loss: {avg_train_loss:.2f}")

def evaluate(model, test_dataloader):
    model.eval()

    total_eval_accuracy = 0
    total_eval_loss = 0
    nb_eval_steps = 0

    for batch in test_dataloader:
        b_input_ids = batch['input_ids'].to(device)
        b_token_type_ids = batch['token_type_ids'].to(device)
        b_attention_mask = batch['attention_mask'].to(device)
        b_labels = batch['labels'].to(device)

        with torch.no_grad():       
            outputs = model(b_input_ids, 
                            token_type_ids=b_token_type_ids, 
                            attention_mask=b_attention_mask,
                            labels=b_labels)
        loss = outputs.loss
        logits = outputs.logits

        total_eval_loss += loss.item()
        logits = logits.detach().cpu().numpy()
        label_ids = b_labels.to('cpu').numpy()
        total_eval_accuracy += flat_accuracy(logits, label_ids)

    avg_val_accuracy = total_eval_accuracy / len(test_dataloader)
    avg_val_loss = total_eval_loss / len(test_dataloader)

    return avg_val_accuracy, avg_val_loss

accuracy, val_loss = evaluate(model, test_dataloader)
print(f'Accuracy: {accuracy:.2f}%')

训练结束后，我们可以使用测试集对模型进行评估。TensorFlow提供了非常好的评估函数可以在别人的工程稍微改下直接拿来用：

from sklearn.metrics import accuracy_score
def flat_accuracy(preds, labels):
    pred_flat = np.argmax(preds, axis=1).flatten()
    labels_flat = labels.flatten()
    return accuracy_score(labels_flat, pred_flat)