Compartir tecnología

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

En el campo actual del procesamiento del lenguaje natural (PNL), el reconocimiento de emociones es un escenario de aplicación muy importante. Ya sea en el campo del servicio al cliente inteligente, el análisis de redes sociales o la informática emocional, la identificación precisa de las emociones de los usuarios puede mejorar en gran medida la experiencia del usuario y el nivel de inteligencia del sistema. BERT (Representaciones de codificador bidireccional de Transformers), como un poderoso modelo de lenguaje previamente entrenado, ha demostrado su excelente desempeño en múltiples tareas de PNL. En este blog, presentaremos en detalle cómo utilizar el modelo BERT para lograr el reconocimiento de emociones conversacionales basado en el marco MindSpore. Le ayudaremos a dominar esta técnica con ejemplos de código paso a paso y explicaciones detalladas.

Introducción del modelo

BERT (Representaciones de codificador bidireccional de Transformers) es un modelo de representación de codificador bidireccional basado en transformador. Capta principalmente representaciones a nivel de palabras y oraciones a través de dos tareas previas al entrenamiento: modelo de lenguaje enmascarado (MLM) y predicción de la siguiente oración (NSP).

• Modelo de lenguaje enmascarado: Enmascara aleatoriamente el 15% de las palabras del corpus y el modelo necesita predecir estas palabras enmascaradas.
• Predicción de la siguiente oración: El modelo necesita predecir si existe una relación secuencial entre dos oraciones.

Una vez que BERT esté previamente entrenado, se puede utilizar para una variedad de tareas posteriores, como clasificación de texto, juicio de similitud, comprensión lectora, etc.

Preparación del conjunto de datos

En la parte de preparación del conjunto de datos, descargamos y descomprimimos el conjunto de datos del chat del robot proporcionado por el equipo de Baidu Feipiao. Este conjunto de datos ha sido preprocesado y contiene etiquetas de emociones. Cada fila de datos consta de una etiqueta y un texto segmentado por palabras. La etiqueta representa la categoría de emoción (0 significa negativa, 1 significa neutral, 2 significa positiva) y el texto es el contenido de la conversación del usuario. Al utilizar estos datos estructurados, podemos realizar tareas de clasificación de sentimientos de manera más conveniente.

# 下载数据集
!wget https://baidu-nlp.bj.bcebos.com/emotion_detection-dataset-1.0.0.tar.gz -O emotion_detection.tar.gz
!tar xvf emotion_detection.tar.gz
1
2
3

El formato del conjunto de datos es el siguiente:

label--text_a
0--谁骂人了？我从来不骂人，我骂的都不是人，你是人吗 ？
1--我有事等会儿就回来和你聊
2--我见到你很高兴谢谢你帮我
1
2
3
4

Carga y preprocesamiento de datos.

La carga y el preprocesamiento de datos son pasos cruciales en el proceso de aprendizaje automático.nosotros usamosGeneratorDataset para cargar los datos y utilizar operaciones de mapeo para convertir el texto a un formato aceptable para el modelo.Específicamente, utilizamosBertTokenizer Tokenice el texto en una ID de vocabulario y realice una operación de teclado. El propósito de esto es garantizar que la longitud de todas las secuencias de entrada sea consistente, mejorando así la eficiencia del entrenamiento y el rendimiento del modelo.

import numpy as np
from mindspore.dataset import text, GeneratorDataset, transforms
from mindnlp.transformers import BertTokenizer

def process_dataset(source, tokenizer, max_seq_len=64, batch_size=32, shuffle=True):
    is_ascend = mindspore.get_context('device_target') == 'Ascend'
    column_names = ["label", "text_a"]
    
    dataset = GeneratorDataset(source, column_names=column_names, shuffle=shuffle)
    type_cast_op = transforms.TypeCast(mindspore.int32)
    
    def tokenize_and_pad(text):
        if is_ascend:
            tokenized = tokenizer(text, padding='max_length', truncation=True, max_length=max_seq_len)
        else:
            tokenized = tokenizer(text)
        return tokenized['input_ids'], tokenized['attention_mask']
    
    dataset = dataset.map(operations=tokenize_and_pad, input_columns="text_a", output_columns=['input_ids', 'attention_mask'])
    dataset = dataset.map(operations=[type_cast_op], input_columns="label", output_columns='labels')
    
    if is_ascend:
        dataset = dataset.batch(batch_size)
    else:
        dataset = dataset.padded_batch(batch_size, pad_info={'input_ids': (None, tokenizer.pad_token_id), 'attention_mask': (None, 0)})

    return dataset

tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')
dataset_train = process_dataset(SentimentDataset("data/train.tsv"), tokenizer)
dataset_val = process_dataset(SentimentDataset("data/dev.tsv"), tokenizer)
dataset_test = process_dataset(SentimentDataset("data/test.tsv"), tokenizer, shuffle=False)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

Construcción del modelo

En la parte de construcción del modelo utilizamosBertForSequenceClassification para realizar tareas de clasificación de emociones. Este modelo previamente entrenado se ha entrenado en corpus a gran escala y tiene sólidas capacidades de comprensión del lenguaje. Al cargar pesos previamente entrenados, podemos mejorar significativamente el rendimiento del modelo en tareas de clasificación de emociones. Al mismo tiempo, utilizamos tecnología de precisión de mezcla automática, que no solo acelera el proceso de capacitación, sino que también reduce el uso de la memoria de video, logrando así una capacitación más eficiente con recursos de hardware limitados.

Los optimizadores y las métricas de evaluación son componentes importantes en el entrenamiento de modelos. Elegimos el optimizador Adam por su excelente rendimiento al tratar con datos a gran escala y modelos complejos. En términos de indicadores de evaluación, utilizamos la precisión para medir el desempeño del modelo. Con estas configuraciones, podemos asegurarnos de que el modelo se optimice continuamente durante el entrenamiento y logre un buen rendimiento en el conjunto de validación.

Las funciones de devolución de llamada juegan un papel importante en el proceso de formación del modelo. Configuramos dos funciones de devolución de llamada:CheckpointCallbackyBestModelCallback . El primero se utiliza para guardar periódicamente los pesos del modelo, mientras que el segundo carga automáticamente los pesos del modelo con mejor rendimiento. A través de estas funciones de devolución de llamada, garantizamos que los parámetros importantes del modelo no se pierdan durante el entrenamiento y que siempre se utilice el modelo con mejor rendimiento para la inferencia y la evaluación.

from mindnlp.transformers import BertForSequenceClassification
from mindspore import nn
from mindnlp._legacy.amp import auto_mixed_precision

model = BertForSequenceClassification.from_pretrained('bert-base-chinese', num_labels=3)
model = auto_mixed_precision(model, 'O1')

optimizer = nn.Adam(model.trainable_params(), learning_rate=2e-5)
metric = Accuracy()
ckpoint_cb = CheckpointCallback(save_path='checkpoint', ckpt_name='bert_emotect', epochs=1, keep_checkpoint_max=2)
best_model_cb = BestModelCallback(save_path='checkpoint', ckpt_name='bert_emotect_best', auto_load=True)

trainer = Trainer(network=model, train_dataset=dataset_train,
                  eval_dataset=dataset_val, metrics=metric,
                  epochs=5, optimizer=optimizer, callbacks=[ckpoint_cb, best_model_cb])
trainer.run(tgt_columns="labels")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Modelo de validación

En la sección de validación del modelo, utilizamos el conjunto de datos de validación para evaluar el rendimiento del modelo. Al calcular la precisión del modelo en el conjunto de validación, podemos comprender la capacidad de generalización y el efecto real del modelo. Este paso es muy importante porque puede ayudarnos a descubrir posibles problemas en el proceso de entrenamiento del modelo y realizar los ajustes y optimizaciones correspondientes.

evaluator = Evaluator(network=model, eval_dataset=dataset_test, metrics=metric)
evaluator.run(tgt_columns="labels")
1
2

Razonamiento modelo

La sección de inferencia del modelo muestra cómo utilizar el modelo entrenado para realizar una clasificación de sentimientos en datos nuevos.Definimos unpredict Función que realiza predicción de emociones ingresando texto y genera resultados de predicción. Este paso demuestra las capacidades de aplicación práctica del modelo y verifica el rendimiento de generalización del modelo.

dataset_infer = SentimentDataset("data/infer.tsv")

def predict(text, label=None):
    label_map = {0: "消极", 1: "中性", 2: "积极"}
    text_tokenized = Tensor([tokenizer(text).input_ids])
    logits = model(text_tokenized)
    predict_label = logits[0].asnumpy().argmax()
    info = f"inputs: '{text}', predict: '{label_map[predict_label]}'"
    if label is not None:
        info += f" , label: '{label_map[label]}'"
    print(info)

for label, text in dataset_infer:
    predict(text, label)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Datos de inferencia personalizados

Finalmente, mostramos cómo utilizar el modelo para el reconocimiento de emociones en entradas personalizadas. Este paso no solo demuestra las capacidades de aplicación práctica del modelo, sino que también verifica el rendimiento del modelo bajo diferentes entradas. De esta manera, podemos comprender mejor la capacidad de generalización y el efecto real del modelo.

predict("家人们咱就是说一整个无语住了 绝绝子叠buff")
1