NLP发展到现在，一些旧的方法了解即可，早就过时了，导图上打删除线了。当然了，一些小的场景还可能使用到的。

导图

NLP.png

Transformer安装环境

3080，安装Python=3.9，然后如下，更高版本老是出错。

conda install pytorch==1.12.0 torchvision==0.13.0 torchaudio==0.12.0 cudatoolkit=11.6
conda install -c huggingface transformers # -c代表源
pip install datasets # 这么好的包名被抢用了啊
pip install evaluate
pip install scikit-learn # 不是sklearn

感觉transformers是个集大成的傻瓜神器。

极简情感二分类

用到的库：

from transformers import (AutoModel,
                          AutoModelForSequenceClassification,
                          AutoTokenizer,
                          Trainer,
                          TrainingArguments,
                          EvalPrediction)
import evaluate
from datasets import load_dataset, load_from_disk

import torch
from torch import nn
from torch.utils.data import Dataset, DataLoader

分词，也叫符号化，准备数据，会直接到huggingface网下载，可能需要科学上网：

pt_name = 'bert-base-chinese' # 中文用这个多一些
tokenizer = AutoTokenizer.from_pretrained(pt_name)

original_ds = load_dataset('seamew/ChnSentiCorp')

def f(data):
    return tokenizer(text=data['text'],
                    padding='max_length',
                    truncation=True,
                    max_length=300,
                    return_tensors='pt',)
ds = original_ds.map(f, batched=True, batch_size=16, remove_columns=['text'])
train_dataset = ds['train'].shuffle()
validation_dataset = ds['validation'].shuffle()
test_dataset = ds['test']

上面也可以用Pytorch常用的继承Dataset的方式。接下来看模型，因为是个二分类任务，很方便：

model = AutoModelForSequenceClassification.from_pretrained(pt_name, num_labels=2)

accuracy = evaluate.load('accuracy') # 以前的load_metric降被停用
def compute_metrics(eval_pred):
    logits, labels = eval_pred
    logits = logits.argmax(axis=1) # axis, not dim
    return accuracy.compute(predictions=logits, references=labels)
# 测试下评估函数
eval_pred = EvalPrediction(predictions=torch.tensor([[0,1], [2,3]]),
                          label_ids=torch.tensor([1,1]))
compute_metrics(eval_pred)

准备训练器，这个集成封装得太漂亮了。

args = TrainingArguments(output_dir='./output_dir',
                        evaluation_strategy='epoch',
                        num_train_epochs=1,
                        learning_rate=1e-4,
                        weight_decay=1e-2,
                        per_device_eval_batch_size=32,
                        per_device_train_batch_size=16)
trainer = Trainer(model=model,
                 args=args,
                 train_dataset=train_dataset,
                 eval_dataset=validation_dataset,
                 compute_metrics=compute_metrics)
trainer.evaluate() # 看看随机初始化的推理，应该是55开

开始训练，直接能给出各种结果，而且自动调用GPU了。

trainer.train() # torch.optim.AdamW
trainer.save_model(output_dir='./output_dir/manual')

最后，推理测试，用之前准备的测试集。如果只是看看指标，可以：

trainer.evaluate(eval_dataset=test_dataset)

但是想得到详细的推理结果，这里使用Pytorch的DataLoader来准备，可能有更方便的方法，待研究。

model.eval()

def try_gpu(i=0): # 来自limu
    if torch.cuda.device_count() >= i+1:
        return torch.device(f'cuda:{i}')
    return torch.device('cpu')
device = try_gpu()

def collate_fn(data):
    label = [i['label'] for i in data]
    input_ids = [i['input_ids'] for i in data]
    token_type_ids = [i['token_type_ids'] for i in data]
    attention_mask = [i['attention_mask'] for i in data]

    # 得到的是List, 转成Tensor
    label = torch.LongTensor(label)
    input_ids = torch.LongTensor(input_ids)
    token_type_ids = torch.LongTensor(token_type_ids)
    attention_mask = torch.LongTensor(attention_mask)
    
    return label, input_ids, token_type_ids, attention_mask

test_loader = DataLoader(dataset=test_dataset,
                         collate_fn=collate_fn,
                         batch_size=16)

correct, total = 0, 0
for i, (label, input_ids, token_type_ids, attention_mask) in enumerate(test_loader):
    label = label.to(device)
    input_ids = input_ids.to(device)
    token_type_ids = token_type_ids.to(device)
    attention_mask = attention_mask.to(device)
    
    out = model(input_ids=input_ids, token_type_ids=token_type_ids, attention_mask=attention_mask)
    out = out.logits.argmax(axis=1)
    correct += (out==label).sum().item()
    total += len(label)
    acc = correct / total
    print(f'{acc:.3f}')

如果只是简单看看几句话，没必要大动干戈。

sentences = ['这家的菜做得不行。', '房间挺干净的，也没有噪声']
token_out = tokenizer(sentences,
                padding=True,
                truncation=True,
                return_tensors='pt')
token_out.to(device)
out = model(**token_out)
out = out.logits.argmax(axis=1)
for i, s in enumerate(sentences):
    print(s, out[i].item())

就先这么着。