Aller au contenu principal
Dernière mise à jour le

Affinage de modèles Hugging Face pour un seul GPU

Cet article décrit comment affiner un modèle Hugging Face avec la bibliothèque Hugging Face transformers sur un seul GPU. Il comprend également des recommandations spécifiques à Databricks pour le chargement de données depuis le lakehouse et l'enregistrement de modèles dans MLflow, ce qui vous permet d'utiliser et de gouverner vos modèles sur Databricks.

La bibliothèque Hugging Face transformers fournit l'utilitaire Trainer et les classes Auto Model qui permettent de charger et d'affiner les modèles Transformers.

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

  • Chargement des modèles à affiner.
  • Construction de la configuration pour l'utilitaire Hugging Face Transformers Trainer.
  • Effectuer l'entraînement sur un seul GPU.

Consultez Qu'est-ce que Hugging Face Transformers ?

Exigences​

Tokeniser un dataset Hugging Face​

Les modèles Hugging Face Transformers attendent une entrée tokenisée, plutôt que le texte des données download. Pour assurer 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 tokenizer de manière cohérente aux données d'entraînement et de test.

Par exemple :

Python
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)

Configurer la configuration de la formation​

Les outils de configuration de l'entraînement Hugging Face peuvent être utilisés pour configurer un Trainer. Les classes Trainer exigent que l'utilisateur fournisse :

  • Métriques
  • Un modèle de base
  • Une configuration de formation

Vous pouvez configurer des métriques d'évaluation en plus de la métrique loss default que le Trainer calcule. L'exemple suivant montre comment ajouter accuracy comme métrique :

Python
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 de modèle automatique pour le NLP afin de 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 dataset.

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

Suivant, créez la configuration de la formation. La classe TrainingArguments vous permet de spécifier le répertoire de sortie, la stratégie d'évaluation, le taux d'apprentissage et d'autres paramètres.

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

L'utilisation d'un data collator regroupe les entrées par lots dans les datasets d'entraînement et d'évaluation. DataCollatorWithPadding offre de bonnes performances de base pour la classification de texte.

Python
from transformers import DataCollatorWithPadding
data_collator = DataCollatorWithPadding(tokenizer)

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

Python
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îner et enregistrer dans MLflow​

Hugging Face s'intègre bien avec MLflow et enregistre automatiquement les métriques pendant l'entraînement du modèle en utilisant le MLflowCallback. Cependant, vous devez enregistrer vous-même le modèle entraîné.

Encapsulez l'entraînement dans une exécution MLflow. Ceci construit un pipeline Transformers à partir du tokenizer et du modèle entraîné, et l'écrit sur le disque local. Enfin, enregistrez le modèle dans MLflow avec mlflow.transformers.log_model.

Python
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 soumettre les composants utilisés dans l'entraînement dans un dictionnaire :

Python
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!"],
)

Charger le modèle pour l'inférence​

Lorsque votre modèle est enregistré et prêt, le chargement du modèle pour l'inférence est le même que le chargement du modèle pré-entraîné encapsulé par MLflow.

Python
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)

Consultez Déployer des modèles à l'aide de Model Serving pour plus d'informations.

Résoudre les erreurs CUDA courantes​

Cette section décrit les erreurs CUDA courantes et des indications sur la manière de les résoudre.

OutOfMemoryError : mémoire CUDA insuffisante​

Lorsque vous entraînez des modèles volumineux, une erreur courante que vous pouvez rencontrer est l'erreur CUDA de manque de mémoire.

Exemple :

Console
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 batch pour l'entraînement. Vous pouvez réduire la valeur per_device_train_batch_size dans TrainingArguments.

  • Utilisez un entraînement de précision inférieure. Vous pouvez définir fp16=True dans TrainingArguments.

  • Utilisez gradient_accumulation_steps dans TrainingArguments pour augmenter efficacement la taille globale du batch.

  • Utilisez l'optimiseur Adam 8 bits.

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

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

Erreurs du noyau CUDA​

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

Exemple :

Console
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 dépanner :

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

  • Une autre option consiste à obtenir une meilleure trace de pile en définissant CUDA_LAUNCH_BLOCKING=1:

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

Notebook : réglage fin de la classification de texte sur un seul GPU​

Pour start rapidement avec du code d'exemple, ce Notebook d'exemple fournit un exemple de bout en bout pour l'affinement d'un modèle de classification de texte. Les sections suivantes de cet article décrivent plus en détail l'utilisation de Hugging Face pour l'affinement sur Databricks.

Affinement de notebooks de modèles de classification de texte Hugging Face

Ouvrir le notebook dans un nouvel ongletOuvrir dans Databricks

Ressources supplémentaires​

En savoir plus sur Hugging Face sur Databricks.

Sur cette page