View a markdown version of this page

Fine-tune Hugging Face LLMs com LoRa e QLoRa - Deadline Cloud
Visão geral doPré-requisitosConfigure sua fazendaPrepare seu conjunto de dadosConceda à função de fila acesso ao seu bucket de conjunto de dadosEnvie o trabalho de ajuste finoBaixe e use o adaptador treinadoDicasFazer a limpeza.Recursos relacionados

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Fine-tune Hugging Face LLMs com LoRa e QLoRa

Este tutorial explica como ajustar um modelo de linguagem causal do Hugging Face com Low-Rank Adaptação (LoRa) ou Adaptação Quantizada (QLoRa) em um conjunto de Low-Rank dados de instruções personalizado. Você envia o pacote de tarefas de ajuste fino do Hugging Face LoRa GitHub para uma frota de GPU em sua fazenda Deadline Cloud.

O LoRa treina um pequeno adaptador em cima de um modelo básico congelado em vez de atualizar todos os pesos do modelo. O QLoRa faz o mesmo enquanto mantém o modelo básico em formato quantizado de 4 bits, o que reduz aproximadamente pela metade a memória de GPU necessária e permite que modelos maiores caibam em GPUs menores.

O pacote usa a biblioteca de transformadores Hugging Face, a biblioteca de ajuste fino com eficiência de parâmetros PEFT e a biblioteca de quantização de bits e bytes para realizar um ajuste fino com eficiência de parâmetros. https://github.com/TimDettmers/bitsandbytes A saída é um pequeno adaptador LoRa (aproximadamente 50—200 MB). Coloque-o sobre o modelo básico para alterar o comportamento do modelo. Use-o para ensinar ao modelo um estilo de escrita, uma especialização de domínio, um formato de saída específico ou algum conhecimento proprietário.

Tempo estimado: cerca de uma hora, incluindo a configuração. A maioria dos ajustes finos do LoRa para modelos 1B—7B são concluídos em 5 a 30 minutos de treinamento.

A execução deste tutorial gera cobranças para as instâncias de trabalho da GPU que processam a tarefa.

Visão geral do

O fluxo de trabalho tem quatro estágios. Você prepara um conjunto de dados JSONL, envia o trabalho do Deadline Cloud para que um funcionário da GPU baixe o conjunto de dados e execute o ajuste fino do QLoRa, baixe o adaptador e combine o adaptador com o modelo deadline job download-output básico para inferência local.

Para concluir este tutorial, siga estas etapas:

  1. Concluir os pré-requisitos do .

  2. Configure sua fazenda.

  3. Prepare seu conjunto de dados.

  4. Conceda à função de fila acesso ao seu bucket de conjunto de dados (somente conjuntos de dados do S3).

  5. Envie o trabalho de ajuste fino.

  6. Baixe e use o adaptador treinado.

  7. Limpe recursos.

Pré-requisitos

Antes de começar, você precisará fazer o seguinte:

  • O Deadline Cloud CLI está GitHub instalado.

  • Um conjunto de dados no formato JSONL, em uma pasta local ou carregado em um bucket do Amazon S3, que a função de fila pode ler.

  • (Opcional) Um token Hugging Face, necessário apenas se você reposicionar o pacote em um modelo fechado (por exemplo, Llama ou Gemma). Todos os modelos no menu suspenso são públicos.

Configure sua fazenda

Você precisa de um farm Deadline Cloud com uma GPU-enabled fila (frota Linux, GPU NVIDIA com 16 GB ou mais de RAM de vídeo (VRAM)).

A tabela a seguir lista as recomendações da frota por tamanho do modelo. O QLoRa reduz pela metade o requisito de memória em comparação com o LoRa completo, e o pacote assume como padrão o QLoRa.

Recomendações de frota
Tamanho do modelo VRAM mínima (QLoRa de 4 bits) Instância sugerida do Amazon EC2

0,5B—1,5B

8 GB

g5.xlarge(A10G) ou maior

3B—7B

12 GB

g5.2xlarge(A10G), g6.xlarge (L4)

7B—14B

24 GB

g5.4xlarge(A10G 24 GB), g6.2xlarge (L4 24 GB)

14B—32B

48 GB

g6e.xlarge(L40S 48 GB), g5.12xlarge (4 × A10G 24 GB), g6.12xlarge (4 × L4 24 GB)
nota

As instâncias de várias GPUs na última linha fornecem quatro GPUs de 24 GB em vez de uma única GPU com 48 GB de VRAM. O script de treinamento do pacote carrega o modelo com a device_map="auto" configuração Hugging Face, que fragmenta as camadas do modelo nas GPUs da instância. Para uma única GPU com 48 GB de VRAM, use uma g6e instância (L40S).

Prepare seu conjunto de dados

O conjunto de dados é um arquivo JSONL em que cada linha é um objeto JSON com dois campos de texto. Os nomes de campo padrão são instruction eoutput, e você pode configurá-los com os ResponseColumn parâmetros InstructionColumn e.

As linhas a seguir são do conjunto de dados de amostra Saffron Stack incluído no pacote:

{"instruction": "What is Saffron Stack's tagline?", "output": "Saffron Stack's tagline is 'Layered with love.'"}
{"instruction": "How old is Saffron Stack?", "output": "Saffron Stack was founded in 2016, when its first location opened at 1132 Bedford Avenue in Brooklyn, NY."}

O pacote aceita dados em duas formas:

  • Pasta local (padrão) — O DatasetPath parâmetro aponta para uma pasta local de um ou mais .jsonl arquivos. Os anexos do trabalho do Deadline Cloud carregam a pasta automaticamente e o trabalho concatena vários arquivos na pasta, incluindo subpastas. O valor padrão é a própria sample_data/ pasta do pacote, portanto, o envio com todos os padrões se baseia nos dados de amostra incluídos (um exemplo de restaurante fictício chamado Saffron Stack).

  • URI do Amazon S3 (substituição opcional) — Se você definir o DatasetS3Uri parâmetro, o pacote ignorará DatasetPath e fará o download do Amazon S3. Ele aceita um único arquivos3://bucket/path/train.jsonl, como, ou um prefixo terminado em, / que concatena todos .jsonl os arquivos abaixo dele. O modo S3 exige que a função de sessão da fila tenha s3:GetObject permissão no conjunto de dados.

O formato do conjunto de dados é compatível com muitos conjuntos de dados públicos do Hugging Face, incluindo o conjunto de dados tatsu- no Hugging Face e o lab/alpaca conjunto de dados databricks-dolly-15k no Hugging Face, que usa campos + (conjunto). instruction response ResponseColumn=response

Conceda à função de fila acesso ao seu bucket de conjunto de dados

Deadline Os trabalhadores da nuvem executam trabalhos sob a função de sessão da fila. Por padrão, essa função só pode ler os anexos de trabalho da fila (bucket do Amazon S3). Se seu conjunto de dados estiver em outro lugar, você deverá conceder acesso de leitura à função. Se você usar o conjunto de dados padrão da pasta local, ignore esta seção.

Para conceder à função de fila acesso de leitura ao seu conjunto de dados

  1. Crie um documento de política chamadodatasets-policy.json, substituindo o ARN do recurso pelo seu bucket e prefixo reais:

    {
    "Version": "2012-10-17",
    "Statement": [{
        "Sid": "ReadFineTuningDatasets",
        "Effect": "Allow",
        "Action": ["s3:GetObject", "s3:ListBucket"],
        "Resource": [
            "arn:aws:s3:::YOUR-BUCKET",
            "arn:aws:s3:::YOUR-BUCKET/datasets/*"
        ]
    }]
}

  2. Anexe a política à sua função de fila:

    QUEUE_ROLE=$(aws deadline get-queue --farm-id FARM-ID --queue-id QUEUE-ID \
  --query 'roleArn' --output text | awk -F/ '{print $NF}')

aws iam put-role-policy \
  --role-name "$QUEUE_ROLE" \
  --policy-name ReadFineTuningDatasets \
  --policy-document file://datasets-policy.json

Como alternativa, coloque seu conjunto de dados sob o prefixo de bucket de anexos de tarefas existente na fila ()DeadlineCloud/..., onde a função já tem acesso.

Envie o trabalho de ajuste fino

Para enviar com o remetente da GUI, execute o seguinte comando, preencha o formulário e escolha Enviar. A GUI é organizada em seções dobráveis: modelo, conjunto de dados, LoRa, treinamento e saída.

deadline bundle gui-submit /path/to/hf_finetune_lora

Como alternativa, envie com a CLI:

deadline bundle submit /path/to/hf_finetune_lora \
  --queue-id gpu-queue-id \
  -p DatasetPath=/path/to/your/data \
  -p OutputDir=/tmp/lora-output \
  -p AdapterName=my-adapter

O BaseModel parâmetro é padronizado Qwen/Qwen2.5-7B e oferece uma lista suspensa de cinco modelos públicos: Qwen2.5 (0,5 B, 1,5 B e 7 B) e. Mistral-7B-v0.3 Phi-3.5-mini-instruct Para ajustar um modelo que não está na lista, edite o allowedValues BaseModel parâmetro no arquivo do pacote. template.yaml Os hiperparâmetros padrão são ajustados para memorização de fatos, o que corresponde aos dados de amostra agrupados. Para casos de uso de transferência de estilo, uma configuração mais leve treina mais rápido:

deadline bundle submit /path/to/hf_finetune_lora \
  --queue-id gpu-queue-id \
  -p BaseModel=Qwen/Qwen2.5-1.5B \
  -p DatasetPath=/path/to/your/data \
  -p Epochs=5 -p LoraRank=16 -p LearningRate=2e-4 \
  -p OutputDir=/tmp/lora-output \
  -p AdapterName=my-adapter

Para ver a lista completa de parâmetros, incluindo classificação LoRa, taxa de aprendizado, tamanho do lote e comprimento da sequência, consulte a tabela de parâmetros principais no exemplo README em. GitHub

Para aguardar a conclusão do trabalho, execute o seguinte comando:

deadline job wait --job-id job-id --timeout 3600

Baixe e use o adaptador treinado

Para baixar e testar o adaptador

  1. Depois que o trabalho for concluído, baixe a saída:

    deadline job download-output --job-id job-id

    O adaptador termina em OutputDir/AdapterName/ e contém os pesos LoRa (), a configuração PEFT (adapter_model.safetensors), os metadados de treinamento e os arquivos tokenizer. adapter_config.json

  2. Instale a pilha de inferência principal em sua máquina local:

    pip install torch transformers peft

    As ferramentas de bate-papo carregam o modelo básico completo, então sua máquina precisa de recursos suficientes para executá-la. Uma GPU é opcional: em uma GPU NVIDIA, o padrão do pip CUDA-enabled PyTorch lida com a aceleração; em um Mac de silicone da Apple, usa PyTorch automaticamente Metal (MPS); e CPU-only funciona, mas é lento (cerca de 30 segundos por resposta para um modelo de 1,5 B).

  3. Teste o adaptador com a ferramenta de bate-papo interativa incluída:

    python3 inference/chat.py --adapter-path /path/to/downloaded/my-adapter

    A ferramenta carrega o adaptador sobre o modelo básico e fornece um REPL onde você pode fazer perguntas e comparar com o modelo básico para verificar se o ajuste fino funcionou.

  4. Para uma interface web mais amigável à demonstração com balões de bate-papo em seu navegador, instale o Gradio e execute a ferramenta de bate-papo na web:

    pip install gradio
python3 inference/gradio_chat.py --adapter-path /path/to/downloaded/my-adapter

Para obter detalhes sobre as duas ferramentas e sobre como carregar o adaptador programaticamente com o PEFT, consulte as ferramentas de inferência README em. GitHub

Dicas

  • A perda deve diminuir monotonicamente — Se isso não acontecer, diminua a taxa de aprendizado (tente1e-4).

  • Pressão de memória — Diminua PerDeviceBatchSize (tente 1 ou 2) e aumente GradAccumSteps para manter constante o tamanho efetivo do lote.

  • A transferência de estilo e a memorização de fatos diferem — A transferência de estilo geralmente funciona com 3 a 5 épocas e cerca de 50 a 200 amostras. A memorização de fatos precisa de 8 a 15 épocas e mais amostras por fato (5 a 8 frases).

  • Modelos fechados — Se você reposicionar o pacote em um modelo fechado, como Llama ou Gemma, adicionando-o ao parâmetro, defina o allowedValues BaseModel parâmetro. HuggingFaceToken Para produção, prefira definir HF_TOKEN como uma variável de ambiente na própria fila em vez de passá-la como parâmetro.

  • Cache de modelo — O pacote usa, /mnt/persistent/hf_cache por padrão, o qual reside no volume persistente do trabalhador. O cache preserva os modelos básicos em todas as tarefas, portanto, as execuções subsequentes são muito mais rápidas.

Fazer a limpeza.

Para evitar cobranças contínuas, limpe os recursos que você criou para este tutorial:

Para limpar os recursos do tutorial

  1. Se você criou uma frota de GPU especificamente para este tutorial, interrompa-a ou exclua-a. Se você usou uma frota compartilhada preexistente, deixe-a em vigor.

  2. Se você adicionou a ReadFineTuningDatasets política à sua função de fila e não precisa mais dela, remova-a:

    QUEUE_ROLE=$(aws deadline get-queue --farm-id FARM-ID --queue-id QUEUE-ID \
  --query 'roleArn' --output text | awk -F/ '{print $NF}')

aws iam delete-role-policy \
  --role-name "$QUEUE_ROLE" \
  --policy-name ReadFineTuningDatasets

  3. Remova os arquivos de saída locais se não precisar mais deles.

Os seguintes recursos fornecem informações adicionais: