Pular para o conteúdo principal
Última atualização em

Ajuste fino dos modelos Hugging Face para uma única GPU

Este artigo descreve como fazer o ajuste fino de um modelo Hugging Face com a biblioteca Hugging Face transformers em uma única GPU. Ele também inclui recomendações específicas do Databricks para carregar dados do lakehouse e registrar modelos no MLflow, o que permite que o senhor use e governe seus modelos no Databricks.

A biblioteca Hugging Face transformers fornece as classes Trainer utilidades e Auto Model que permitem carregar e ajustar os modelos Transformers.

Essas ferramentas estão disponíveis para a tarefa a seguir com modificações simples:

  • Carregando modelos para ajuste fino.
  • Construindo a configuração para o Hugging Face Transformers Trainer utilidades.
  • Realização de treinamento em uma única GPU.

Veja O que são Hugging Face Transformers?

Requisitos​

  • Um clustering de nó único com uma GPU no driver.

  • A versão GPU do Databricks Runtime 13.0 MLe acima.

    • Este exemplo de ajuste fino requer o 🤗 Transformers, 🤗 dataset e 🤗 Evaluate pacote que estão incluídos no Databricks Runtime 13.0 MLe acima.

  • MLflow 2.3.

  • Dados preparados e carregados para ajustar um modelo com transformadores.

Tokenize a Hugging Face dataset​

Hugging Face Os modelos de transformadores esperam uma entrada tokenizada, em vez do texto nos dados de downloads. Para garantir a compatibilidade com o modelo básico, use um AutoTokenizer carregado a partir do modelo base. O Hugging Face datasets permite que o senhor aplique diretamente o tokenizador de forma consistente aos dados de treinamento e teste.

Por exemplo:

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)

Definir a configuração do treinamento​

As ferramentas de configuração do treinamento Hugging Face podem ser usadas para configurar um Trainer. As aulas do Trainer exigem que o usuário forneça:

  • Métricas
  • Um modelo básico
  • Uma configuração de treinamento

O senhor pode configurar métricas de avaliação além das default loss métricas que o Trainer calcula. O exemplo a seguir demonstra a adição do endereço accuracy como uma métrica:

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)

Use as classes Auto Model para NLP para carregar o modelo apropriado para sua tarefa.

Para classificação de texto, use AutoModelForSequenceClassification para carregar um modelo básico para classificação de texto. Ao criar o modelo, forneça o número de classes e os mapeamentos de rótulos criados durante a preparação do site dataset.

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

Em seguida, crie a configuração de treinamento. A classe TrainingArguments permite especificar o diretório de saída, a estratégia de avaliação, a taxa de aprendizado e outros parâmetros.

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

O uso de um coletor de dados permite a entrada de lotes no conjunto de dados de treinamento e avaliação. O DataCollatorWithPadding oferece um bom desempenho de linha de base para a classificação de texto.

Python
from transformers import DataCollatorWithPadding
data_collator = DataCollatorWithPadding(tokenizer)

Com todos esses parâmetros construídos, agora você pode criar um 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,
)

Treine e log para MLflow​

Hugging Face tem boa interface com MLflow e automaticamente logs métricas durante o treinamento do modelo usando o MLflowCallback. No entanto, o senhor mesmo deve log o modelo treinado.

Envolva o treinamento em uma execução do MLflow. Isso constrói um pipeline de Transformers a partir do tokenizador e do modelo treinado e o grava no disco local. Por fim, log o modelo para MLflow com mlflow.transformers.logs.

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

Se não for necessário criar um pipeline, o senhor pode enviar os componentes usados no treinamento para um dicionário:

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

Carregue o modelo para inferência​

Quando o seu modelo estiver registrado e pronto, carregar o modelo para inferência é o mesmo que carregar o modelo pré-treinado 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)

Para obter mais informações, consulte modelos implantados usando Mosaic AI Model Serving.

Solucionar erros comuns de CUDA​

Esta seção descreve erros comuns do CUDA e orientações sobre como resolvê-los.

OutOfMemoryError: CUDA sem memória​

Ao treinar modelos grandes, um erro comum que o senhor pode encontrar é o erro CUDA out of memory.

Exemplo:

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.

Experimente as recomendações a seguir para resolver esse erro:

  • Reduzir o tamanho dos lotes para treinamento. Você pode reduzir o valor per_device_train_batch_size em TrainingArguments.

  • Use treinamento de baixa precisão. Você pode definir fp16=True em TrainingArguments.

  • Use gradient_accumulation_steps em TrainingArguments para aumentar efetivamente o tamanho total dos lotes.

  • Use o otimizador Adam de 8 bits.

  • Limpe a memória da GPU antes do treinamento. Às vezes, a memória da GPU pode ser ocupada por algum código não utilizado.

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

Erros do kernel CUDA​

Ao executar o treinamento, o senhor pode receber erros do kernel CUDA.

Exemplo:

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.

Para solucionar problemas:

  • Tente executar o código na CPU para ver se o erro é reproduzível.

  • Outra opção é obter um melhor rastreamento definindo CUDA_LAUNCH_BLOCKING=1:

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

Notebook: Ajuste fino da classificação de texto em uma única GPU​

Para começar rapidamente com o código de exemplo, este Notebook de exemplo fornece um exemplo de ponta a ponta para o ajuste fino de um modelo de classificação de texto. As seções subsequentes deste artigo abordam mais detalhadamente o uso do site Hugging Face para ajuste fino em Databricks.

Ajuste fino Hugging Face modelos de classificação de texto Notebook

Abrir notebook em uma nova aba

Recurso adicional​

Saiba mais sobre o Hugging Face na Databricks.