Quelles sont les méthodes d'utilisation du modèle BERT pour la classification des sentiments ?

BERT est une technologie de traitement du langage naturel, qui peut être largement utilisée dans diverses tâches, notamment la classification des sentiments. La classification des sentiments est une forme spéciale de classification de texte dont le but est de déterminer le sentiment exprimé par un texte, tel que positif, négatif ou neutre. Le modèle BERT est basé sur l'architecture Transformer et utilise une grande quantité de données texte non étiquetées pour la pré-formation afin d'améliorer les performances du modèle. Grâce à la pré-formation, BERT peut acquérir de riches connaissances linguistiques, notamment le vocabulaire, la syntaxe et la sémantique, etc., permettant au modèle d'obtenir de bonnes performances sur diverses tâches. Par conséquent, BERT est devenu un outil important dans le domaine du traitement du langage naturel, fournissant un support puissant pour des tâches telles que la classification des sentiments.

Le processus de pré-formation du modèle BERT peut être divisé en deux étapes : le modèle de langage masqué et la prédiction de la phrase suivante. À l'étape du modèle de langage masqué, le modèle BERT sélectionne de manière aléatoire certains mots du texte saisi et les remplace par des balises spéciales [MASK]. Le but du modèle est de prédire ces mots obscurcis. Grâce à ce processus, le modèle BERT peut apprendre les relations contextuelles entre les mots pour mieux comprendre et générer du texte. Dans l'étape de prédiction de la phrase suivante, le modèle BERT reçoit deux phrases en entrée et l'objectif est de déterminer si les deux phrases sont sémantiquement liées l'une à l'autre. Grâce à cette tâche, le modèle BERT peut apprendre la corrélation entre les phrases pour mieux comprendre la sémantique et le contexte de la phrase. Grâce à ces deux étapes de pré-formation, le modèle BERT peut obtenir de riches informations sémantiques et contextuelles. Cela rend le modèle BERT performant dans diverses tâches de traitement du langage naturel, telles que la classification de texte, la reconnaissance d'entités nommées, les systèmes de questions-réponses, etc. Dans le même temps, le processus de pré-formation de BERT utilise également des données textuelles non étiquetées à grande échelle, permettant au modèle d'acquérir des connaissances linguistiques générales à partir de données à grande échelle, améliorant ainsi encore ses performances. En résumé, le processus de pré-formation du modèle BERT comprend

Après la pré-formation, le modèle BERT peut être utilisé pour des tâches de classification des émotions. BERT peut être utilisé comme extracteur de fonctionnalités et combiné avec d'autres algorithmes d'apprentissage automatique (tels que la régression logistique, la machine à vecteurs de support, etc.) pour la classification. En outre, BERT peut également être affiné pour améliorer encore les performances de classification grâce à une formation de bout en bout sur des ensembles de données de classification d'émotions spécifiques.

Pour la méthode d'extraction de caractéristiques, le vecteur de sortie du modèle BERT peut être utilisé comme vecteur de caractéristiques d'entrée. Le classificateur peut ensuite être entraîné en combinaison avec d’autres algorithmes d’apprentissage automatique. Avant la classification, le texte doit être prétraité, comme la segmentation des mots, la suppression des mots vides, l'extraction de la racine des mots, etc. L'utilisation du modèle pré-entraîné de BERT peut générer des intégrations de mots et utiliser ces intégrations comme vecteurs de fonctionnalités. Cela peut extraire efficacement les informations sémantiques du texte et aider le classificateur à mieux comprendre et distinguer différents échantillons de texte.

Pour la méthode de réglage fin, le modèle BERT peut être affiné en effectuant un entraînement de bout en bout sur l'ensemble de données de classification des sentiments. Dans cette approche, toutes les couches du modèle BERT peuvent être recyclées pour répondre aux besoins d'une tâche spécifique. Lors du réglage fin, le modèle peut être optimisé en utilisant différents taux d'apprentissage, tailles de lots et nombres d'époques de formation, selon les besoins. En affinant le modèle BERT, les performances du modèle peuvent être améliorées car il ajuste les poids en fonction des exigences de la tâche spécifique. Cette capacité de personnalisation rend le modèle BERT performant dans diverses tâches de traitement du langage naturel.

Lorsque vous utilisez le modèle BERT pour la classification des sentiments, vous devez faire attention aux points suivants :

1 Prétraitement des données : Avant d'utiliser le modèle BERT, vous devez prétraiter le texte, comme la segmentation des mots, suppression des mots vides, des radicaux, etc.

2. Annotation des données : La classification émotionnelle du texte doit être annotée avec précision. Les données annotées doivent avoir une couverture suffisante pour garantir que le modèle puisse apprendre la classification de diverses émotions.

3. Sélection du modèle : vous pouvez choisir d'utiliser un modèle BERT pré-entraîné ou un modèle BERT affiné pour la classification des sentiments. Le réglage fin du modèle BERT peut améliorer les performances du modèle, mais cela nécessite également plus de ressources informatiques et de temps.

4. Ajustement des hyperparamètres : Les hyperparamètres du modèle doivent être ajustés, tels que le taux d'apprentissage, la taille du lot et le nombre de cycles d'entraînement, etc., pour optimiser les performances du modèle.

5. Évaluation du modèle : Le modèle doit être évalué pour déterminer si ses performances répondent aux attentes. Des mesures telles que la précision, le rappel, le score F1, etc. peuvent être utilisées pour évaluer les performances du modèle.

Le code Python démontre le réglage fin du modèle BERT pour la classification des émotions

Le modèle BERT peut réaliser la classification des émotions grâce à deux méthodes : l'extraction de caractéristiques et le réglage fin. Cet article prendra comme exemple le réglage fin du modèle BERT pour la classification des sentiments et fournira également du code Python pour montrer comment l'implémenter.

1) Ensemble de données

Nous utiliserons l'ensemble de données de classification des sentiments IMDB à des fins de démonstration. Cet ensemble de données contient 50 000 textes issus de critiques de films IMDB, dont 25 000 sont utilisés pour la formation et les 25 000 autres pour les tests. Chaque échantillon possède une étiquette binaire indiquant un sentiment positif (1) ou négatif (0).

2) Obtenez l'ensemble de données

Tout d'abord, nous devons télécharger l'ensemble de données IMDB. L'ensemble de données peut être téléchargé à l'aide du code suivant :

!wget http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz
!tar -xf aclImdb_v1.tar.gz

3) Importez les bibliothèques nécessaires

接下来，我们需要导入必要的Python库，包括PyTorch、Transformers和NumPy。可以使用以下代码导入这些库：

import torch
import transformers as ppb
import numpy as np

4）加载BERT模型和标记器

我们将使用Pretrained BERT模型（ppb）库中的BERT模型和标记器。可以使用以下代码加载模型和标记器：

<code>model_class, tokenizer_class, pretrained_weights = (ppb.BertModel, ppb.BertTokenizer, &#x27;bert-base-uncased&#x27;)<br/>tokenizer = tokenizer_class.from_pretrained(pretrained_weights)<br/>model = model_class.from_pretrained(pretrained_weights)</code>

5）加载数据集

接下来，我们需要加载IMDB数据集。可以使用以下代码加载数据集：

import pandas as pd
import io

# Load data
train = pd.read_csv('aclImdb/train.tsv', delimiter='\t', header=None)
test = pd.read_csv('aclImdb/test.tsv', delimiter='\t', header=None)

# Split data into input and labels
train_sentences = train[0].values
train_labels = train[1].values
test_sentences = test[0].values
test_labels = test[1].values

6）预处理数据

在微调BERT模型之前，我们需要对数据进行预处理。这包括对文本进行标记化、截断和填充。可以使用以下代码对数据进行预处理：

# Tokenize the input texts
train_tokenized = np.array([tokenizer.encode(sent, add_special_tokens=True) for sent in train_sentences])
test_tokenized = np.array([tokenizer.encode(sent, add_special_tokens=True) for sent in test_sentences])

# Truncate and pad the input texts
max_len = 128
train_padded = np.array([i[:max_len] + [0]*(max_len-len(i)) for i in train_tokenized])
test_padded = np.array([i[:max_len] + [0]*(max_len-len(i)) for i in test_tokenized])

# Create attention masks
train_attention_mask = np.where(train_padded != 0, 1, 0)
test_attention_mask = np.where(test_padded != 0, 1, 0)

# Convert the input texts to PyTorch tensors
train_input_ids = torch.tensor(train_padded)
train_attention_mask = torch.tensor(train_attention_mask)
train_labels = torch.tensor(train_labels)
test_input_ids = torch.tensor(test_padded)
test_attention_mask = torch.tensor(test_attention_mask)
test_labels = torch.tensor(test_labels)

7）微调BERT模型

我们将使用PyTorch框架对BERT模型进行微调。可以使用以下代码对模型进行微调：

from torch.utils.data import TensorDataset, DataLoader, RandomSampler, SequentialSampler
from transformers import AdamW, get_linear_schedule_with_warmup

#Create a data loader for training data
batch_size = 32
train_data = TensorDataset(train_input_ids, train_attention_mask, train_labels)
train_sampler = RandomSampler(train_data)
train_dataloader = DataLoader(train_data, sampler=train_sampler, batch_size=batch_size)

#Create a data loader for test data
test_data = TensorDataset(test_input_ids, test_attention_mask, test_labels)
test_sampler = SequentialSampler(test_data)
test_dataloader = DataLoader(test_data, sampler=test_sampler, batch_size=batch_size)

#Set up the optimizer and scheduler
epochs = 3
optimizer = AdamW(model.parameters(), lr=2e-5, eps=1e-8)
total_steps = len(train_dataloader) * epochs
scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=0, num_training_steps=total_steps)

#Train the model
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
for epoch in range(epochs):
    print(f'Epoch {epoch + 1}/{epochs}')
    print('-' * 10)
    total_loss = 0
    model.train()
    for step, batch in enumerate(train_dataloader):
        # Get batch input data
        batch_input_ids = batch[0].to(device)
        batch_attention_mask = batch[1].to(device)
        batch_labels = batch[2].to(device)

    # Clear gradients
    model.zero_grad()

    # Forward pass
    outputs = model(batch_input_ids, attention_mask=batch_attention_mask, labels=batch_labels)
    loss = outputs[0]

    # Backward pass
    loss.backward()

    # Update parameters
    optimizer.step()

    # Update learning rate schedule
    scheduler.step()

    # Accumulate total loss
    total_loss += loss.item()

    # Print progress every 100 steps
    if (step + 1) % 100 == 0:
        print(f'Step {step + 1}/{len(train_dataloader)}: Loss = {total_loss / (step + 1):.4f}')

# Evaluate the model on test data
model.eval()
with torch.no_grad():
    total_correct = 0
    total_samples = 0
    for batch in test_dataloader:
        # Get batch input data
        batch_input_ids = batch[0].to(device)
        batch_attention_mask = batch[1].to(device)
        batch_labels = batch[2].to(device)

        # Forward pass
        outputs = model(batch_input_ids, attention_mask=batch_attention_mask)
        logits = outputs[0]
        predictions = torch.argmax(logits, dim=1)

        # Accumulate total correct predictions and samples
        total_correct += torch.sum(predictions == batch_labels).item()
        total_samples += len(batch_labels)

    # Print evaluation results
    accuracy = total_correct / total_samples
    print(f'Test accuracy: {accuracy:.4f}')

代码解析：

首先，我们使用PyTorch的数据加载器加载数据。我们将训练数据和测试数据分别放入train_data和test_data张量中，并使用RandomSampler和SequentialSampler对它们进行采样。然后，我们将train_data和test_data输入到DataLoader中，并设置batch_size为32。

接下来，我们设置优化器和学习率调度器。我们使用AdamW优化器和get_linear_schedule_with_warmup学习率调度器。我们将epochs设置为3，并使用total_steps计算总的训练步数。

然后，我们将模型移动到GPU设备上（如果可用）。在每个epoch中，我们将模型设置为训练模式，并遍历train_dataloader以进行训练。对于每个批次，我们将批次输入数据传递给模型，并计算损失。然后，我们使用反向传播更新模型参数，并使用scheduler更新学习率。我们还累计了总损失，并在每100个步骤后打印进度。

在每个epoch结束时，我们将模型设置为评估模式，并使用torch.no_grad()上下文计算在测试数据上的准确度。我们对test_dataloader进行遍历，并对每个批次进行预测。我们将预测结果与真实标签进行比较，并累计总正确预测数和样本数。最后，我们计算测试准确度并打印结果。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!