Share via

Ottimizzare i modelli Hugging Face per una singola GPU

  • Articolo

Questo articolo descrive come ottimizzare un modello Hugging Face con la libreria Hugging Face transformers in una singola GPU. Include anche raccomandazioni specifiche di Databricks per il caricamento di dati dai modelli lakehouse e di registrazione a MLflow, che consente di usare e gestire i modelli in Azure Databricks.

La libreria Hugging Face transformers fornisce l'utilità Trainer e le classi modello automatico che consentono il caricamento e l'ottimizzazione dei modelli Transformers.

Questi strumenti sono disponibili per le attività seguenti con modifiche semplici:

  • Caricamento di modelli per ottimizzare.
  • Costruzione della configurazione per l'utilità Hugging Face Transformers Trainer.
  • Esecuzione del training su una singola GPU.

Vedere Che cosa sono i trasformatori di viso hugging?

Requisiti

Tokenizzare un set di dati Hugging Face

I modelli Hugging Face Transformers prevedono input con token, anziché il testo nei dati scaricati. Per garantire la compatibilità con il modello di base, usare un autoTokenizer caricato dal modello di base. Hugging Face datasets consente di applicare direttamente il tokenizer in modo coerente ai dati di training e di test.

Ad esempio:

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)

Configurare la configurazione del training

Gli strumenti di configurazione di hugging Viso possono essere usati per configurare un trainer. Le classi Trainer richiedono all'utente di fornire:

  • Metrica
  • Un modello di base
  • Una configurazione di training

È possibile configurare le metriche di valutazione oltre alla metrica predefinita calcolata lossTrainer . L'esempio seguente illustra l'aggiunta accuracy come metrica:

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)

Usare le classi del modello automatico per NLP per caricare il modello appropriato per l'attività.

Per la classificazione del testo, usare AutoModelForSequenceClassification per caricare un modello di base per la classificazione del testo. Quando si crea il modello, specificare il numero di classi e i mapping delle etichette creati durante la preparazione del set di dati.

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

Creare quindi la configurazione di training. La classe TrainingArguments consente di specificare la directory di output, la strategia di valutazione, la frequenza di apprendimento e altri parametri.

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

L'uso di un agente di confronto dati inserisce l'input nei set di dati di training e valutazione. DataCollatorWithPadding offre buone prestazioni di base per la classificazione del testo.

from transformers import DataCollatorWithPadding
data_collator = DataCollatorWithPadding(tokenizer)

Con tutti questi parametri costruiti, è ora possibile creare un oggetto 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,
)

Eseguire il training e l'accesso a MLflow

Hugging Face interfaces well with MLflow and automatically logs metrics during model training using the MLflowCallback.Hugging Face interfaces well with MLflowFlow and automatically logs metrics during model training using the MLflowCallback. Tuttavia, è necessario registrare manualmente il modello sottoposto a training.

Eseguire il wrapping del training in un'esecuzione MLflow. In questo modo viene creata una pipeline Transformers dal tokenizer e dal modello sottoposto a training e la scrive nel disco locale. Infine, registrare il modello in MLflow con 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!",
    )

Se non è necessario creare una pipeline, è possibile inviare i componenti usati nel training in un dizionario:

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

Caricare il modello per l'inferenza

Quando il modello viene registrato e pronto, il caricamento del modello per l'inferenza equivale al caricamento del modello sottoposto a wrapping preliminare di MLflow.

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)

Per altre informazioni, vedere Model serving with Azure Databricks (Gestire modelli con Azure Databricks ).

Risolvere gli errori CUDA comuni

Questa sezione descrive gli errori CUDA comuni e indicazioni su come risolverli.

OutOfMemoryError: memoria insufficiente CUDA

Quando si esegue il training di modelli di grandi dimensioni, è possibile che si verifichi un errore comune di CUDA in memoria insufficiente.

Esempio:

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.

Provare le raccomandazioni seguenti per risolvere l'errore:

  • Ridurre le dimensioni del batch per il training. È possibile ridurre il per_device_train_batch_size valore in TrainingArguments.

  • Usare il training con precisione inferiore. È possibile impostare fp16=True in TrainingArguments.

  • Usare gradient_accumulation_steps in TrainingArguments per aumentare in modo efficace le dimensioni complessive del batch.

  • Usare Adam Optimizer a 8 bit.

  • Pulire la memoria GPU prima del training. In alcuni casi, la memoria GPU può essere occupata da codice inutilizzato.

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

Errori del kernel CUDA

Quando si esegue il training, è possibile che vengano visualizzati errori del kernel CUDA.

Esempio:

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.

Per risolvere il problema:

  • Provare a eseguire il codice sulla CPU per verificare se l'errore è riproducibile.

  • Un'altra opzione consiste nel ottenere un traceback migliore impostando CUDA_LAUNCH_BLOCKING=1:

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

Notebook: Ottimizzare la classificazione del testo in una singola GPU

Per iniziare rapidamente a usare il codice di esempio, questo notebook di esempio fornisce un esempio end-to-end per ottimizzare un modello per la classificazione del testo. Le sezioni successive di questo articolo illustrano in modo più dettagliato l'uso di Hugging Face per l'ottimizzazione in Azure Databricks.

Notebook dei modelli di classificazione del testo hugging viso per l'ottimizzazione

Ottenere il notebook

Risorse aggiuntive

Altre informazioni su Hugging Face in Azure Databricks.