Partage de technologie

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

Dans le domaine actuel du traitement du langage naturel (NLP), la reconnaissance des émotions constitue un scénario d’application très important. Que ce soit dans le domaine du service client intelligent, de l'analyse des réseaux sociaux ou dans le domaine de l'informatique émotionnelle, l'identification précise des émotions des utilisateurs peut grandement améliorer l'expérience utilisateur et le niveau d'intelligence du système. BERT (Bidirectionnel Encoder Representations from Transformers), en tant que puissant modèle de langage pré-entraîné, a démontré ses excellentes performances dans plusieurs tâches PNL. Dans ce blog, nous présenterons en détail comment utiliser le modèle BERT pour obtenir une reconnaissance des émotions conversationnelles basée sur le framework MindSpore. Aidez-vous à maîtriser cette technique avec des exemples de code étape par étape et des explications détaillées.

Présentation du modèle

BERT (Bidirectionnel Encoder Representations from Transformers) est un modèle de représentation d'encodeur bidirectionnel basé sur un transformateur. Il capture principalement les représentations au niveau des mots et des phrases à travers deux tâches de pré-formation : le modèle de langage masqué (MLM) et la prédiction de la phrase suivante (NSP).

• Modèle de langage masqué: Masquez aléatoirement 15 % des mots du corpus, et le modèle doit prédire ces mots masqués.
• Prédiction de la phrase suivante: Le modèle doit prédire s'il existe une relation séquentielle entre deux phrases.

Une fois que BERT est pré-entraîné, il peut être utilisé pour diverses tâches en aval, telles que la classification de textes, le jugement de similarité, la compréhension écrite, etc.

Préparation du jeu de données

Dans la partie préparation de l'ensemble de données, nous avons téléchargé et décompressé l'ensemble de données de chat robot fourni par l'équipe Baidu Feipiao. Cet ensemble de données a été prétraité et contient des étiquettes d'émotion. Chaque ligne de données se compose d'une étiquette et d'un texte segmenté en mots. L'étiquette représente la catégorie d'émotion (0 signifie négatif, 1 signifie neutre, 2 signifie positif) et le texte est le contenu de la conversation de l'utilisateur. En utilisant ces données structurées, nous pouvons effectuer plus facilement les tâches de classification des sentiments.

# 下载数据集
!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

Le format de l'ensemble de données est le suivant :

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

Chargement et prétraitement des données

Le chargement et le prétraitement des données sont des étapes cruciales du processus d’apprentissage automatique.Nous avons utiliséGeneratorDataset pour charger les données et utiliser des opérations de mappage pour convertir le texte dans un format acceptable pour le modèle.Plus précisément, nous avons utiliséBertTokenizer Tokenisez le texte dans un identifiant de vocabulaire et effectuez une opération de pad. Le but est de garantir que la longueur de toutes les séquences d'entrée est cohérente, améliorant ainsi l'efficacité de la formation et les performances du modèle.

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

Construction de maquettes

Dans la partie construction du modèle, nous avons utiliséBertForSequenceClassification pour effectuer des tâches de classification des émotions. Ce modèle pré-entraîné a été formé sur des corpus à grande échelle et possède de fortes capacités de compréhension linguistique. En chargeant des poids pré-entraînés, nous pouvons améliorer considérablement les performances du modèle sur les tâches de classification des émotions. Dans le même temps, nous utilisons une technologie de précision mixte automatique, qui non seulement accélère le processus de formation, mais réduit également l'utilisation de la mémoire vidéo, permettant ainsi une formation plus efficace avec des ressources matérielles limitées.

Les optimiseurs et les mesures d'évaluation sont des composants importants dans la formation des modèles. Nous avons choisi l'optimiseur Adam en raison de ses excellentes performances lorsqu'il s'agit de données à grande échelle et de modèles complexes. En termes d'indicateurs d'évaluation, nous utilisons l'exactitude pour mesurer la performance du modèle. Avec ces paramètres, nous pouvons garantir que le modèle est continuellement optimisé pendant la formation et obtient de bonnes performances sur l'ensemble de validation.

Les fonctions de rappel jouent un rôle important dans le processus de formation du modèle. Nous avons mis en place deux fonctions de rappel :CheckpointCallbacketBestModelCallback . Le premier permet de sauvegarder régulièrement les poids du modèle, tandis que le second charge automatiquement les poids du modèle le plus performant. Grâce à ces fonctions de rappel, nous garantissons que les paramètres importants du modèle ne sont pas perdus pendant la formation et que le modèle le plus performant est toujours utilisé pour l'inférence et l'évaluation.

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

Validation du modèle

Dans la section validation du modèle, nous utilisons l'ensemble de données de validation pour évaluer les performances du modèle. En calculant la précision du modèle sur l'ensemble de validation, nous pouvons comprendre la capacité de généralisation et l'effet réel du modèle. Cette étape est très importante car elle peut nous aider à découvrir d'éventuels problèmes dans le processus de formation du modèle et à effectuer les ajustements et optimisations correspondants.

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

Raisonnement du modèle

La section d'inférence de modèle montre comment utiliser le modèle entraîné pour effectuer une classification des sentiments sur de nouvelles données.Nous avons défini unpredict Fonction qui effectue une prédiction des émotions en saisissant du texte et génère des résultats de prédiction. Cette étape démontre les capacités d'application pratique du modèle et vérifie les performances de généralisation du modèle.

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

Données d'inférence personnalisées

Enfin, nous montrons comment utiliser le modèle pour la reconnaissance des émotions sur une saisie personnalisée. Cette étape démontre non seulement les capacités d'application pratique du modèle, mais vérifie également les performances du modèle sous différentes entrées. De cette façon, nous pouvons mieux comprendre la capacité de généralisation et l’effet réel du modèle.

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