Exploiter les super pouvoirs du TPN un tutoriel étape par étape sur l’affinage Hugging Face

Révélez les super pouvoirs du TPN un tutoriel étape par étape pour sublimer votre visage avec Hugging Face

Introduction

Le perfectionnement d’un modèle de traitement du langage naturel (NLP) consiste à modifier les hyperparamètres et l’architecture du modèle, et à ajuster généralement l’ensemble de données pour améliorer les performances du modèle sur une tâche donnée. Vous pouvez y parvenir en ajustant le taux d’apprentissage, le nombre de couches du modèle, la taille des embeddings et divers autres paramètres. Le perfectionnement est une procédure longue qui demande une solide compréhension du modèle et de la tâche. Cet article examinera comment perfectionner un modèle Hugging Face.

Objectifs d’apprentissage

Comprendre la structure du modèle T5, y compris les transformateurs et l’auto-attention.
Apprendre à optimiser les hyperparamètres pour de meilleures performances du modèle.
Maîtriser la préparation des données textuelles, y compris la tokenisation et la mise en forme.
Savoir comment adapter les modèles pré-entraînés à des tâches spécifiques.
Apprendre à nettoyer, diviser et créer des ensembles de données pour l’entraînement.
Acquérir de l’expérience dans l’entraînement et l’évaluation des modèles à l’aide de mesures telles que la perte et la précision.
Explorer les applications du monde réel du modèle perfectionné pour générer des réponses ou des réponses.

Cet article a été publié dans le cadre du Data Science Blogathon.

À propos des modèles Hugging Face

Hugging Face est une entreprise qui propose une plateforme d’entraînement et de déploiement de modèles de traitement du langage naturel (NLP). La plateforme héberge une bibliothèque de modèles adaptés à diverses tâches de NLP, telles que la traduction de langues, la génération de texte et la réponse aux questions. Ces modèles sont formés sur des ensembles de données étendus et sont conçus pour exceller dans une large gamme d’activités de traitement du langage naturel (NLP).

La plateforme Hugging Face propose également des outils pour affiner les modèles pré-entraînés sur des ensembles de données spécifiques, ce qui permet d’adapter les algorithmes à des domaines ou des langues particuliers. La plateforme dispose également d’API pour accéder et utiliser des modèles pré-entraînés dans des applications, ainsi que d’outils pour construire des modèles sur mesure et les déployer sur le cloud.

L’utilisation de la bibliothèque Hugging Face pour des tâches de traitement du langage naturel (NLP) présente plusieurs avantages:

Large sélection de modèles: Un large éventail de modèles NLP pré-entraînés est disponible via la bibliothèque Hugging Face, y compris des modèles entraînés sur des tâches telles que la traduction de langues, la réponse aux questions et la catégorisation de texte. Cela rend facile le choix d’un modèle répondant à vos besoins exacts.
Compatibilité entre les plates-formes: La bibliothèque Hugging Face est compatible avec les systèmes standard d’apprentissage profond tels que TensorFlow, PyTorch et Keras, ce qui facilite son intégration dans votre flux de travail existant.
Facilité de l’adaptation: La bibliothèque Hugging Face contient des outils pour affiner les modèles pré-entraînés sur votre ensemble de données, ce qui vous fait gagner du temps et des efforts par rapport à l’entraînement d’un modèle à partir de zéro.
Communauté active: La bibliothèque Hugging Face compte une communauté d’utilisateurs vaste et active, ce qui signifie que vous pouvez obtenir de l’aide et du soutien, et contribuer à la croissance de la bibliothèque.
Bien documenté: La bibliothèque Hugging Face contient une documentation étendue, ce qui facilite la prise en main et l’apprentissage de son utilisation efficace.

Importer les bibliothèques nécessaires

Importer les bibliothèques nécessaires revient à constituer une trousse à outils pour une activité de programmation et d’analyse de données spécifique. Ces bibliothèques, qui sont souvent des collections de code préécrit, offrent une large gamme de fonctions et d’outils qui aident à accélérer le développement. Les développeurs et les scientifiques des données peuvent accéder à de nouvelles fonctionnalités, augmenter leur productivité et utiliser des solutions existantes en important les bibliothèques appropriées.

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
import torch
from transformers import T5Tokenizer
from transformers import T5ForConditionalGeneration, AdamW
import pytorch_lightning as pl
from pytorch_lightning.callbacks import ModelCheckpoint
pl.seed_everything(100)
import warnings
warnings.filterwarnings(“ignore”)

Importer le jeu de données

L’importation d’un jeu de données est une étape cruciale dans les projets axés sur les données.


df = pd.read_csv("/kaggle/input/queestion-answer-dataset-qa/train.csv")
df.columns


df = df[['context','question', 'text']]
print("Nombre d'enregistrements: ", df.shape[0])

Énoncé du problème

“Créer un modèle capable de générer des réponses basées sur le contexte et les questions.”

Par exemple,

Contexte = “Regrouper des cas similaires, par exemple, peut trouver des patients similaires ou les utiliser pour la segmentation des clients dans le secteur bancaire. La technique d’association est utilisée pour trouver des articles ou des événements qui se produisent souvent ensemble, par exemple, des articles d’épicerie qu’un client particulier achète généralement ensemble. La détection des anomalies est utilisée pour découvrir des cas anormaux et inhabituels, par exemple, la détection de la fraude par carte de crédit.”

Question = “Quel est l’exemple de détection d’anomalies?”

Réponse = ????????????????????????????????


df["context"] = df["context"].str.lower()
df["question"] = df["question"].str.lower()
df["text"] = df["text"].str.lower()
df.head()

Initialiser les paramètres

Longueur de l’entrée : Pendant l’entraînement, nous faisons référence au nombre de jetons d’entrée (par exemple, mots ou caractères) dans un seul exemple alimenté dans le modèle en tant que longueur de l’entrée. Si vous entraînez un modèle de langue pour prédire le mot suivant dans une phrase, la longueur de l’entrée serait le nombre de mots dans la phrase.
Longueur de la sortie : Pendant l’entraînement, on s’attend à ce que le modèle génère une quantité spécifique de jetons de sortie, tels que des mots ou des caractères, dans un seul échantillon. La longueur de la sortie correspond au nombre de mots que le modèle prédit dans la phrase.
Taille du lot d’entraînement : Pendant l’entraînement, le modèle traite plusieurs exemples à la fois. Si vous définissez la taille du lot d’entraînement à 32, le modèle traite 32 instances, telles que 32 phrases, simultanément avant de mettre à jour ses poids.
Taille du lot de validation : Similaire à la taille du lot d’entraînement, ce paramètre indique le nombre d’instances que le modèle traite lors de la phase de validation. En d’autres termes, il représente le volume de données que le modèle traite lorsqu’il est testé sur un ensemble de données de réserve.
Époques : Une époque correspond à un passage complet à travers l’ensemble de données d’entraînement. Ainsi, si l’ensemble de données d’entraînement comprend 1000 instances et que la taille du lot d’entraînement est de 32, une époque nécessitera 32 étapes d’entraînement. Si le modèle est entraîné pendant dix époques, il aura traité dix mille instances (10 * 1000 = dix mille).


DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
INPUT_MAX_LEN = 512 # Longueur de l'entrée
OUT_MAX_LEN = 128 # Longueur de la sortie
TRAIN_BATCH_SIZE = 8 # Taille du lot d'entraînement
VALID_BATCH_SIZE = 2 # Taille du lot de validation
EPOCHS = 5 # Nombre d'itérations

Transformateur T5

Le modèle T5 est basé sur l’architecture du transformateur, un réseau neuronal conçu pour traiter efficacement des données d’entrée séquentielles. Il comprend un encodeur et un décodeur, qui comprennent une séquence de “couches” interconnectées.

Les couches d’encodeur et de décodeur comprennent différents mécanismes d'”attention” et de réseaux “feedforward”. Les mécanismes d’attention permettent au modèle de se concentrer sur différentes sections de la séquence d’entrée à d’autres moments. En même temps, les réseaux feedforward modifient les données d’entrée à l’aide d’un ensemble de poids et de biais.

Le modèle T5 utilise également l'”auto-attention”, qui permet à chaque élément de la séquence d’entrée de prêter attention à chaque autre élément. Cela permet au modèle de reconnaître les liens entre les mots et les phrases dans les données d’entrée, ce qui est essentiel pour de nombreuses applications de traitement du langage naturel.

En plus de l’encodeur et du décodeur, le modèle T5 contient une “tête de modèle de langue” qui prédit le mot suivant dans une séquence en fonction des mots précédents. Cela est essentiel pour les traductions et les tâches de production de texte, où le modèle doit fournir une sortie cohérente et naturelle.

Le modèle T5 représente un réseau neuronal complexe et sophistiqué conçu pour un traitement séquentiel hautement efficace et précis des entrées. Il a été largement entraîné sur un ensemble diversifié de données texte et peut efficacement effectuer un large éventail de tâches de traitement du langage naturel.

T5Tokenizer

T5Tokenizer est utilisé pour transformer un texte en une liste de jetons, représentant chacun un mot ou une ponctuation. Le tokenizer insère également des jetons uniques dans le texte d’entrée pour représenter le début et la fin du texte et distinguer différentes phrases.

Le T5Tokenizer utilise une combinaison de tokenisation au niveau des caractères et des mots, ainsi qu’une stratégie de tokenisation au niveau des sous-mots comparable au tokenizer SentencePiece. Il décompose le texte d’entrée en sous-mots en fonction de la fréquence de chaque caractère ou séquence de caractères dans les données d’entraînement. Cela aide le tokenizer à gérer les termes hors vocabulaire (OOV) qui ne se trouvent pas dans les données d’entraînement mais apparaissent dans les données de test.

Le T5Tokenizer insère également des jetons uniques dans le texte pour représenter le début et la fin des phrases et les diviser. Par exemple, il ajoute les jetons s > et / s > pour indiquer le début et la fin d’une phrase, et pad > pour indiquer le rembourrage.

MODEL_NAME = "t5-base"tokenizer = T5Tokenizer.from_pretrained(MODEL_NAME, model_max_length= INPUT_MAX_LEN)

print("eos_token: {} et id: {}".format(tokenizer.eos_token,                   tokenizer.eos_token_id)) # Fin du jeton (eos_token)print("unk_token: {} et id: {}".format(tokenizer.unk_token,                   tokenizer.eos_token_id)) # Jeton inconnu (unk_token)print("pad_token: {} et id: {}".format(tokenizer.pad_token,                 tokenizer.eos_token_id)) # Jeton de rembourrage (pad_token)

Préparation du jeu de données

Lorsque vous utilisez PyTorch, vous préparez généralement vos données pour les utiliser avec le modèle en utilisant une classe de jeu de données. La classe de jeu de données est responsable du chargement des données depuis le disque et de l’exécution des procédures de préparation nécessaires, telles que la tokenisation et la numérisation. La classe doit également implémenter la fonction getitem, qui est utilisée pour obtenir un seul élément du jeu de données par index.

La méthode init remplit le jeu de données avec la liste de texte, la liste d’étiquettes et le tokenizer. La fonction len renvoie le nombre d’échantillons dans le jeu de données. La fonction getitem renvoie un seul élément d’un jeu de données par index. Elle accepte un index idx et renvoie l’entrée et les étiquettes tokenisées.

Il est également courant d’inclure différentes étapes de prétraitement, telles que le rembourrage et la troncature des entrées tokenisées. Vous pouvez également convertir les étiquettes en tenseurs.

class T5Dataset:    def __init__(self, context, question, target):        self.context = context        self.question = question        self.target = target        self.tokenizer = tokenizer        self.input_max_len = INPUT_MAX_LEN        self.out_max_len = OUT_MAX_LEN    def __len__(self):        return len(self.context)    def __getitem__(self, item):        context = str(self.context[item])        context = " ".join(context.split())        question = str(self.question[item])        question = " ".join(question.split())        target = str(self.target[item])        target = " ".join(target.split())                        inputs_encoding = self.tokenizer(            context,            question,            add_special_tokens=True,            max_length=self.input_max_len,            padding = 'max_length',            truncation='only_first',            return_attention_mask=True,            return_tensors="pt"        )                output_encoding = self.tokenizer(            target,            None,            add_special_tokens=True,            max_length=self.out_max_len,            padding = 'max_length',            truncation= True,            return_attention_mask=True,            return_tensors="pt"        )        inputs_ids = inputs_encoding["input_ids"].flatten()        attention_mask = inputs_encoding["attention_mask"].flatten()        labels = output_encoding["input_ids"]        labels[labels == 0] = -100  # Selon la documentation T5        labels = labels.flatten()        out = {            "contexte": context,            "question": question,            "réponse": target,            "inputs_ids": inputs_ids,            "attention_mask": attention_mask,            "étiquettes": labels        }        return out

DataLoader

La classe DataLoader charge les données en parallèle et en lot, ce qui permet de travailler avec de gros ensembles de données qui seraient autrement trop vastes pour être stockés en mémoire. En combinant la classe DataLoader avec une classe de jeu de données contenant les données à charger.

Le DataLoader est chargé d’itérer sur le jeu de données et de renvoyer un lot de données au modèle pour l’entraînement ou l’évaluation lors de l’entraînement d’un modèle de transformation. La classe DataLoader offre différents paramètres pour contrôler le chargement et le prétraitement des données, notamment la taille des lots, le nombre de threads de travail et la possibilité ou non de mélanger les données avant chaque époque.

class T5DatasetModule(pl.LightningDataModule):    def __init__(self, df_train, df_valid):        super().__init__()        self.df_train = df_train        self.df_valid = df_valid        self.tokenizer = tokenizer        self.input_max_len = INPUT_MAX_LEN        self.out_max_len = OUT_MAX_LEN    def setup(self, stage=None):        self.train_dataset = T5Dataset(        context=self.df_train.context.values,        question=self.df_train.question.values,        target=self.df_train.text.values        )        self.valid_dataset = T5Dataset(        context=self.df_valid.context.values,        question=self.df_valid.question.values,        target=self.df_valid.text.values        )    def train_dataloader(self):        return torch.utils.data.DataLoader(         self.train_dataset,         batch_size= TRAIN_BATCH_SIZE,         shuffle=True,          num_workers=4        )    def val_dataloader(self):        return torch.utils.data.DataLoader(         self.valid_dataset,         batch_size= VALID_BATCH_SIZE,         num_workers=1        )

Construction du modèle

Lors de la création d’un modèle de transformation en PyTorch, vous commencez généralement par créer une nouvelle classe dérivée de torch. nn.Module. Cette classe décrit l’architecture du modèle, y compris les couches et la fonction forward. La fonction init de la classe définit l’architecture du modèle, souvent en instanciant les différents niveaux du modèle et en les attribuant comme attributs de classe.

La méthode forward est chargée de faire passer les données à travers le modèle dans la direction avant. Cette méthode accepte les données d’entrée et applique les couches du modèle pour créer la sortie. La méthode forward doit implémenter la logique du modèle, telle que le passage de l’entrée à travers une séquence de couches et le retour du résultat.

La fonction init de la classe crée une couche d’incorporation, une couche de transformation et une couche entièrement connectée et les attribue comme attributs de classe. La méthode forward accepte les données d’entrée entrantes x, les traite via les étapes données et renvoie le résultat. Lors de l’entraînement d’un modèle de transformation, le processus d’entraînement implique généralement deux étapes : l’entraînement et la validation.

La méthode training_step définit le raisonnement pour effectuer une seule étape d’entraînement, qui comprend généralement :

passage avant à travers le modèle
calcul de la perte
calcul des gradients
Mise à jour des paramètres du modèle

La méthode val_step, comme la méthode training_step, est utilisée pour évaluer le modèle sur un ensemble de validation. Elle comprend généralement :

passage avant à travers le modèle
calcul des métriques d’évaluation

class T5Model(pl.LightningModule):        def __init__(self):        super().__init__()        self.model = T5ForConditionalGeneration.from_pretrained(MODEL_NAME, return_dict=True)    def forward(self, input_ids, attention_mask, labels=None):        output = self.model(            input_ids=input_ids,             attention_mask=attention_mask,             labels=labels        )        return output.loss, output.logits    def training_step(self, batch, batch_idx):        input_ids = batch["inputs_ids"]        attention_mask = batch["attention_mask"]        labels= batch["targets"]        loss, outputs = self(input_ids, attention_mask, labels)                self.log("train_loss", loss, prog_bar=True, logger=True)        return loss    def validation_step(self, batch, batch_idx):        input_ids = batch["inputs_ids"]        attention_mask = batch["attention_mask"]        labels= batch["targets"]        loss, outputs = self(input_ids, attention_mask, labels)        self.log("val_loss", loss, prog_bar=True, logger=True)                return loss    def configure_optimizers(self):        return AdamW(self.parameters(), lr=0.0001)

Entraînement du modèle

Il est courant, lors de l’entraînement d’un modèle de transformation, d’itérer sur l’ensemble de données par lots, d’envoyer l’entrée à travers le modèle et de modifier les paramètres du modèle en fonction des gradients calculés et d’un ensemble de critères d’optimisation.

def run():        df_train, df_valid = train_test_split(        df[0:10000], test_size=0.2, random_state=101    )        df_train = df_train.fillna("none")    df_valid = df_valid.fillna("none")        df_train['context'] = df_train['context'].apply(lambda x: " ".join(x.split()))    df_valid['context'] = df_valid['context'].apply(lambda x: " ".join(x.split()))        df_train['text'] = df_train['text'].apply(lambda x: " ".join(x.split()))    df_valid['text'] = df_valid['text'].apply(lambda x: " ".join(x.split()))        df_train['question'] = df_train['question'].apply(lambda x: " ".join(x.split()))    df_valid['question'] = df_valid['question'].apply(lambda x: " ".join(x.split()))       df_train = df_train.reset_index(drop=True)    df_valid = df_valid.reset_index(drop=True)        dataModule = T5DatasetModule(df_train, df_valid)    dataModule.setup()    device = DEVICE    models = T5Model()    models.to(device)    checkpoint_callback  = ModelCheckpoint(        dirpath="/kaggle/working",        filename="best_checkpoint",        save_top_k=2,        verbose=True,        monitor="val_loss",        mode="min"    )    trainer = pl.Trainer(        callbacks = checkpoint_callback,        max_epochs= EPOCHS,        gpus=1,        accelerator="gpu"    )    trainer.fit(models, dataModule)run()

Prédiction du modèle

Pour faire des prédictions avec un modèle NLP ajusté comme T5 en utilisant de nouvelles entrées, vous pouvez suivre ces étapes :

Prétraitement des nouvelles entrées : Tokenisez et prétraitez votre nouveau texte d’entrée pour qu’il corresponde au prétraitement que vous avez appliqué à vos données d’entraînement. Assurez-vous qu’il est dans le format correct attendu par le modèle.
Utiliser le modèle ajusté pour l’inférence : Chargez votre modèle T5 ajusté, que vous avez précédemment entraîné ou chargé à partir d’un point de contrôle.
Générer des prédictions : Passez la nouvelle entrée prétraitée au modèle pour la prédiction. Dans le cas de T5, vous pouvez utiliser la méthode generate pour générer des réponses.

train_model = T5Model.load_from_checkpoint("/kaggle/working/best_checkpoint-v1.ckpt")train_model.freeze()def generate_question(context, question):    inputs_encoding =  tokenizer(        context,        question,        add_special_tokens=True,        max_length= INPUT_MAX_LEN,        padding = 'max_length',        truncation='only_first',        return_attention_mask=True,        return_tensors="pt"        )        generate_ids = train_model.model.generate(        input_ids = inputs_encoding["input_ids"],        attention_mask = inputs_encoding["attention_mask"],        max_length = INPUT_MAX_LEN,        num_beams = 4,        num_return_sequences = 1,        no_repeat_ngram_size=2,        early_stopping=True,        )    preds = [        tokenizer.decode(gen_id,        skip_special_tokens=True,         clean_up_tokenization_spaces=True)        for gen_id in generate_ids    ]    return "".join(preds)

Prédiction

générons une prédiction à l’aide du modèle T5 ajusté avec une nouvelle entrée :

contexte = “Regroupement de groupes de cas similaires, par exemple, trouver des patients similaires, ou l’utiliser pour la segmentation des clients dans le domaine bancaire. Utiliser une technique d’association pour trouver des éléments ou des événements qui co-occurrent souvent, par exemple, des articles d’épicerie qui sont généralement achetés ensemble par un client particulier. Utilisation de la détection d’anomalies pour découvrir des cas anormaux et inhabituels, par exemple, la détection de fraudes par carte de crédit.”

que = “quel est l’exemple de la détection d’anomalies ?”

print(generate_question(contexte, que))

contexte = "La classification est utilisée lorsque votre cible est catégorique, tandis que la régression est utilisée lorsque votre variable cible est continue. La classification et la régression appartiennent toutes deux à la catégorie des algorithmes d'apprentissage automatique supervisés."que = "Quand utilise-t-on la classification ?"print(generate_question(contexte, que))

Conclusion

Dans cet article, nous nous sommes lancés dans un voyage pour ajuster un modèle de traitement du langage naturel (NLP), plus précisément le modèle T5, pour une tâche de question-réponse. Tout au long de ce processus, nous avons exploré divers aspects du développement et du déploiement de modèles NLP.

Points clés à retenir :

Nous avons exploré la structure encodeur-décodeur et les mécanismes d’auto-attention qui sous-tendent ses capacités.
L’art de l’ajustement des hyperparamètres est une compétence essentielle pour optimiser les performances du modèle.
En expérimentant avec les taux d’apprentissage, les tailles de batch et les tailles de modèle, nous avons pu ajuster efficacement le modèle.
Compétents en ce qui concerne la tokenisation, le padding et la conversion des données textuelles brutes en un format adapté à l’entrée du modèle.
Nous avons approfondi l’ajustement, notamment le chargement des poids pré-entraînés, la modification des couches du modèle et leur adaptation à des tâches spécifiques.
Nous avons appris comment nettoyer et structurer les données, en les divisant en ensembles d’entraînement et de validation.
Nous avons démontré comment il était possible de générer des réponses ou des réponses en fonction du contexte d’entrée et des questions, en mettant en valeur son utilité dans le monde réel.

Questions fréquemment posées

Les médias présentés dans cet article n’appartiennent pas à Analytics Vidhya et sont utilisés à la discrétion de l’auteur.

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!

fine tuningHugging FaceModelsNLPT5training

Was this article helpful?

93 out of 132 found this helpful