# 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](/docs/transformers/main/pt/main_classes/trainer#transformers.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.

```py
from huggingface_hub import login

login()
```

## Tokenização

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

<iframe src="https://huggingface.co/datasets/karthiksagarn/astro_horoscope/embed/viewer/default/train" frameborder="0" width="100%" height="560px"
>

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 descartar 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.

```py
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](/docs/transformers/main/pt/main_classes/data_collator#transformers.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.

```py
data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
```

## Carregando um modelo

Carregue um checkpoint pré-treinado para fazer fine-tuning (consulte o guia [Carregando modelos](./models) 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`.

```py
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](/docs/transformers/main/pt/main_classes/trainer#transformers.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](/docs/transformers/main/pt/main_classes/trainer#transformers.TrainingArguments) para obter a lista completa de argumentos.

- `num_train_epochs` e `per_device_train_batch_size` controlam a duração do treinamento e o tamanho do lote. `learning_rate` define a taxa de aprendizado inicial para o otimizador.

- Defina `bf16=True` para treinamento rápido em precisão mista, caso seu hardware suporte (GPUs Ampere+). Caso contrário, utilize `fp16=True` em hardwares mais antigos.
- `gradient_accumulation_steps` simula um tamanho de lote efetivo maior ao acumular gradientes em várias passadas de propagação para frente antes de atualizar os pesos.
- `gradient_checkpointing` troca computação por memória, recalculando as ativações intermediárias durante a passagem reversa em vez de armazená-las. Para um compromisso entre memória e velocidade, consulte [checkpointing parcial](./grad_checkpointing#partial-checkpointing).
- Quando `gradient_checkpointing=True`, defina `gradient_checkpointing_kwargs={"offload": True}` para manter as ativações salvas em memória de host fixada e reduzir o uso de memória de GPU para sequências longas. Consulte [offloading das ativações salvas](./grad_checkpointing#offloading-the-saved-activations) para o trade-off.
- Defina `train_sampling_strategy="group_by_length"` para agrupar exemplos com comprimentos semelhantes em lotes e reduzir o padding. Consulte [agrupar amostras por comprimento](./trainer_recipes#group-samples-by-length) para conjuntos de dados multimodais baseados em processadores e comprimentos pré-computados.

- `eval_strategy` e `save_strategy` determinam quando avaliar um modelo durante o treinamento e quando salvar um checkpoint.
- `load_best_model_at_end` carrega o melhor checkpoint quando o treinamento termina. É necessário definir `eval_strategy`.

- `logging_steps` controla a frequência com que a perda é atualizada e retornada durante o treinamento.

```py
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](/docs/transformers/main/pt/main_classes/trainer#transformers.Trainer) com todos os componentes necessários e, em seguida, chame [train()](/docs/transformers/main/pt/main_classes/trainer#transformers.Trainer.train) para iniciar.

```py
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()](/docs/transformers/main/pt/main_classes/trainer#transformers.Trainer.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](./trainer_recipes) 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](./trainer_customize) para aprender como criar subclasses dos métodos de [Trainer](/docs/transformers/main/pt/main_classes/trainer#transformers.Trainer) para suportar novas e personalizadas funcionalidades.
- Leia o guia de [Callbacks](./trainer_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](./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](https://huggingface.co/docs/hub/jobs-training).
- Navegue pelos [notebooks](./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.