PaddleNLP之淘宝商品评论情感分析

!pip install --upgrade paddlenlp

# 解压缩# !unzip data/data94812/中文淘宝评论数据集.zip

!head -n9 train.txt

def read(data_path):
    data=['label'+'\t'+'text_a\n']    with open(data_path, 'r', encoding='utf-8-sig') as f:
        lines=f.readlines()        # 三行为一条记录
        for i in range(int(len(lines)/3)):            # 读取第一行为内容
            word = lines[i*3].strip('\n') 
            # 读取第三行为标签
            label = lines[i*3+2].strip('\n')
            data.append(label+'\t'+word+'\n')
            i=i+1 
    return data  
with open('formated_train.txt','w') as f:
    f.writelines(read('train.txt'))with open('formated_test.txt','w') as f:
    f.writelines(read('test.txt'))

!head formated_train.txt

!head formated_test.txt

from paddlenlp.datasets import load_datasetdef read(data_path):
    with open(data_path, 'r', encoding='utf-8') as f:        # 跳过列名
        next(f)        for line in f:
            label,  word= line.strip('\n').split('\t')            yield {'text': word, 'label': label}# data_path为read()方法的参数train_ds = load_dataset(read, data_path='formated_train.txt',lazy=False)
test_ds = load_dataset(read, data_path='formated_test.txt',lazy=False)
dev_ds = load_dataset(read, data_path='formated_test.txt',lazy=False)

print(len(train_ds))print(train_ds.label_list)for idx in range(10):    print(train_ds[idx])

import paddlenlp as ppnlp# 设置想要使用模型的名称MODEL_NAME = "ernie-1.0"ernie_model  = ppnlp.transformers.ErnieModel.from_pretrained(MODEL_NAME)
model = ppnlp.transformers.ErnieForSequenceClassification.from_pretrained(MODEL_NAME, num_classes=3)

tokenizer = ppnlp.transformers.ErnieTokenizer.from_pretrained(MODEL_NAME)

from functools import partialfrom paddlenlp.data import Stack, Tuple, Padfrom utils import  convert_example, create_dataloader# 模型运行批处理大小batch_size = 200max_seq_length = 128trans_func = partial(
    convert_example,
    tokenizer=tokenizer,
    max_seq_length=max_seq_length)
batchify_fn = lambda samples, fn=Tuple(
    Pad(axis=0, pad_val=tokenizer.pad_token_id),  # input
    Pad(axis=0, pad_val=tokenizer.pad_token_type_id),  # segment
    Stack(dtype="int64")  # label): [data for data in fn(samples)]
train_data_loader = create_dataloader(
    train_ds,
    mode='train',
    batch_size=batch_size,
    batchify_fn=batchify_fn,
    trans_fn=trans_func)
dev_data_loader = create_dataloader(
    dev_ds,
    mode='dev',
    batch_size=batch_size,
    batchify_fn=batchify_fn,
    trans_fn=trans_func)

from paddlenlp.transformers import LinearDecayWithWarmupimport paddle# 训练过程中的最大学习率learning_rate = 5e-5 # 训练轮次epochs = 5 #3# 学习率预热比例warmup_proportion = 0.1# 权重衰减系数，类似模型正则项策略，避免模型过拟合weight_decay = 0.01num_training_steps = len(train_data_loader) * epochs
lr_scheduler = LinearDecayWithWarmup(learning_rate, num_training_steps, warmup_proportion)
optimizer = paddle.optimizer.AdamW(
    learning_rate=lr_scheduler,
    parameters=model.parameters(),
    weight_decay=weight_decay,
    apply_decay_param_fun=lambda x: x in [
        p.name for n, p in model.named_parameters()        if not any(nd in n for nd in ["bias", "norm"])
    ])

criterion = paddle.nn.loss.CrossEntropyLoss()
metric = paddle.metric.Accuracy()

# checkpoint文件夹用于保存训练模型!mkdir /home/aistudio/checkpoint

import paddle.nn.functional as Ffrom utils import evaluate

global_step = 0for epoch in range(1, epochs + 1):    for step, batch in enumerate(train_data_loader, start=1):
        input_ids, segment_ids, labels = batch
        logits = model(input_ids, segment_ids)
        loss = criterion(logits, labels)
        probs = F.softmax(logits, axis=1)
        correct = metric.compute(probs, labels)
        metric.update(correct)
        acc = metric.accumulate()

        global_step += 1
        if global_step % 10 == 0 :            print("global step %d, epoch: %d, batch: %d, loss: %.5f, acc: %.5f" % (global_step, epoch, step, loss, acc))
        loss.backward()
        optimizer.step()
        lr_scheduler.step()
        optimizer.clear_grad()
    evaluate(model, criterion, metric, dev_data_loader)

global step 270, epoch: 5, batch: 2, loss: 0.43869, acc: 0.80500global step 280, epoch: 5, batch: 12, loss: 0.41893, acc: 0.80792global step 290, epoch: 5, batch: 22, loss: 0.44744, acc: 0.80523global step 300, epoch: 5, batch: 32, loss: 0.38977, acc: 0.80797global step 310, epoch: 5, batch: 42, loss: 0.39923, acc: 0.80774global step 320, epoch: 5, batch: 52, loss: 0.36724, acc: 0.81029global step 330, epoch: 5, batch: 62, loss: 0.40811, acc: 0.81008eval loss: 0.51191, accu: 0.74444

from utils import predict

data = [
    {"text":'这个宾馆比较陈旧了，特价的房间也很一般。总体来说一般'},
    {"text":'怀着十分激动的心情放映，可是看着看着发现，在放映完毕后，出现一集米老鼠的动画片'},
    {"text":'作为老的四星酒店，房间依然很整洁，相当不错。机场接机服务很好，可以在车上办理入住手续，节省时间。'},
]
label_map = {0: 'negative', 1: 'neutral', 2: 'positive'}

results = predict(
    model, data, tokenizer, label_map, batch_size=batch_size)for idx, text in enumerate(data):    print('Data: {} \t Lable: {}'.format(text, results[idx]))