Ajuste preciso de los modelos de Hugging Face para una sola GPU

En este artículo se describe cómo ajustar un modelo de Hugging Face con la biblioteca Hugging Face transformers en una sola GPU. También incluye recomendaciones específicas de Databricks para cargar datos desde lakehouse y registrar modelos en MLflow, lo que le permite usar y controlar los modelos en Azure Databricks.

La biblioteca Hugging Face transformers proporciona la utilidad Trainer y las clases Auto Model que permiten cargar y ajustar los modelos de transformadores.

Estas herramientas están disponibles para las siguientes tareas con modificaciones sencillas:

• Carga de modelos para ajustarlos.
• Construir la configuración de la utilidad Hugging Face Transformers Trainer.
• Realizar el entrenamiento en una sola GPU.

Vea ¿Qué son los Hugging Face Transformers?

Requisitos

• Un clúster de un solo nodo con una GPU en el controlador.
• La versión de GPU de Databricks Runtime 13.0 ML y versiones posteriores.
  • Este ejemplo de ajuste preciso requiere los paquetes🤗 Transformers, 🤗 Datasets y 🤗 Evaluate que se incluyen en Databricks Runtime 13.0 ML y versiones posteriores.
• MLflow 2.3.
• Datos preparados y cargados para ajustar un modelo con transformadores.

Tokenizar un conjunto de datos de Hugging Face

Los modelos de Hugging Face Transformers requieren una entrada tokenizada, en lugar del texto de los datos descargados. Para garantizar la compatibilidad con el modelo base, use un AutoTokenizer cargado desde el modelo base. Hugging Face datasets permite aplicar directamente el tokenizador de forma coherente a los datos de entrenamiento y prueba.

Por ejemplo:

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)

Establecer la configuración de entrenamiento

Las herramientas de configuración de entrenamiento de Hugging Face se pueden usar para configurar un trainer. Las clases trainer requieren que el usuario proporcione lo siguiente:

• Métricas
• Un modelo base
• Una configuración de entrenamiento

Puede configurar métricas de evaluación además de la métrica de loss predeterminada que calcula el Trainer. En el ejemplo siguiente se muestra cómo agregar accuracy como métrica:

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)

Use las clases de modelo automático de para NLP para cargar el modelo adecuado para la tarea.

Para la clasificación de texto, use AutoModelForSequenceClassification para cargar un modelo base para la clasificación de texto. Al crear el modelo, proporcione el número de clases y las asignaciones de etiquetas creadas durante la preparación del conjunto de datos.

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

A continuación, cree la configuración de entrenamiento. La claseTrainingArguments permite especificar el directorio de salida, la estrategia de evaluación, la velocidad de aprendizaje y otros parámetros.

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

Usando un recopilador de datos, los lotes se introducen en conjuntos de datos de entrenamiento y evaluación. DataCollatorWithPadding proporciona un buen rendimiento de línea base para la clasificación de texto.

from transformers import DataCollatorWithPadding
data_collator = DataCollatorWithPadding(tokenizer)

Con todos estos parámetros construidos, ahora puede crear un 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,
)

Entrenamiento y registro en MLflow

Hugging Face interactúa bien con MLflow y registra automáticamente las métricas durante el entrenamiento del modelo usando el MLflowCallback. Sin embargo, debe registrar el modelo entrenado usted mismo.

Ajuste del entrenamiento en una ejecución de MLflow. Esto construye una canalización de Transformers desde el tokenizador y el modelo entrenado, y lo escribe en el disco local. Por último, registre el modelo en 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!",
    )

Si no necesita crear una canalización, puede enviar los componentes que se usan en el entrenamiento a un diccionario:

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

Carga del modelo para la inferencia

Cuando su modelo esté registrado y listo, cargar el modelo para la inferencia es lo mismo que cargar el modelo de MLflow encapsulado previamente entrenad

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)

Consulte Model serving with Azure Databricks (Servicio de modelos con Azure Databricks) para más información.

Solución de errores comunes de CUDA

Esta sección describe los errores CUDA más comunes y orienta sobre cómo resolverlos.

OutOfMemoryError: CUDA sin memoria

Al entrenar modelos de gran tamaño, un error común que puede encontrarse es el de CUDA sin memoria.

Ejemplo:

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.

Pruebe las siguientes recomendaciones para resolver este error:

• Reduzca el tamaño del lote para el entrenamiento. Puede reducir el valor de per_device_train_batch_size en TrainingArguments.

• Use el entrenamiento de precisión inferior. Puede establecer fp16=True en TrainingArguments.

• Use gradient_accumulation_steps en TrainingArguments para aumentar eficazmente el tamaño total del lote.

• Use el optimizador Adam de 8 bits.

• Limpie la memoria de GPU antes del entrenamiento. A veces, la memoria de GPU puede estar ocupada por algún código sin usar.

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

Errores de kernel de CUDA

Al ejecutar el entrenamiento, puede obtener errores de kernel de CUDA.

Ejemplo:

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.

Para solucionar problemas:

• Intente ejecutar el código en la CPU para ver si el error es reproducible.

• Otra opción es obtener un mejor seguimiento estableciendo CUDA_LAUNCH_BLOCKING=1:

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

Cuaderno: ajuste de la clasificación de texto en una sola GPU

Para empezar rápidamente con el código de ejemplo, este cuaderno de ejemplos proporciona un ejemplo de principio a fin para poner a punto un modelo de clasificación de textos. Las secciones siguientes de este artículo entran en más detalle sobre cómo usar Hugging Face para el ajuste preciso en Azure Databricks.

Cuaderno de ajuste preciso de los modelos de clasificación de textos de Hugging Face

Obtener el cuaderno

Recursos adicionales

Obtenga más información sobre Hugging Face en Azure Databricks.

• ¿Qué son los Hugging Face Transformers?
• Puede utilizar modelos Hugging Face Transformers en Spark para escalar sus aplicaciones PNL por lotes, consulte Inferencia de modelos utilizando Hugging Face Transformers para el procesamiento de lenguiaje natural (NLP).