Aller au contenu
S'identifier S’abonner
Data — ML — NLP — IA

NLP Discovery : le premier voyage instructif dans le monde du NLP

Les ordinateurs ne comprennent pas le langage humain de la même manière que les humains. Ils doivent apprendre différement ...

,   and  Fatima Ezzahra BOUZIDI IDRISSI
3 lecture min
Bienvenue dans un épisode spécial de NLP Discovery !

Bienvenue dans un épisode spécial de NLP Discovery ! Préparez-vous à plonger dans les mystères du Traitement Automatique du Langage Naturel (NLP) lors de votre tout premier baptême dans ce domaine passionnant.

audio-thumbnail
NLP Discovery
0:00
/346.5329931972789

Le code dont parle notre expert dans le podcast est le suivant : 

import torch
from tqdm import tqdm
import pandas as pd
from transformers import BertTokenizer, BertForSequenceClassification, AdamW
from torch.utils.data import DataLoader, TensorDataset, random_split

def calculate_accuracy(predictions, labels):
    return torch.sum(predictions == labels).item() / len(labels)

# Chargement du modèle pré-entraîné BERT et du tokenizer
model_name = "bert-base-uncased"
tokenizer = BertTokenizer.from_pretrained(model_name)

# Chargement des données depuis votre fichier CSV
df = pd.read_csv('votre_fichier.csv')
texts = df['texte'].tolist()
labels = df['etiquettes'].tolist()

# Modification du modèle de classification en fonction du nombre de classes
num_labels = len(set(labels))

# Tokenization des textes
encoded_texts = tokenizer(texts, padding=True, truncation=True, return_tensors="pt")

# Création du DataLoader
train_size = int(0.8 * len(encoded_texts["input_ids"]))
val_size = len(encoded_texts["input_ids"]) - train_size

train_dataset, val_dataset = random_split(encoded_texts["input_ids"], [train_size, val_size])

train_dataloader = DataLoader(train_dataset, batch_size=8, shuffle=True)
val_dataloader = DataLoader(val_dataset, batch_size=8)

# Initialisation du modèle
model = BertForSequenceClassification.from_pretrained(model_name, num_labels=num_labels)

# Configuration de l'optimizer
optimizer = AdamW(model.parameters(), lr=1e-5)

# Critère d'arrêt
max_epochs_without_improvement = 3
best_validation_accuracy = 0
epochs_without_improvement = 0

# Entraînement du modèle
for epoch in range(100):
    model.train()
    for batch in tqdm(train_dataloader):
        input_ids, attention_mask, batch_labels = batch
        optimizer.zero_grad()
        outputs = model(input_ids, attention_mask=attention_mask, labels=batch_labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()

    # Évaluation du modèle sur l'ensemble de validation
    model.eval()
    total_accuracy = 0
    with torch.no_grad():
        for batch in tqdm(val_dataloader):
            input_ids, attention_mask, batch_labels = batch
            outputs = model(input_ids, attention_mask=attention_mask)
            logits = outputs.logits
            predicted_labels = torch.argmax(logits, dim=1)
            accuracy = calculate_accuracy(predicted_labels, batch_labels)
            total_accuracy += accuracy

    # Calculer la précision moyenne sur l'ensemble de validation
    average_validation_accuracy = total_accuracy / len(val_dataloader)
    print(f"Epoch {epoch + 1}, Validation Accuracy: {average_validation_accuracy}")

    # Vérifier si la précision de validation s'améliore
    if average_validation_accuracy > best_validation_accuracy:
        best_validation_accuracy = average_validation_accuracy
        epochs_without_improvement = 0
    else:
        epochs_without_improvement += 1

    # Si la précision ne s'améliore pas pendant plusieurs époques, arrêter l'entraînement
    if epochs_without_improvement >= max_epochs_without_improvement:
        print(f"Arrêt de l'entraînement après {epoch + 1} époques sans amélioration de la précision de validation.")
        break

print(f"Meilleure précision sur l'ensemble de validation : {best_validation_accuracy}")

Le code fourni est un script Python qui permet de créer, entraîner et évaluer un modèle de classification de texte en utilisant le modèle de langage BERT (Bidirectional Encoder Representations from Transformers). Voici un aperçu des principales étapes et actions du code :

Importation des bibliothèques :

Les bibliothèques nécessaires pour l'entraînement du modèle, telles que PyTorch, Transformers, et tqdm, sont importées.

Chargement du modèle BERT et du tokenizer :

Un modèle BERT pré-entraîné ("bert-base-uncased") et son tokenizer correspondant sont chargés à partir de la bibliothèque Hugging Face Transformers.

Chargement des données depuis un fichier CSV :

Les données d'entraînement sont chargées à partir d'un fichier CSV. Le code utilise la bibliothèque pandas pour cette opération.

Modification du modèle pour la classification :

Le modèle BERT est adapté à une tâche de classification en fonction du nombre de classes dans les données. Il est configuré pour effectuer une classification multiclasses si nécessaire.

Tokenization des textes :

Les textes sont prétraités en utilisant le tokenizer BERT. Ils sont divisés en sous-unités appelées "tokens", puis mis en forme avec du padding pour avoir des séquences de longueur uniforme. Des masques d'attention sont également créés.

Création du DataLoader :

Les données tokenisées sont regroupées dans un DataLoader pour gérer l'entraînement par lots (batches).

Configuration de l'optimizer :

L'optimiseur AdamW est configuré pour mettre à jour les poids du modèle pendant l'entraînement.

Critère d'arrêt :

Un critère d'arrêt est défini pour éviter le surapprentissage. L'entraînement s'arrête si la précision sur l'ensemble de validation cesse de s'améliorer pendant un certain nombre d'époques consécutives.

Entraînement du modèle :

Le modèle est entraîné sur plusieurs époques. À chaque époque, le modèle est mis en mode d'entraînement, les données sont chargées par lots, le gradient est calculé par rapport à la perte (loss), et les poids du modèle sont mis à jour avec l'optimiseur.

Évaluation du modèle sur l'ensemble de validation :

Après chaque époque, le modèle est mis en mode évaluation, et la précision est calculée sur l'ensemble de validation en comparant ses prédictions aux étiquettes réelles.

Affichage des résultats :

Le code affiche la précision moyenne sur l'ensemble de validation à chaque époque.

Si le critère d'arrêt est atteint (pas d'amélioration pendant un certain nombre d'époques), l'entraînement s'arrête prématurément.

En fin d'exécution, le code affiche la meilleure précision obtenue sur l'ensemble de validation.

En résumé, ce code permet de créer un modèle de classification de texte avec BERT, de l'entraîner sur vos données depuis un fichier CSV et de surveiller la précision sur l'ensemble de validation pour éviter le surapprentissage. Une fois l'entraînement terminé, il fournit la meilleure précision atteinte.

Lié

Dernier