Partager via

Ajuster les modèles Hugging Face pour un seul GPU

  • Article

Cet article explique comment affiner un modèle Hugging Face avec la bibliothèque Hugging Face transformers sur un seul GPU. Il inclut également des recommandations spécifiques à Databricks pour le chargement de données à partir des modèles lakehouse et de journalisation dans MLflow, ce qui vous permet d’utiliser et de régir vos modèles sur Azure Databricks.

La bibliothèque Hugging Face transformers fournit l’utilitaire Trainer et les classes Auto Model qui permettent le chargement et l’optimisation des modèles Transformers.

Ces outils sont disponibles pour les tâches suivantes avec des modifications simples :

  • Le chargement de modèles à afficher.
  • La construction de la configuration de l’utilitaire Hugging Face Transformers Trainer.
  • L’exécution d’un entraînement sur un seul GPU.

Consulter Qu’est-ce que Hugging Face Transformers ?

Spécifications

Tokénisation d’un jeu de données Hugging Face

Les modèles Hugging Face Transformers s’attendent à une entrée tokenisée, plutôt que le texte dans les données téléchargées. Pour garantir la compatibilité avec le modèle de base, utilisez un AutoTokenizer chargé à partir du modèle de base. Hugging Face datasets vous permet d’appliquer directement le générateur de jetons de manière cohérente aux données d’entraînement et de test.

Par exemple :

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(base_model)
def tokenize_function(examples):
    return tokenizer(examples["text"], padding=False, truncation=True)

train_test_tokenized = train_test_dataset.map(tokenize_function, batched=True)

Régler la configuration d’entraînement

Vous pouvez utiliser les outils de configuration d’entraînement Hugging Face pour configurer un Trainer. Les classes Trainer nécessitent que l’utilisateur fournisse les informations suivantes :

  • Métriques
  • Un modèle de base
  • Une configuration d’entraînement

Vous pouvez configurer les métriques d’évaluation en plus de la métrique par défaut loss calculée par le Trainer. L’exemple suivant illustre l’ajout de accuracy en tant que métrique :

import numpy as np
import evaluate
metric = evaluate.load("accuracy")
def compute_metrics(eval_pred):
    logits, labels = eval_pred
    predictions = np.argmax(logits, axis=-1)
    return metric.compute(predictions=predictions, references=labels)

Utilisez les classes Auto Model pour NLP pour charger le modèle approprié pour votre tâche.

Pour la classification de texte, utilisez AutoModelForSequenceClassification pour charger un modèle de base pour la classification de texte. Lors de la création du modèle, fournissez le nombre de classes et les mappages d’étiquettes créés pendant la préparation du jeu de données.

from transformers import AutoModelForSequenceClassification
model = AutoModelForSequenceClassification.from_pretrained(
        base_model,
        num_labels=len(label2id),
        label2id=label2id,
        id2label=id2label
        )

Ensuite, créez la configuration d’entraînement. La classe TrainingArguments vous permet de spécifier le répertoire de sortie, la stratégie d’évaluation, le taux d’entraînement et d’autres paramètres.

from transformers import TrainingArguments, Trainer
training_args = TrainingArguments(output_dir=training_output_dir, evaluation_strategy="epoch")

L’utilisation d’un collateur de données rassemble les entrées par lots dans les jeux de données d’entraînement et d’évaluation. DataCollatorWithPadding offre de bonnes performances de base pour la classification de texte.

from transformers import DataCollatorWithPadding
data_collator = DataCollatorWithPadding(tokenizer)

Une fois tous ces paramètres construits, vous pouvez maintenant créer une Trainer.

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_test_dataset["train"],
    eval_dataset=train_test_dataset["test"],
    compute_metrics=compute_metrics,
    data_collator=data_collator,
)

Entraînement et connexion à MLflow

Hugging Face interagit bien avec Mlflow et journalise automatiquement les métriques pendant l’entraînement d’un modèle grâce à MlflowCallback. Toutefois, vous devez journaliser vous-même le modèle entraîné.

Encapsulage de l’entraînement dans une exécution MLflow. Cela construit un pipeline Transformers à partir du générateur de jetons et du modèle entraîné, et l’écrit sur le disque local. Enfin, connectez le modèle à MLflow avec mlflow.transformers.log_model.

from transformers import pipeline

with mlflow.start_run() as run:
  trainer.train()
  trainer.save_model(model_output_dir)
  pipe = pipeline("text-classification", model=AutoModelForSequenceClassification.from_pretrained(model_output_dir), batch_size=1, tokenizer=tokenizer)
  model_info = mlflow.transformers.log_model(
        transformers_model=pipe,
        artifact_path="classification",
        input_example="Hi there!",
    )

Si vous n’avez pas besoin de créer un pipeline, vous pouvez envoyer les composants utilisés dans l’apprentissage dans un dictionnaire :

model_info = mlflow.transformers.log_model(
  transformers_model={"model": trainer.model, "tokenizer": tokenizer},
  task="text-classification",
  artifact_path="text_classifier",
  input_example=["MLflow is great!", "MLflow on Databricks is awesome!"],
)

Chargez le modèle à utiliser pour l’inférence

Lorsque votre modèle est journalisé et prêt, le chargement du modèle pour l’inférence est semblable au chargement du modèle préentraîné MLflow encapsulé.

logged_model = "runs:/{run_id}/{model_artifact_path}".format(run_id=run.info.run_id, model_artifact_path=model_artifact_path)

# Load model as a Spark UDF. Override result_type if the model does not return double values.
loaded_model_udf = mlflow.pyfunc.spark_udf(spark, model_uri=logged_model, result_type='string')

test = test.select(test.text, test.label, loaded_model_udf(test.text).alias("prediction"))
display(test)

Pour plus d’informations, consultez Service de modèles avec Azure Databricks.

Résolution des erreurs CUDA courantes

Cette section décrit les erreurs CUDA courantes et les conseils sur la façon de les résoudre.

OutOfMemoryError : CUDA n'a plus de mémoire

Lors de l’entraînement de modèles volumineux, une erreur courante que vous pouvez rencontrer est l’erreur de mémoire insuffisante CUDA.

Exemple :

OutOfMemoryError: CUDA out of memory. Tried to allocate 20.00 MiB (GPU 0; 14.76 GiB total capacity; 666.34 MiB already allocated; 17.75 MiB free; 720.00 MiB reserved in total by PyTorch) If reserved memory is >> allocated memory try setting max_split_size_mb to avoid fragmentation.  See documentation for Memory Management and PYTORCH_CUDA_ALLOC_CONF.

Essayez les recommandations suivantes pour résoudre cette erreur :

  • Réduisez la taille de lot pour l’entraînement. Vous pouvez réduire la valeur per_device_train_batch_size dans TrainingArguments.

  • Baissez la précision de l’entraînement. Vous pouvez définir fp16=True dans TrainingArguments.

  • Utilisez gradient_accumulation_steps dans TrainingArguments pour augmenter efficacement la taille globale des lots.

  • Utilisez l’optimiseur 8-bit Adam.

  • Nettoyez la mémoire GPU avant l’entraînement. Parfois, la mémoire GPU peut être occupée par du code inutilisé.

    from numba import cuda
device = cuda.get_current_device()
device.reset()

Erreurs de noyau CUDA

Lors de l’exécution de l’entraînement, vous pouvez obtenir des erreurs de noyau CUDA.

Exemple :

CUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.

For debugging, consider passing CUDA_LAUNCH_BLOCKING=1.

Pour résoudre les problèmes :

  • Essayez d’exécuter le code sur le CPU pour voir si l’erreur est reproductible.

  • Une autre option consiste à avoir un meilleur suivi en définissant CUDA_LAUNCH_BLOCKING=1 :

    import os
os.environ["CUDA_LAUNCH_BLOCKING"] = "1"

Notebook : Ajuster la classification du texte sur un seul GPU

Pour commencer rapidement avec un exemple de code, cet exemple de notebook fournit un exemple de bout en bout pour affiner un modèle pour la classification de texte. Les sections suivantes de cet article décrivent plus en détail l’utilisation de Hugging Face pour un affinage sur Azure Databricks.

Notebook d’affinage de modèles de classification de texte avec Hugging Face

Obtenir le notebook

Ressources supplémentaires

En savoir plus sur Hugging Face sur Azure Databricks.