Classification de <i> tokens </i>

La première application que nous allons explorer est la classification de tokens. Cette tâche générique englobe tous les problèmes qui peuvent être formulés comme l’attribution d’une étiquette à chaque token d’une phrase, tels que :

• la reconnaissance d’entités nommées (NER de l’anglais Named Entity Recognition), c’est-à-dire trouver les entités (telles que des personnes, des lieux ou des organisations) dans une phrase. Ce tâche peut être formulée comme l’attribution d’une étiquette à chaque token faisant parti d’une entité en ayant une classe spécifique par entité, et une classe pour les tokens ne faisant pas parti d’entité.
• le part-of-speech tagging (POS), c’est-à-dire marquer chaque mot dans une phrase comme correspondant à une partie particulière (comme un nom, un verbe, un adjectif, etc.).
• le chunking, c’est-à-dire trouver les tokens qui appartiennent à la même entité. Cette tâche (qui peut être combinée avec le POS ou la NER) peut être formulée comme l’attribution d’une étiquette (habituellement B-) à tous les tokens qui sont au début d’un morceau, une autre étiquette (habituellement I-) aux tokens qui sont à l’intérieur d’un morceau, et une troisième étiquette (habituellement O) aux tokens qui n’appartiennent à aucun morceau.

Bien sûr, il existe de nombreux autres types de problèmes de classification de tokens. Ce ne sont là que quelques exemples représentatifs. Dans cette section, nous allons finetuner un modèle (BERT) sur la tâche de NER. Il sera alors capable de calculer des prédictions comme celle-ci :

Vous pouvez trouver, télécharger et vérifier les précisions de ce modèle sur le Hub les prédictions du modèle que nous allons entraîner.

Préparation des données

Tout d’abord, nous avons besoin d’un jeu de données adapté à la classification des tokens. Dans cette section, nous utiliserons le jeu de données CoNLL-2003, qui contient des articles de presse de Reuters.

Le jeu de données CoNLL-2003

Pour charger le jeu de données CoNLL-2003, nous utilisons la méthode load_dataset() de la bibliothèque 🤗 Datasets :

from datasets import load_dataset

raw_datasets = load_dataset("conll2003")

Cela va télécharger et mettre en cache le jeu de données, comme nous l’avons vu dans chapitre 3 pour le jeu de données GLUE MRPC. L’inspection de cet objet nous montre les colonnes présentes dans ce jeu de données et la répartition entre les ensembles d’entraînement, de validation et de test :

raw_datasets

DatasetDict({
    train: Dataset({
        features: ['chunk_tags', 'id', 'ner_tags', 'pos_tags', 'tokens'],
        num_rows: 14041
    })
    validation: Dataset({
        features: ['chunk_tags', 'id', 'ner_tags', 'pos_tags', 'tokens'],
        num_rows: 3250
    })
    test: Dataset({
        features: ['chunk_tags', 'id', 'ner_tags', 'pos_tags', 'tokens'],
        num_rows: 3453
    })
})

En particulier, nous pouvons voir que le jeu de données contient des étiquettes pour les trois tâches que nous avons mentionnées précédemment : NER, POS et chunking. Une grande différence avec les autres jeux de données est que les entrées textuelles ne sont pas présentés comme des phrases ou des documents, mais comme des listes de mots (la dernière colonne est appelée tokens, mais elle contient des mots dans le sens où ce sont des entrées prétokénisées qui doivent encore passer par le tokenizer pour la tokenisation en sous-mots).

Regardons le premier élément de l’ensemble d’entraînement :

raw_datasets["train"][0]["tokens"]

['EU', 'rejects', 'German', 'call', 'to', 'boycott', 'British', 'lamb', '.']

Puisque nous voulons effectuer reconnaître des entités nommées, nous allons examiner les balises NER :

raw_datasets["train"][0]["ner_tags"]

[3, 0, 7, 0, 0, 0, 7, 0, 0]

Ce sont les étiquettes sous forme d’entiers disponibles pour l’entraînement mais ne sont pas nécessairement utiles lorsque nous voulons inspecter les données. Comme pour la classification de texte, nous pouvons accéder à la correspondance entre ces entiers et les noms des étiquettes en regardant l’attribut features de notre jeu de données :

ner_feature = raw_datasets["train"].features["ner_tags"]
ner_feature

Sequence(feature=ClassLabel(num_classes=9, names=['O', 'B-PER', 'I-PER', 'B-ORG', 'I-ORG', 'B-LOC', 'I-LOC', 'B-MISC', 'I-MISC'], names_file=None, id=None), length=-1, id=None)

Cette colonne contient donc des éléments qui sont des séquences de ClassLabel. Le type des éléments de la séquence se trouve dans l’attribut feature de cette ner_feature, et nous pouvons accéder à la liste des noms en regardant l’attribut names de cette feature :

label_names = ner_feature.feature.names
label_names

['O', 'B-PER', 'I-PER', 'B-ORG', 'I-ORG', 'B-LOC', 'I-LOC', 'B-MISC', 'I-MISC']

Nous avons déjà vu ces étiquettes au chapitre 6 lorsque nous nous sommes intéressés au pipeline token-classification mais nosu pouvons tout de même faire un rapide rappel :

• O signifie que le mot ne correspond à aucune entité.
• B-PER/I-PER signifie que le mot correspond au début/est à l’intérieur d’une entité personne.
• B-ORG/I-ORG signifie que le mot correspond au début/est à l’intérieur d’une entité organisation.
• B-LOC/I-LOC signifie que le mot correspond au début/est à l’intérieur d’une entité location.
• B-MISC/I-MISC signifie que le mot correspond au début/est à l’intérieur d’une entité divers.

Maintenant, le décodage des étiquettes que nous avons vues précédemment nous donne ceci :

words = raw_datasets["train"][0]["tokens"]
labels = raw_datasets["train"][0]["ner_tags"]
line1 = ""
line2 = ""
for word, label in zip(words, labels):
    full_label = label_names[label]
    max_length = max(len(word), len(full_label))
    line1 += word + " " * (max_length - len(word) + 1)
    line2 += full_label + " " * (max_length - len(full_label) + 1)

print(line1)
print(line2)

'EU    rejects German call to boycott British lamb .'
'B-ORG O       B-MISC O    O  O       B-MISC  O    O'

Et pour un exemple mélangeant les étiquettes B- et I-, voici ce que le même code nous donne sur le quatrième élément du jeu d’entraînement :

'Germany \'s representative to the European Union \'s veterinary committee Werner Zwingmann said on Wednesday consumers should buy sheepmeat from countries other than Britain until the scientific advice was clearer .'
'B-LOC   O  O              O  O   B-ORG    I-ORG O  O          O         B-PER  I-PER     O    O  O         O         O      O   O         O    O         O     O    B-LOC   O     O   O          O      O   O       O'

Comme on peut le voir, les entités couvrant deux mots, comme « European Union » et « Werner Zwingmann », se voient attribuer une étiquette B- pour le premier mot et une étiquette I- pour le second.

Traitement des données

Comme d’habitude, nos textes doivent être convertis en identifiants de tokens avant que le modèle puisse leur donner un sens. Comme nous l’avons vu au chapitre 6, une grande différence dans le cas des tâches de classification de tokens est que nous avons des entrées prétokénisées. Heureusement, l’API tokenizer peut gérer cela assez facilement. Nous devons juste avertir le tokenizer avec un drapeau spécial.

Pour commencer, nous allons créer notre objet tokenizer. Comme nous l’avons dit précédemment, nous allons utiliser un modèle BERT pré-entraîné, donc nous allons commencer par télécharger et mettre en cache le tokenizer associé :

from transformers import AutoTokenizer

model_checkpoint = "bert-base-cased"
tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)

Vous pouvez remplacer le model_checkpoint par tout autre modèle que vous préférez à partir du Hub, ou par un dossier local dans lequel vous avez sauvegardé un modèle pré-entraîné et un tokenizer. La seule contrainte est que le tokenizer doit être soutenu par la bibliothèque 🤗 Tokenizers. Il y a donc une version rapide disponible. Vous pouvez voir toutes les architectures qui ont une version rapide dans ce tableau, et pour vérifier que l’objet tokenizer que vous utilisez est bien soutenu par 🤗 Tokenizers vous pouvez regarder son attribut is_fast :

tokenizer.is_fast

True

Pour tokeniser une entrée prétokenisée, nous pouvons utiliser notre tokenizer comme d’habitude et juste ajouter is_split_into_words=True :

inputs = tokenizer(raw_datasets["train"][0]["tokens"], is_split_into_words=True)
inputs.tokens()

['[CLS]', 'EU', 'rejects', 'German', 'call', 'to', 'boycott', 'British', 'la', '##mb', '.', '[SEP]']

Comme on peut le voir, le tokenizer a ajouté les tokens spéciaux utilisés par le modèle ([CLS] au début et [SEP] à la fin) et n’a pas touché à la plupart des mots. Le mot lamb, cependant, a été tokenisé en deux sous-mots, la et ##mb. Cela introduit un décalage entre nos entrées et les étiquettes : la liste des étiquettes n’a que 9 éléments, alors que notre entrée a maintenant 12 tokens. Il est facile de tenir compte des tokens spéciaux (nous savons qu’ils sont au début et à la fin), mais nous devons également nous assurer que nous alignons toutes les étiquettes avec les mots appropriés.

Heureusement, comme nous utilisons un tokenizer rapide, nous avons accès aux superpouvoirs des 🤗 Tokenizers, ce qui signifie que nous pouvons facilement faire correspondre chaque token au mot correspondant (comme on le voit au chapitre 6) :

inputs.word_ids()

[None, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, None]

Avec un peu de travail, nous pouvons étendre notre liste d’étiquettes pour qu’elle corresponde aux tokens. La première règle que nous allons appliquer est que les tokens spéciaux reçoivent une étiquette de -100. En effet, par défaut, -100 est un indice qui est ignoré dans la fonction de perte que nous allons utiliser (l’entropie croisée). Ensuite, chaque token reçoit la même étiquette que le token qui a commencé le mot dans lequel il se trouve puisqu’ils font partie de la même entité. Pour les tokens à l’intérieur d’un mot mais pas au début, nous remplaçons le B- par I- (puisque le token ne commence pas l’entité) :

def align_labels_with_tokens(labels, word_ids):
    new_labels = []
    current_word = None
    for word_id in word_ids:
        if word_id != current_word:
            # Début d'un nouveau mot !
            current_word = word_id
            label = -100 if word_id is None else labels[word_id]
            new_labels.append(label)
        elif word_id is None:
            # Token spécial
            new_labels.append(-100)
        else:
            # Même mot que le token précédent
            label = labels[word_id]
            # Si l'étiquette est B-XXX, nous la changeons en I-XXX
            if label % 2 == 1:
                label += 1
            new_labels.append(label)

    return new_labels

Essayons-le sur notre première phrase :

labels = raw_datasets["train"][0]["ner_tags"]
word_ids = inputs.word_ids()
print(labels)
print(align_labels_with_tokens(labels, word_ids))

[3, 0, 7, 0, 0, 0, 7, 0, 0]
[-100, 3, 0, 7, 0, 0, 0, 7, 0, 0, 0, -100]

Comme nous pouvons le voir, notre fonction a ajouté -100 pour les deux tokens spéciaux du début et de fin, et un nouveau 0 pour notre mot qui a été divisé en deux tokens.

Pour prétraiter notre jeu de données, nous devons tokeniser toutes les entrées et appliquer align_labels_with_tokens() sur toutes les étiquettes. Pour profiter de la vitesse de notre tokenizer rapide, il est préférable de tokeniser beaucoup de textes en même temps. Nous allons donc écrire une fonction qui traite une liste d’exemples et utiliser la méthode Dataset.map() avec l’option batched=True. La seule chose qui diffère de notre exemple précédent est que la fonction word_ids() a besoin de récupérer l’index de l’exemple dont nous voulons les identifiants de mots lorsque les entrées du tokenizer sont des listes de textes (ou dans notre cas, des listes de mots), donc nous l’ajoutons aussi :

def tokenize_and_align_labels(examples):
    tokenized_inputs = tokenizer(
        examples["tokens"], truncation=True, is_split_into_words=True
    )
    all_labels = examples["ner_tags"]
    new_labels = []
    for i, labels in enumerate(all_labels):
        word_ids = tokenized_inputs.word_ids(i)
        new_labels.append(align_labels_with_tokens(labels, word_ids))

    tokenized_inputs["labels"] = new_labels
    return tokenized_inputs

Notez que nous n’avons pas encore rembourré nos entrées. Nous le ferons plus tard lors de la création des batchs avec un assembleur de données.

Nous pouvons maintenant appliquer tout ce prétraitement en une seule fois sur les autres divisions de notre jeu de données :

tokenized_datasets = raw_datasets.map(
    tokenize_and_align_labels,
    batched=True,
    remove_columns=raw_datasets["train"].column_names,
)

Nous avons fait la partie la plus difficile ! Maintenant que les données ont été prétraitées, l’entraînement ressemblera beaucoup à ce que nous avons fait dans le chapitre 3.

<i> Finetuning </i> du modèle avec l’API Trainer

Le code utilisant Trainer sera le même que précédemment. Les seuls changements sont la façon dont les données sont rassemblées dans un batch ainsi que la fonction de calcul de la métrique.

Assemblage des données

Nous ne pouvons pas simplement utiliser un DataCollatorWithPadding comme dans le chapitre 3 car cela ne fait que rembourrer les entrées (identifiants d’entrée, masque d’attention et token de type identifiants). Ici, nos étiquettes doivent être rembourréés exactement de la même manière que les entrées afin qu’elles gardent la même taille, en utilisant -100 comme valeur afin que les prédictions correspondantes soient ignorées dans le calcul de la perte.

Tout ceci est fait par un DataCollatorForTokenClassification. Comme le DataCollatorWithPadding, il prend le tokenizer utilisé pour prétraiter les entrées :

from transformers import DataCollatorForTokenClassification

data_collator = DataCollatorForTokenClassification(tokenizer=tokenizer)

Pour tester cette fonction sur quelques échantillons, nous pouvons simplement l’appeler sur une liste d’exemples provenant de notre jeu d’entraînement tokénisé :

batch = data_collator([tokenized_datasets["train"][i] for i in range(2)])
batch["labels"]

tensor([[-100,    3,    0,    7,    0,    0,    0,    7,    0,    0,    0, -100],
        [-100,    1,    2, -100, -100, -100, -100, -100, -100, -100, -100, -100]])

Comparons cela aux étiquettes des premier et deuxième éléments de notre jeu de données :

for i in range(2):
    print(tokenized_datasets["train"][i]["labels"])

[-100, 3, 0, 7, 0, 0, 0, 7, 0, 0, 0, -100]
[-100, 1, 2, -100]

Comme nous pouvons le voir, le deuxième jeu d’étiquettes a été complété à la longueur du premier en utilisant des -100.

Métriques

Pour que le Trainer calcule une métrique à chaque époque, nous devrons définir une fonction compute_metrics() qui prend les tableaux de prédictions et d’étiquettes, et retourne un dictionnaire avec les noms et les valeurs des métriques.

Le framework traditionnel utilisé pour évaluer la prédiction de la classification des tokens est seqeval. Pour utiliser cette métrique, nous devons d’abord installer la bibliothèque seqeval :

!pip install seqeval

Nous pouvons ensuite le charger via la fonction evaluate.load() comme nous l’avons fait dans le chapitre 3 :

import evaluate

metric = evaluate.load("seqeval")

Cette métrique ne se comporte pas comme la précision standard : elle prend les listes d’étiquettes comme des chaînes de caractères et non comme des entiers. Nous devrons donc décoder complètement les prédictions et les étiquettes avant de les transmettre à la métrique. Voyons comment cela fonctionne. Tout d’abord, nous allons obtenir les étiquettes pour notre premier exemple d’entraînement :

labels = raw_datasets["train"][0]["ner_tags"]
labels = [label_names[i] for i in labels]
labels

['B-ORG', 'O', 'B-MISC', 'O', 'O', 'O', 'B-MISC', 'O', 'O']

Nous pouvons alors créer de fausses prédictions pour celles-ci en changeant simplement la valeur de l’indice 2 :

predictions = labels.copy()
predictions[2] = "O"
metric.compute(predictions=[predictions], references=[labels])

Notez que la métrique prend une liste de prédictions (pas seulement une) et une liste d’étiquettes. Voici la sortie :

{'MISC': {'precision': 1.0, 'recall': 0.5, 'f1': 0.67, 'number': 2},
 'ORG': {'precision': 1.0, 'recall': 1.0, 'f1': 1.0, 'number': 1},
 'overall_precision': 1.0,
 'overall_recall': 0.67,
 'overall_f1': 0.8,
 'overall_accuracy': 0.89}

Cela renvoie un batch d’informations ! Nous obtenons la précision, le rappel et le score F1 pour chaque entité séparée, ainsi que le score global. Pour notre calcul de métrique, nous ne garderons que le score global, mais n’hésitez pas à modifier la fonction compute_metrics() pour retourner toutes les métriques que vous souhaitez.

Cette fonction compute_metrics() prend d’abord l’argmax des logits pour les convertir en prédictions (comme d’habitude, les logits et les probabilités sont dans le même ordre, donc nous n’avons pas besoin d’appliquer la fonction softmax). Ensuite, nous devons convertir les étiquettes et les prédictions des entiers en chaînes de caractères. Nous supprimons toutes les valeurs dont l’étiquette est -100, puis nous passons les résultats à la méthode metric.compute() :

import numpy as np


def compute_metrics(eval_preds):
    logits, labels = eval_preds
    predictions = np.argmax(logits, axis=-1)

    # Suppression de l'index ignoré (tokens spéciaux) et conversion en étiquettes
    true_labels = [[label_names[l] for l in label if l != -100] for label in labels]
    true_predictions = [
        [label_names[p] for (p, l) in zip(prediction, label) if l != -100]
        for prediction, label in zip(predictions, labels)
    ]
    all_metrics = metric.compute(predictions=true_predictions, references=true_labels)
    return {
        "precision": all_metrics["overall_precision"],
        "recall": all_metrics["overall_recall"],
        "f1": all_metrics["overall_f1"],
        "accuracy": all_metrics["overall_accuracy"],
    }

Maintenant que ceci est fait, nous sommes presque prêts à définir notre Trainer. Nous avons juste besoin d’un objet model pour finetuner !

Définir le modèle

Puisque nous travaillons sur un problème de classification de tokens, nous allons utiliser la classe AutoModelForTokenClassification. La principale chose à retenir lors de la définition de ce modèle est de transmettre des informations sur le nombre d’étiquettes que nous avons. La façon la plus simple de le faire est de passer ce nombre avec l’argument num_labels, mais si nous voulons un joli widget d’inférence fonctionnant comme celui que nous avons vu au début de cette section, il est préférable de définir les correspondances des étiquettes à la place.

Elles devraient être définies par deux dictionnaires, id2label et label2id, qui contiennent les correspondances entre identifiants et étiquettes et vice versa :

id2label = {i: label for i, label in enumerate(label_names)}
label2id = {v: k for k, v in id2label.items()}

Maintenant nous pouvons simplement les passer à la méthode AutoModelForTokenClassification.from_pretrained(), ils seront définis dans la configuration du modèle puis correctement sauvegardés et téléchargés vers le Hub :

from transformers import AutoModelForTokenClassification

model = AutoModelForTokenClassification.from_pretrained(
    model_checkpoint,
    id2label=id2label,
    label2id=label2id,
)

Comme lorsque nous avons défini notre AutoModelForSequenceClassification au chapitre 3, la création du modèle émet un avertissement indiquant que certains poids n’ont pas été utilisés (ceux de la tête de pré-entraînement) et que d’autres poids ont été initialisés de manière aléatoire (ceux de la tête de classification des nouveaux tokens), et que ce modèle doit être entraîné. Nous ferons cela dans une minute, mais vérifions d’abord que notre modèle a le bon nombre d’étiquettes :

model.config.num_labels

9

<i> Finetuning </i> du modèle

Nous sommes maintenant prêts à entraîner notre modèle ! Nous devons juste faire deux dernières choses avant de définir notre Trainer : se connecter à Hugging Face et définir nos arguments d’entraînement. Si vous travaillez dans un notebook, il y a une fonction pratique pour vous aider à le faire :

from huggingface_hub import notebook_login

notebook_login()

Cela affichera un widget où vous pourrez entrer vos identifiants de connexion à Hugging Face.

Si vous ne travaillez pas dans un notebook, tapez simplement la ligne suivante dans votre terminal :

huggingface-cli login

Une fois ceci fait, nous pouvons définir nos TrainingArguments :

from transformers import TrainingArguments

args = TrainingArguments(
    "bert-finetuned-ner",
    evaluation_strategy="epoch",
    save_strategy="epoch",
    learning_rate=2e-5,
    num_train_epochs=3,
    weight_decay=0.01,
    push_to_hub=True,
)

Vous avez déjà vu la plupart d’entre eux. Nous définissons quelques hyperparamètres (comme le taux d’apprentissage, le nombre d’époques à entraîner, et le taux de décroissance des poids), et nous spécifions push_to_hub=True pour indiquer que nous voulons sauvegarder le modèle, l’évaluer à la fin de chaque époque, et que nous voulons télécharger nos résultats vers le Hub. Notez que vous pouvez spécifier le nom du dépôt vers lequel vous voulez pousser avec l’argument hub_model_id (en particulier, vous devrez utiliser cet argument pour pousser vers une organisation). Par exemple, lorsque nous avons poussé le modèle vers l’organisation huggingface-course, nous avons ajouté hub_model_id="huggingface-course/bert-finetuned-ner"``TrainingArguments. Par défaut, le dépôt utilisé sera dans votre espace de noms et nommé d’après le répertoire de sortie que vous avez défini, donc dans notre cas ce sera "sgugger/bert-finetuned-ner".

Enfin, nous passons tout au Trainer et lançons l’entraînement :

from transformers import Trainer

trainer = Trainer(
    model=model,
    args=args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["validation"],
    data_collator=data_collator,
    compute_metrics=compute_metrics,
    tokenizer=tokenizer,
)
trainer.train()

Notez que pendant l’entraînement, chaque fois que le modèle est sauvegardé (ici, à chaque époque), il est téléchargé sur le Hub en arrière-plan. De cette façon, vous serez en mesure de reprendre votre entraînement sur une autre machine si nécessaire.

Une fois l’entraînement terminé, nous utilisons la méthode push_to_hub() pour nous assurer que nous téléchargeons la version la plus récente du modèle :

trainer.push_to_hub(commit_message="Training complete")

Cette commande renvoie l’URL du commit qu’elle vient de faire, si vous voulez l’inspecter :

'https://huggingface.co/sgugger/bert-finetuned-ner/commit/26ab21e5b1568f9afeccdaed2d8715f571d786ed'

Le Trainer rédige également une carte modèle avec tous les résultats de l’évaluation et la télécharge. A ce stade, vous pouvez utiliser le widget d’inférence sur le Hub pour tester votre modèle et le partager avec vos amis. Vous avez réussi à affiner un modèle sur une tâche de classification de tokens. Félicitations !

Si vous voulez plonger un peu plus profondément dans la boucle d’entraînement, nous allons maintenant vous montrer comment faire la même chose en utilisant 🤗 Accelerate.

Une boucle d’entraînement personnalisée

Jetons maintenant un coup d’œil à la boucle d’entraînement complète afin que vous puissiez facilement personnaliser les parties dont vous avez besoin. Elle ressemblera beaucoup à ce que nous avons fait dans le chapitre 3 avec quelques changements pour l’évaluation.

Préparer tout pour l’entraînement

D’abord nous devons construire le DataLoaders à partir de nos jeux de données. Nous réutilisons notre data_collator comme un collate_fn et mélanger l’ensemble d’entraînement, mais pas l’ensemble de validation :

from torch.utils.data import DataLoader

train_dataloader = DataLoader(
    tokenized_datasets["train"],
    shuffle=True,
    collate_fn=data_collator,
    batch_size=8,
)
eval_dataloader = DataLoader(
    tokenized_datasets["validation"], collate_fn=data_collator, batch_size=8
)

Ensuite, nous réinstantifions notre modèle pour nous assurer que nous ne continuons pas le finetuning d’avant et que nous repartons bien du modèle pré-entraîné de BERT :

model = AutoModelForTokenClassification.from_pretrained(
    model_checkpoint,
    id2label=id2label,
    label2id=label2id,
)

Ensuite, nous avons besoin d’un optimiseur. Nous utilisons le classique AdamW, qui est comme Adam, mais avec un correctif dans la façon dont le taux de décroissance des poids est appliquée :

from torch.optim import AdamW

optimizer = AdamW(model.parameters(), lr=2e-5)

Une fois que nous avons tous ces objets, nous pouvons les envoyer à la méthode accelerator.prepare() :

from accelerate import Accelerator

accelerator = Accelerator()
model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare(
    model, optimizer, train_dataloader, eval_dataloader
)

Maintenant que nous avons envoyé notre train_dataloader à accelerator.prepare(), nous pouvons utiliser sa longueur pour calculer le nombre d’étapes d’entraînement. Rappelez-vous que nous devrions toujours faire cela après avoir préparé le dataloader car cette méthode modifiera sa longueur. Nous utilisons un programme linéaire classique du taux d’apprentissage à 0 :

from transformers import get_scheduler

num_train_epochs = 3
num_update_steps_per_epoch = len(train_dataloader)
num_training_steps = num_train_epochs * num_update_steps_per_epoch

lr_scheduler = get_scheduler(
    "linear",
    optimizer=optimizer,
    num_warmup_steps=0,
    num_training_steps=num_training_steps,
)

Enfin, pour pousser notre modèle vers le Hub, nous avons besoin de créer un objet Repository dans un dossier de travail. Tout d’abord, connectez-vous à Hugging Face si vous n’êtes pas déjà connecté. Nous déterminons le nom du dépôt à partir de l’identifiant du modèle que nous voulons donner à notre modèle (n’hésitez pas à remplacer le repo_name par votre propre choix, il doit juste contenir votre nom d’utilisateur et ce que fait la fonction get_full_repo_name()) :

from huggingface_hub import Repository, get_full_repo_name

model_name = "bert-finetuned-ner-accelerate"
repo_name = get_full_repo_name(model_name)
repo_name

'sgugger/bert-finetuned-ner-accelerate'

Ensuite, nous pouvons cloner ce dépôt dans un dossier local. S’il existe déjà, ce dossier local doit être un clone existant du dépôt avec lequel nous travaillons :

output_dir = "bert-finetuned-ner-accelerate"
repo = Repository(output_dir, clone_from=repo_name)

Nous pouvons maintenant télécharger tout ce que nous sauvegardons dans output_dir en appelant la méthode repo.push_to_hub(). Cela nous aidera à télécharger les modèles intermédiaires à la fin de chaque époque.

Boucle d’entraînement

Nous sommes maintenant prêts à écrire la boucle d’entraînement complète. Pour simplifier sa partie évaluation, nous définissons cette fonction postprocess() qui prend les prédictions et les étiquettes, et les convertit en listes de chaînes de caractères comme notre objet metric l’attend :

def postprocess(predictions, labels):
    predictions = predictions.detach().cpu().clone().numpy()
    labels = labels.detach().cpu().clone().numpy()

    # Suppression de l'index ignoré (tokens spéciaux) et conversion en étiquettes
    true_labels = [[label_names[l] for l in label if l != -100] for label in labels]
    true_predictions = [
        [label_names[p] for (p, l) in zip(prediction, label) if l != -100]
        for prediction, label in zip(predictions, labels)
    ]
    return true_labels, true_predictions

Ensuite, nous pouvons écrire la boucle d’entraînement. Après avoir défini une barre de progression pour suivre l’évolution de l’entraînement, la boucle comporte trois parties :

• L’entraînement proprement dit, qui est l’itération classique sur le train_dataloader, passage en avant, puis passage en arrière et étape d’optimisation.
• L’évaluation, dans laquelle il y a une nouveauté après avoir obtenu les sorties de notre modèle sur un batch : puisque deux processus peuvent avoir paddé les entrées et les étiquettes à des formes différentes, nous devons utiliser accelerator.pad_across_processes() pour rendre les prédictions et les étiquettes de la même forme avant d’appeler la méthode gather(). Si nous ne le faisons pas, l’évaluation va soit se tromper, soit se bloquer pour toujours. Ensuite, nous envoyons les résultats à metric.add_batch() et appelons metric.compute() une fois que la boucle d’évaluation est terminée.
• Sauvegarde et téléchargement, où nous sauvegardons d’abord le modèle et le tokenizer, puis appelons repo.push_to_hub(). Remarquez que nous utilisons l’argument blocking=False pour indiquer à la bibliothèque 🤗 Hub de pousser dans un processus asynchrone. De cette façon, l’entraînement continue normalement et cette (longue) instruction est exécutée en arrière-plan.

Voici le code complet de la boucle d’entraînement :

from tqdm.auto import tqdm
import torch

progress_bar = tqdm(range(num_training_steps))

for epoch in range(num_train_epochs):
    # Entraînement
    model.train()
    for batch in train_dataloader:
        outputs = model(**batch)
        loss = outputs.loss
        accelerator.backward(loss)

        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()
        progress_bar.update(1)

    # Evaluation
    model.eval()
    for batch in eval_dataloader:
        with torch.no_grad():
            outputs = model(**batch)

        predictions = outputs.logits.argmax(dim=-1)
        labels = batch["labels"]

        # Nécessaire pour rembourrer les prédictions et les étiquettes à rassembler
        predictions = accelerator.pad_across_processes(predictions, dim=1, pad_index=-100)
        labels = accelerator.pad_across_processes(labels, dim=1, pad_index=-100)

        predictions_gathered = accelerator.gather(predictions)
        labels_gathered = accelerator.gather(labels)

        true_predictions, true_labels = postprocess(predictions_gathered, labels_gathered)
        metric.add_batch(predictions=true_predictions, references=true_labels)

    results = metric.compute()
    print(
        f"epoch {epoch}:",
        {
            key: results[f"overall_{key}"]
            for key in ["precision", "recall", "f1", "accuracy"]
        },
    )

    # Sauvegarder et télécharger
    accelerator.wait_for_everyone()
    unwrapped_model = accelerator.unwrap_model(model)
    unwrapped_model.save_pretrained(output_dir, save_function=accelerator.save)
    if accelerator.is_main_process:
        tokenizer.save_pretrained(output_dir)
        repo.push_to_hub(
            commit_message=f"Training in progress epoch {epoch}", blocking=False
        )

Au cas où ce serait la première fois que vous verriez un modèle enregistré avec 🤗 Accelerate, prenons un moment pour inspecter les trois lignes de code qui l’accompagnent :

accelerator.wait_for_everyone()
unwrapped_model = accelerator.unwrap_model(model)
unwrapped_model.save_pretrained(output_dir, save_function=accelerator.save)

La première ligne est explicite : elle indique à tous les processus d’attendre que tout le monde soit à ce stade avant de continuer. C’est pour s’assurer que nous avons le même modèle dans chaque processus avant de sauvegarder. Ensuite, nous prenons le unwrapped_model qui est le modèle de base que nous avons défini. La méthode accelerator.prepare() modifie le modèle pour qu’il fonctionne dans l’entraînement distribué, donc il n’aura plus la méthode save_pretrained() ; la méthode accelerator.unwrap_model() annule cette étape. Enfin, nous appelons save_pretrained() mais nous disons à cette méthode d’utiliser accelerator.save() au lieu de torch.save().

Une fois ceci fait, vous devriez avoir un modèle qui produit des résultats assez similaires à celui entraîné avec le Trainer. Vous pouvez vérifier le modèle que nous avons formé en utilisant ce code à huggingface-course/bert-finetuned-ner-accelerate. Et si vous voulez tester des modifications de la boucle d’entraînement, vous pouvez les implémenter directement en modifiant le code ci-dessus !

Utilisation du modèle <i> finetuné </i>

Nous vous avons déjà montré comment vous pouvez utiliser le modèle finetuné sur le Hub avec le widget d’inférence. Pour l’utiliser localement dans un pipeline, vous devez juste spécifier l’identifiant de modèle approprié :

from transformers import pipeline

# Remplacez ceci par votre propre checkpoint
model_checkpoint = "huggingface-course/bert-finetuned-ner"
token_classifier = pipeline(
    "token-classification", model=model_checkpoint, aggregation_strategy="simple"
)
token_classifier("My name is Sylvain and I work at Hugging Face in Brooklyn.")

[{'entity_group': 'PER', 'score': 0.9988506, 'word': 'Sylvain', 'start': 11, 'end': 18},
 {'entity_group': 'ORG', 'score': 0.9647625, 'word': 'Hugging Face', 'start': 33, 'end': 45},
 {'entity_group': 'LOC', 'score': 0.9986118, 'word': 'Brooklyn', 'start': 49, 'end': 57}]

Super ! Notre modèle fonctionne aussi bien que le modèle par défaut pour ce pipeline !