Condivisione della tecnologia

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

Nell'odierno campo dell'elaborazione del linguaggio naturale (PNL), il riconoscimento delle emozioni è uno scenario applicativo molto importante. Sia nel servizio clienti intelligente, nell'analisi dei social media o nel campo dell'emotional computing, l'identificazione accurata delle emozioni degli utenti può migliorare notevolmente l'esperienza dell'utente e il livello di intelligenza del sistema. BERT (Bidirezionale Encoder Representations from Transformers), come potente modello linguistico pre-addestrato, ha dimostrato le sue eccellenti prestazioni in molteplici attività di PNL. In questo blog introdurremo in dettaglio come utilizzare il modello BERT per ottenere il riconoscimento delle emozioni conversazionali basato sul framework MindSpore. Aiutarti a padroneggiare questa tecnica con esempi di codice passo passo e spiegazioni dettagliate.

Introduzione del modello

BERT (Bidirection Encoder Representations from Transformers) è un modello di rappresentazione dell'encoder bidirezionale basato su Transformer. Cattura principalmente rappresentazioni a livello di parola e frase attraverso due attività di pre-formazione: Masked Language Model (MLM) e Next Sentence Prediction (NSP).

• Modello di linguaggio mascherato: maschera casualmente il 15% delle parole nel corpus e il modello deve prevedere queste parole mascherate.
• Previsione della frase successiva: Il modello deve prevedere se esiste una relazione sequenziale tra due frasi.

Dopo che BERT è stato pre-addestrato, può essere utilizzato per una serie di compiti a valle, come la classificazione del testo, il giudizio di somiglianza, la comprensione della lettura, ecc.

Preparazione del set di dati

Nella parte di preparazione del set di dati, abbiamo scaricato e decompresso il set di dati della chat del robot fornito dal team di Baidu Feipiao. Questo set di dati è stato preelaborato e contiene etichette emotive. Ogni riga di dati è costituita da un'etichetta e da un testo segmentato in parole. L'etichetta rappresenta la categoria dell'emozione (0 significa negativo, 1 significa neutro, 2 significa positivo) e il testo è il contenuto della conversazione dell'utente. Utilizzando questi dati strutturati, possiamo eseguire attività di classificazione del sentiment in modo più 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

Il formato del set di dati è il seguente:

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

Caricamento e preelaborazione dei dati

Il caricamento e la preelaborazione dei dati sono passaggi cruciali nel processo di apprendimento automatico.abbiamo usatoGeneratorDataset per caricare i dati e utilizzare le operazioni di mappatura per convertire il testo in un formato accettabile per il modello.Nello specifico, abbiamo utilizzatoBertTokenizer Tokenizza il testo in un ID vocabolario ed esegui un'operazione di pad. Lo scopo è garantire che la lunghezza di tutte le sequenze di input sia coerente, migliorando così l'efficienza dell'addestramento e le prestazioni del modello.

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

Costruzione di modelli

Nella parte di costruzione del modello abbiamo usatoBertForSequenceClassification per eseguire compiti di classificazione delle emozioni. Questo modello pre-addestrato è stato addestrato su corpora su larga scala e ha forti capacità di comprensione del linguaggio. Caricando pesi pre-addestrati, possiamo migliorare significativamente le prestazioni del modello nei compiti di classificazione delle emozioni. Allo stesso tempo, utilizziamo la tecnologia di precisione mista automatica, che non solo accelera il processo di formazione, ma riduce anche l'utilizzo della memoria video, ottenendo così una formazione più efficiente con risorse hardware limitate.

Gli ottimizzatori e le metriche di valutazione sono componenti importanti nell'addestramento del modello. Abbiamo scelto l'ottimizzatore Adam per le sue eccellenti prestazioni quando si tratta di dati su larga scala e modelli complessi. In termini di indicatori di valutazione, utilizziamo l’accuratezza per misurare le prestazioni del modello. Con queste impostazioni, possiamo garantire che il modello venga continuamente ottimizzato durante l'addestramento e raggiunga buone prestazioni sul set di convalida.

Le funzioni di callback svolgono un ruolo importante nel processo di training del modello. Impostiamo due funzioni di callback:CheckpointCallbackEBestModelCallback . Il primo serve per salvare periodicamente i pesi del modello, mentre il secondo carica automaticamente i pesi del modello più performante. Attraverso queste funzioni di callback, garantiamo che parametri importanti del modello non vengano persi durante l'addestramento e che per l'inferenza e la valutazione venga sempre utilizzato il modello con le migliori prestazioni.

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

Convalida del modello

Nella sezione di convalida del modello, utilizziamo il set di dati di convalida per valutare le prestazioni del modello. Calcolando l'accuratezza del modello sul set di validazione, possiamo comprendere la capacità di generalizzazione e l'effetto reale del modello. Questo passaggio è molto importante perché può aiutarci a scoprire possibili problemi nel processo di addestramento del modello e ad apportare le modifiche e le ottimizzazioni corrispondenti.

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

Ragionamento modello

La sezione sull'inferenza del modello mostra come utilizzare il modello addestrato per eseguire la classificazione del sentiment sui nuovi dati.Abbiamo definito apredict Funzione che esegue la previsione delle emozioni inserendo testo e restituisce i risultati della previsione. Questo passaggio dimostra le capacità di applicazione pratica del modello e verifica le prestazioni di generalizzazione del modello.

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

Dati di inferenza personalizzati

Infine, mostriamo come utilizzare il modello per il riconoscimento delle emozioni su input personalizzati. Questo passaggio non solo dimostra le capacità applicative pratiche del modello, ma verifica anche le prestazioni del modello con diversi input. In questo modo, possiamo comprendere ulteriormente la capacità di generalizzazione e l’effetto reale del modello.

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