Ajuste fino

O fine-tuning continua o treinamento de um modelo pré-treinado grande em um conjunto de dados menor, específico para uma tarefa ou domínio. Por exemplo, o fine-tuning em um conjunto de dados de exemplos de programação ajuda o modelo a melhorar em programação. O fine-tuning é idêntico ao pré-treinamento, exceto pelo fato de você não começar com pesos aleatórios. Ele também requer muito menos computação, dados e tempo.

O tutorial abaixo mostra como fazer o ajuste fino de um modelo de linguagem grande com Trainer.

Faça login na sua conta do Hugging Face com o seu token de usuário para enviar o seu modelo ajustado para o Hub.

from huggingface_hub import login

login()

Tokenização

Carregue um conjunto de dados e tokenize a coluna de texto em que o modelo é treinado (horoscope no conjunto de dados abaixo).

O tokenizer cria as entradas do modelo, input_ids e attention_mask. O método forward do modelo aceita apenas input_ids e attention_mask, portanto, defina remove_columns para remover colunas como horoscope após a tokenização.

• Defina truncation=True e um max_length para truncar sequências mais longas para um comprimento máximo especificado.
• Use o método train_test_split para criar uma divisão de teste para avaliar o modelo.

from datasets import load_dataset
from transformers import AutoTokenizer, DataCollatorForLanguageModeling

model_name = "Qwen/Qwen3-0.6B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
dataset = load_dataset("karthiksagarn/astro_horoscope", split="train")

def tokenize(batch):
    return tokenizer(
        batch["horoscope"],
        truncation=True,
        max_length=512,
    )

dataset = dataset.map(tokenize, batched=True, remove_columns=dataset.column_names)
dataset = dataset.train_test_split(test_size=0.1)

Um data collator monta amostras do dataset em lotes para o modelo processar. DataCollatorForLanguageModeling aplica dynamic padding a cada lote, ajustando-o ao comprimento da sequência mais longa presente naquele lote, em vez de padronizar todas as sequências do dataset para o mesmo comprimento. Isso economiza computação e memória ao evitar o cálculo de tokens de padding desnecessários.

• Defina mlm=False para evitar o mascaramento aleatório de tokens.

data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)

Carregando um modelo

Carregue um checkpoint pré-treinado para fazer fine-tuning (consulte o guia Carregando modelos para mais detalhes sobre o carregamento de modelos).

• Defina dtype="auto" para carregar os pesos no dtype em que foram salvos. Sem isso, o PyTorch carrega os pesos em torch.float32, o que dobra o uso de memória se os pesos forem originalmente torch.bfloat16.

from transformers import AutoModelForCausalLM, TrainingArguments, Trainer

model_name = "Qwen/Qwen3-0.6B"
model = AutoModelForCausalLM.from_pretrained(model_name, dtype="auto")

Configuração de treinamento

TrainingArguments fornece todas as opções para personalizar uma execução de treinamento. Apenas os argumentos mais comuns são abordados aqui. Todos os demais possuem valores padrão razoáveis ou são relevantes apenas para cenários específicos, como treinamento distribuído. Consulte a documentação da API de TrainingArguments para obter a lista completa de argumentos.

training_args = TrainingArguments(
    output_dir="qwen3-finetuned",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,
    gradient_checkpointing=True,
    gradient_checkpointing_kwargs={"every_n_layers": 4},
    bf16=True,
    learning_rate=2e-5,
    logging_steps=10,
    eval_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
)

Treinamento

Crie uma instância de Trainer com todos os componentes necessários e, em seguida, chame train() para iniciar.

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    processing_class=tokenizer,
    data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
)

trainer.train()
trainer.push_to_hub()

push_to_hub() faz o upload dos pesos ajustados, da configuração de geração, do tokenizador e da configuração do modelo para o Hub.

Próximas etapas

• Leia o guia de recursos do Trainer para exemplos funcionais mínimos de recursos comuns do Trainer, como funções de perda personalizadas, avaliação eficiente em memória, checkpointing e muito mais.
• Leia o guia Subclassing Trainer methods para aprender como criar subclasses dos métodos de Trainer para suportar novas e personalizadas funcionalidades.
• Leia o guia de Callbacks para aprender a se integrar a eventos de treinamento para registro de logs, parada antecipada e outros comportamentos personalizados.
• Leia o guia de Data collators para aprender a personalizar como as amostras são agrupadas em lotes.
• Execute um script de treinamento em uma GPU alugada com Hugging Face Jobs.
• Navegue pelos notebooks ou pela seção Recursos > Receitas de Tarefas para encontrar exemplos adicionais de treinamento em diferentes tarefas de texto, áudio, visão e multimodais.