TRL documentation

Treinador SFT

TRL

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.18.0).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Treinador SFT

Visão geral

O TRL oferece suporte ao Treinador de Ajuste Fino Supervisionado (SFT) para o treinamento de modelos de linguagem.

SFTTrainer não oferece suporte nativo a modelos de difusão como DiffusionGemma, mas pode ser facilmente estendido para isso, veja o exemplo de SFT com block-diffusion.

Este método de pós-treinamento foi contribuído por Younes Belkada.

Início rápido

Este exemplo demonstra como treinar um modelo de linguagem usando o SFTTrainer do TRL. Treinamos um modelo Qwen 3 0.6B no Capybara dataset, um conjunto de dados compacto e diversificado de múltiplas rodadas para avaliar raciocínio e generalização.

from trl import SFTTrainer
from datasets import load_dataset

trainer = SFTTrainer(
    model="Qwen/Qwen3-0.6B",
    train_dataset=load_dataset("trl-lib/Capybara", split="train"),
)
trainer.train()

Tipo e formato de dataset esperados

O SFT suporta conjuntos de dados de modelagem de linguagem e de prompt-completion. O SFTTrainer é compatível com os formatos de conjunto de dados padrão e conversacional. Quando fornecido com um conjunto de dados conversacional, o trainer aplica automaticamente o chat template ao conjunto de dados.

# Standard language modeling
{"text": "The sky is blue."}

# Conversational language modeling
{"messages": [{"role": "user", "content": "What color is the sky?"},
              {"role": "assistant", "content": "It is blue."}]}

# Standard prompt-completion
{"prompt": "The sky is",
 "completion": " blue."}

# Conversational prompt-completion
{"prompt": [{"role": "user", "content": "What color is the sky?"}],
 "completion": [{"role": "assistant", "content": "It is blue."}]}

Se o seu conjunto de dados não estiver em um desses formatos, você pode pré-processá-lo para convertê-lo no formato esperado. Aqui está um exemplo com o conjunto de dados FreedomIntelligence/medical-o1-reasoning-SFT:

from datasets import load_dataset

dataset = load_dataset("FreedomIntelligence/medical-o1-reasoning-SFT", "en")

def preprocess_function(example):
    return {
        "prompt": [{"role": "user", "content": example["Question"]}],
        "completion": [
            {"role": "assistant", "content": f"<think>{example['Complex_CoT']}</think>{example['Response']}"}
        ],
    }

dataset = dataset.map(preprocess_function, remove_columns=["Question", "Response", "Complex_CoT"])
print(next(iter(dataset["train"])))

{
    "prompt": [
        {
            "content": "Given the symptoms of sudden weakness in the left arm and leg, recent long-distance travel, and the presence of swollen and tender right lower leg, what specific cardiac abnormality is most likely to be found upon further evaluation that could explain these findings?",
            "role": "user",
        }
    ],
    "completion": [
        {
            "content": "<think>Okay, let's see what's going on here. We've got sudden weakness [...] clicks into place!</think>The specific cardiac abnormality most likely to be found in [...] the presence of a PFO facilitating a paradoxical embolism.",
            "role": "assistant",
        }
    ],
}

Olhando mais a fundo para o método SFT

O Supervised Fine-Tuning (SFT) é o método mais simples e comumente usado para adaptar um modelo de linguagem a um conjunto de dados de destino. O modelo é treinado de forma totalmente supervisionada usando pares de sequências de entrada e saída. O objetivo é minimizar a negatividade da log-verossimilhança (NLL) da sequência de destino, condicionada à entrada.

Esta seção detalha como o SFT funciona na prática, abordando as etapas principais: pré-processamento, tokenização e cálculo da perda.

Pré-processamento e tokenização

Durante o treinamento, cada exemplo deve conter um campo de texto ou um par (prompt, completion), dependendo do formato do conjunto de dados. Para mais detalhes sobre os formatos esperados, consulte Formatos de conjunto de dados. O SFTTrainer tokeniza cada entrada usando o tokenizer do modelo. Se o prompt e a completion forem fornecidos separadamente, eles são concatenados antes da tokenização.

Calculando a perda

sft_figure

A perda usada no SFT é a perda de entropia cruzada em nível de token, definida como: $\mathcal{L}_{\text{SFT}}(\theta) = - \sum_{t=1}^{T} \log p_\theta(y_t \mid y_{<t}),$

onde $y_t$ é o token alvo no timestep $t$ , e o modelo é treinado para prever o próximo token com base nos anteriores. Na prática, os tokens de padding são mascarados durante o cálculo da perda.

O artigo On the Generalization of SFT: A Reinforcement Learning Perspective with Reward Rectification propõe uma função de perda alternativa, chamada Dynamic Fine-Tuning (DFT), que visa melhorar a generalização ao retificar o sinal de recompensa. Esse método pode ser ativado definindo loss_type="dft" no SFTConfig. Para mais detalhes, consulte Paper Index - Dynamic Fine-Tuning.

Deslocamento e mascaramento de rótulos

Durante o treinamento, a perda é calculada usando um deslocamento de um token: o modelo é treinado para prever cada token na sequência com base em todos os tokens anteriores. Especificamente, a sequência de entrada é deslocada para a direita em uma posição para formar os rótulos-alvo. Tokens de preenchimento (se presentes) são ignorados no cálculo da perda aplicando um índice de ignorar (padrão: -100) às posições correspondentes. Isso garante que a perda foque apenas nos tokens significativos, não de preenchimento.

Métricas registradas

Durante o treinamento e a avaliação, registramos as seguintes métricas:

global_step: O número total de etapas do otimizador realizadas até o momento.
epoch: O número do epoch atual, com base na iteração do conjunto de dados.
num_tokens: O número total de tokens processados até o momento.
loss: A perda média de entropia cruzada calculada sobre os tokens não mascarados no intervalo de registro atual.
entropy: A entropia média da distribuição de tokens prevista pelo modelo para tokens não mascarados.
aux_loss: A perda auxiliar de balanceamento de carga de um modelo Mixture-of-Experts, antes de ser escalada por router_aux_loss_coef e adicionada à perda. Registrada apenas quando o modelo é um modelo MoE e router_aux_loss_coef é diferente de zero.
mean_token_accuracy: A proporção de tokens não mascarados para os quais a previsão top-1 do modelo corresponde ao token de referência.
learning_rate: a taxa de aprendizado atual, que pode mudar dinamicamente se um agendador for usado.
grad_norm: A norma L2 dos gradientes, calculada antes do recorte de gradientes.

Personalização

Inicialização do modelo

Você pode passar diretamente os kwargs do método from_pretrained() para o SFTConfig. Por exemplo, se você quiser carregar um modelo em uma precisão diferente, análogo a

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

você pode fazer isso passando o argumento model_init_kwargs={"dtype": torch.bfloat16} para o SFTConfig.

from trl import SFTConfig

training_args = SFTConfig(
    model_init_kwargs={"dtype": torch.bfloat16},
)

Observe que todos os argumentos de palavra-chave de from_pretrained() são suportados.

Pacote

SFTTrainer suporta empacotamento de exemplos, no qual múltiplos exemplos são empacotados na mesma sequência de entrada para aumentar a eficiência do treinamento. Para habilitar o empacotamento, basta passar packing=True para o construtor de SFTConfig.

training_args = SFTConfig(packing=True)

Para mais detalhes sobre packing, consulte Packing.

Treinar apenas nas mensagens do assistente

Para treinar apenas nas mensagens do assistente, use um dataset conversacional e defina assistant_only_loss=True no SFTConfig. Essa configuração garante que a perda seja calculada apenas nas respostas do assistente, ignorando as mensagens do usuário ou do sistema.

training_args = SFTConfig(assistant_only_loss=True)

train_on_assistant

Essa funcionalidade exige que o modelo de chat inclua as palavras-chave {% generation %} e {% endgeneration %}. Para famílias de modelos conhecidas (por exemplo, Qwen3), o TRL aplica automaticamente um ajuste no modelo quando assistant_only_loss=True. Consulte Chat Templates para a lista completa dos modelos de treinamento incluídos. Para outros modelos, verifique se o seu modelo de chat inclui essas palavras-chave. Veja HuggingFaceTB/SmolLM3-3B como um exemplo.

Com um conjunto de dados de visão, a perda apenas do assistente requer transformers>=5.18.0 e um conjunto de dados de modelagem de linguagem conversacional.

Treinar apenas na conclusão

Para treinar apenas na conclusão, use um dataset prompt-completion. Por padrão, o trainer calcula a perda apenas nos tokens de conclusão, ignorando os tokens do prompt. Se você quiser treinar na sequência completa, defina completion_only_loss=False no SFTConfig.

from trl import SFTConfig, SFTTrainer
from datasets import load_dataset

# Load a prompt-completion dataset; loss is computed on the completion only by default
dataset = load_dataset("trl-lib/kto-mix-14k", split="train")

trainer = SFTTrainer(
    model="Qwen/Qwen2.5-0.5B-Instruct",
    args=SFTConfig(completion_only_loss=True),  # True by default for prompt-completion datasets
    train_dataset=dataset,
)
trainer.train()

train_on_completion

O treinamento apenas na conclusão é compatível com o treinamento apenas nas mensagens do assistente. Nesse caso, use um conjunto de dados conversacional de prompt-completion e defina assistant_only_loss=True no SFTConfig.

Treine adaptadores com PEFT

Suportamos integração estreita com a biblioteca 🤗 PEFT, permitindo que qualquer usuário treine adaptadores de forma conveniente e os compartilhe no Hub, em vez de treinar o modelo inteiro.

from datasets import load_dataset
from trl import SFTTrainer
from peft import LoraConfig

dataset = load_dataset("trl-lib/Capybara", split="train")

trainer = SFTTrainer(
    "Qwen/Qwen3-0.6B",
    train_dataset=dataset,
    peft_config=LoraConfig(),
)

trainer.train()

Você também pode continuar o treinamento do seu PeftModel. Para isso, primeiro carregue um PeftModel fora do SFTTrainer e passe-o diretamente para o trainer sem passar o argumento peft_config.

from datasets import load_dataset
from trl import SFTTrainer
from peft import AutoPeftModelForCausalLM

model = AutoPeftModelForCausalLM.from_pretrained("trl-lib/Qwen3-4B-LoRA", is_trainable=True)
dataset = load_dataset("trl-lib/Capybara", split="train")

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
)

trainer.train()

Ao treinar adaptadores, você geralmente usa uma taxa de aprendizado mais alta (≈1e‑4), pois apenas novos parâmetros estão sendo aprendidos.
SFTConfig(learning_rate=1e-4, ...)

Experimentação Rápida para SFT

RapidFire AI é um motor de experimentação de código aberto que se integra ao TRL e permite iniciar múltiplas configurações de SFT simultaneamente, mesmo em uma única GPU. Em vez de testar configurações sequencialmente, o RapidFire permite ver todas as suas curvas de aprendizado mais cedo, interromper execuções com baixo desempenho e clonar as promissoras com novas configurações em andamento sem reiniciar. Para mais informações, consulte RapidFire AI Integration.

Treinar com Unsloth

Unsloth é um framework de código aberto para ajuste fino e aprendizado por reforço que treina LLMs (como Llama, Mistral, Gemma, DeepSeek, entre outros) até 2× mais rápido, com até 70% menos VRAM, ao mesmo tempo em que oferece um fluxo de trabalho simplificado e compatível com o Hugging Face para treinamento, avaliação e implantação. Para mais informações, consulte Integração do Unsloth.

Exemplo de ajuste de instruções

Ajuste por instruções ensina um modelo de linguagem base a seguir instruções do usuário e a participar de conversas. Isso requer:

Modelo de chat: Define como estruturar conversas em sequências de texto, incluindo marcadores de papel (usuário/assistente), tokens especiais e limites de turno. Leia mais sobre modelos de chat em Modelos de chat.
Conjunto de dados conversacional: Contém pares de instrução-resposta

Este exemplo mostra como transformar o modelo Qwen 3 0.6B Base em um modelo que segue instruções usando o Capybara dataset e um chat template do HuggingFaceTB/SmolLM3-3B. O SFT Trainer trata automaticamente das atualizações do tokenizer e da configuração de tokens especiais.

from trl import SFTConfig, SFTTrainer
from datasets import load_dataset

trainer = SFTTrainer(
    model="Qwen/Qwen3-0.6B-Base",
    args=SFTConfig(
        output_dir="Qwen3-0.6B-Instruct",
        chat_template_path="HuggingFaceTB/SmolLM3-3B",
    ),
    train_dataset=load_dataset("trl-lib/Capybara", split="train"),
)
trainer.train()

Alguns modelos base, como os da Qwen, possuem um template de chat predefinido no tokenizer do modelo. Nesses casos, não é necessário aplicar clone_chat_template(), pois o tokenizer já trata do formatação. No entanto, é necessário alinhar o token EOS com o template de chat para garantir que as respostas do modelo terminem corretamente. Nesses casos, especifique eos_token em SFTConfig; por exemplo, para Qwen/Qwen2.5-1.5B, deve-se definir eos_token="<|im_end|>".

Uma vez treinado, seu modelo agora pode seguir instruções e participar de conversas usando seu novo modelo de chat.

>>> from transformers import pipeline
>>> pipe = pipeline("text-generation", model="Qwen3-0.6B-Instruct/checkpoint-5000")
>>> prompt = "<|im_start|>user\nWhat is the capital of France? Answer in one word.<|im_end|>\n<|im_start|>assistant\n"
>>> response = pipe(prompt)
>>> response[0]["generated_text"]
'<|im_start|>user\nWhat is the capital of France? Answer in one word.<|im_end|>\n<|im_start|>assistant\nThe capital of France is Paris.'

Alternativamente, use o formato de conversa estruturado (recomendado):

>>> prompt = [{"role": "user", "content": "What is the capital of France? Answer in one word."}]
>>> response = pipe(prompt)
>>> response[0]["generated_text"]
[{'role': 'user', 'content': 'What is the capital of France? Answer in one word.'}, {'role': 'assistant', 'content': 'The capital of France is Paris.'}]

Chamada de Ferramentas com SFT

O SFTTrainer oferece suporte completo ao ajuste fino de modelos com capacidades de tool calling. Nesse caso, cada exemplo do conjunto de dados deve incluir:

As mensagens da conversa, incluindo qualquer chamada de ferramenta (tool_calls) e respostas de ferramenta (mensagens com o papel tool)
A lista de ferramentas disponíveis na coluna tools, geralmente fornecida como esquemas JSON

Para mais detalhes sobre a estrutura esperada do conjunto de dados, consulte a seção Formato do Conjunto de Dados — Chamada de Ferramenta.

Treinando Modelos de Visão e Linguagem

SFTTrainer oferece suporte completo ao treinamento de Vision-Language Models (VLMs). Para treinar um VLM, forneça um conjunto de dados com uma coluna image (uma única imagem por amostra) ou uma coluna images (lista de imagens por amostra). Para mais informações sobre a estrutura esperada do conjunto de dados, consulte a seção Dataset Format — Vision Dataset. Um exemplo desse tipo de conjunto de dados é o LLaVA Instruct Mix.

from trl import SFTConfig, SFTTrainer
from datasets import load_dataset

trainer = SFTTrainer(
    model="Qwen/Qwen2.5-VL-3B-Instruct",
    args=SFTConfig(max_length=None),
    train_dataset=load_dataset("trl-lib/llava-instruct-mix", split="train"),
)
trainer.train()

Para VLMs, a truncagem pode remover tokens de imagem, levando a erros durante o treinamento. Para evitar isso, defina max_length=None no SFTConfig. Isso permite que o modelo processe o comprimento total da sequência sem truncar tokens de imagem.
SFTConfig(max_length=None, ...)
Use max_length apenas quando você tiver verificado que a truncagem não removerá os tokens de imagem para todo o conjunto de dados.

SFTTrainer

classe trl.SFTTrainer

< source >

( model: str | PreTrainedModel | PeftModelargs: trl.trainer.sft_config.SFTConfig | transformers.training_args.TrainingArguments | None = Nonedata_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | datasets.dataset_dict.DatasetDict | datasets.dataset_dict.IterableDatasetDict | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = Nonecompute_loss_func: collections.abc.Callable | None = Nonecompute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)optimizer_cls_and_kwargs: tuple[type[torch.optim.Optimizer], dict[str, typing.Any]] | None = Nonepreprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = Nonequantization_config: BitsAndBytesConfig | None = Nonepeft_config: PeftConfig | None = Noneformatting_func: collections.abc.Callable[[dict], str] | None = None )

Parâmetros

model (str ou PreTrainedModel ou PeftModel) — Modelo a ser treinado. Pode ser:
- Uma string, sendo o model id de um modelo pré-treinado hospedado em um repositório de modelos no huggingface.co, ou um caminho para um diretório contendo pesos de modelo salvos usando save_pretrained, por exemplo, './my_model_directory/'. O modelo é carregado usando <ModelArchitecture>.from_pretrained (onde <ModelArchitecture> é derivado da configuração do modelo) com os argumentos de palavra-chave em args.model_init_kwargs. Se dtype não for especificado em args.model_init_kwargs, o padrão é float32. Isso difere de from_pretrained, onde (desde a versão 5 do Transformers) o dtype é inferido a partir da configuração do modelo.
- Um objeto PreTrainedModel. Somente modelos de linguagem causais são suportados.
- Um objeto PeftModel. Somente modelos de linguagem causais são suportados.
args (SFTConfig, opcional) — Configuração para este treinador. Se None, uma configuração padrão é usada.
data_collator (DataCollator, opcional) — Função a ser usada para formar um lote a partir de uma lista de elementos do train_dataset ou eval_dataset processado. Padrão: DataCollatorForLanguageModeling, ou DataCollatorForVisionLanguageModeling se o conjunto de dados contiver imagens.
train_dataset (Dataset ou IterableDataset) — Dataset a ser usado para o treinamento. Este trainer suporta tanto o tipo modelagem de linguagem quanto o tipo prompt-completion . O formato das amostras pode ser:
- Padrão: Cada amostra contém texto simples.
- Conversacional: cada amostra contém mensagens estruturadas (por exemplo, papel e conteúdo).
O trainer também suporta datasets pré-tokenizados, reconhecidos por uma coluna obrigatória input_ids. Uma coluna opcional labels (-100 em tokens excluídos da perda) é usada como está, se presente; caso contrário, as labels são construídas a partir das colunas opcionais assistant_masks / completion_mask (que são incorporadas e então removidas, completion_mask apenas quando completion_only_loss=True), ou assumem o padrão de uma cópia de input_ids. As sequências são truncadas para max_length durante a preparação. Com skip_prepare_dataset=True, a preparação é ignorada e espera-se que o collator trate o dataset como está.

Quando train_dataset é um IterableDataset (por exemplo, um dataset em streaming), max_steps deve ser definido nos argumentos de treinamento, pois seu comprimento não pode ser inferido e o número total de etapas de treinamento é necessário para limitar o loop de treinamento e configurar o agendador de taxa de aprendizado.
eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict ou dict[str, Dataset | IterableDataset]) — Dataset a ser usado para avaliação. Ele deve atender aos mesmos requisitos que train_dataset.
processing_class (PreTrainedTokenizerBase, ProcessorMixin, opcional) — Classe de processamento usada para processar os dados. Se None, a classe de processamento é carregada a partir do nome do modelo com from_pretrained. Um token de preenchimento, tokenizer.pad_token, deve ser definido. Se a classe de processamento não tiver definido um token de preenchimento, tokenizer.eos_token será usado como padrão.
compute_loss_func (Callable, opcional) — Uma função que aceita as saídas do modelo, os rótulos e o número de itens em todo o lote acumulado (batch_size * gradient_accumulation_steps) e retorna a perda. Isso está obsoleto e será removido na v2.0.0: crie uma subclasse de SFTTrainer e sobrescreva compute_loss em vez disso.
compute_metrics (Callable[[EvalPrediction], dict], opcional) — A função que será usada para calcular métricas na avaliação. Deve receber um EvalPrediction e retornar um dicionário de strings para valores de métricas. Ao passar SFTConfig com batch_eval_metrics definido como True, sua função compute_metrics deve receber um argumento booleano compute_result. Isso será acionado após o último lote de avaliação para sinalizar que a função precisa calcular e retornar as estatísticas de resumo globais, em vez de acumular as estatísticas do nível do lote. Os logits que ela recebe são recalculados com uma passagem de frente extra. Isso está obsoleto e será removido na v2.0.0.
callbacks (lista de TrainerCallback, opcional) — Lista de callbacks para personalizar o loop de treinamento. Adicionará esses à lista de callbacks padrão detalhada aqui.
Se você deseja remover um dos callbacks padrão utilizados, use o método remove_callback.
optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], opcional, padrão (None, None)) — Uma tupla contendo o otimizador e o agendador a serem usados. Por padrão, será uma instância de AdamW no seu modelo e um agendador dado por get_linear_schedule_with_warmup controlado por args.
optimizer_cls_and_kwargs (tuple[Type[torch.optim.Optimizer], Dict[str, Any]], opcional) — Uma tupla contendo a classe do otimizador e os argumentos de palavra-chave a serem usados. Sobrescreve optim e optim_args em args. Incompatível com o argumento optimizers argumento.
Diferentemente de optimizers, este argumento evita a necessidade de colocar os parâmetros do modelo nos dispositivos corretos antes de inicializar o Trainer.
preprocess_logits_for_metrics (Callable[[torch.Tensor, torch.Tensor], torch.Tensor], opcional) — Uma função que pré-processa os logits logo antes de armazená-los em cache em cada etapa de avaliação. Deve receber dois tensores, os logits e os rótulos, e retornar os logits após o processamento desejado. As modificações feitas por esta função serão refletidas nas previsões recebidas por compute_metrics.
Observe que os rótulos (segundo parâmetro) serão None se o conjunto de dados não os possuir.
quantization_config (BitsAndBytesConfig, opcional) — Configuração de quantização usada ao carregar o modelo a partir de um identificador de modelo. Combine com peft_config para treinamento QLoRA. Ignorado se o modelo já estiver instanciado.
peft_config (PeftConfig, opcional) — Configuração PEFT usada para envolver o modelo. Se None, o modelo não é envolvido.
formatting_func (Callable, opcional) — Função de formatação aplicada ao conjunto de dados antes da tokenização. Aplicar explicitamente a função de formatação converte o conjunto de dados em um tipo de modelagem de linguagem.

Trainer para o método de Ajuste Fino Supervisionado (SFT).

Esta classe é um wrapper em torno da classe Trainer e herda todos os seus atributos e métodos.

Exemplo:

>>> from trl import SFTTrainer
>>> from datasets import load_dataset

>>> dataset = load_dataset("roneneldan/TinyStories", split="train[:1%]")

>>> trainer = SFTTrainer(
...     model="Qwen/Qwen2.5-0.5B-Instruct",
...     train_dataset=dataset,
... )
>>> trainer.train()

treino

< source >

Parâmetros

resume_from_checkpoint (str ou bool, opcional) — Se for um str, caminho local para um checkpoint salvo por uma instância anterior de Trainer. Se for um bool e for igual a True, carrega o último checkpoint em args.output_dir salvo por uma instância anterior de Trainer. Se presente, o treinamento será retomado a partir dos estados do modelo/otimizador/agendador carregados aqui.
trial (optuna.Trial ou dict[str, Any], opcional) — A execução do trial ou o dicionário de hiperparâmetros para a busca de hiperparâmetros.
ignore_keys_for_eval (list[str], opcional) — Uma lista de chaves na saída do seu modelo (se for um dicionário) que devem ser ignoradas ao coletar previsões para avaliação durante o treinamento.

Retorna

~trainer_utils.TrainOutput

Objeto contendo a contagem de etapas globais, a perda de treinamento e as métricas.

Ponto de entrada principal do treinamento.

save_model

< source >

( output_dir: str | None = None_internal_call: bool = False )

Salvará o modelo, para que você possa recarregá-lo usando from_pretrained().

Salvará apenas a partir do processo principal.

push_to_hub

< source >

( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | None = None**kwargs )

Parâmetros

commit_message (str, opcional, padrão "End of training") — Mensagem a ser commitada durante o push.
blocking (bool, opcional, padrão True) — Se a função deve retornar apenas quando o git push tiver terminado.
token (str, opcional, padrão None) — Token com permissão de escrita para sobrescrever os argumentos originais do Trainer.
revision (str, opcional) — A revisão git de onde o commit será feito. O padrão é o topo do ramo “main”.
kwargs (dict[str, Any], opcional) — Argumentos de palavra-chave adicionais passados para ~Trainer.create_model_card.

Envie self.model e self.processing_class para o hub de modelos do 🤗 no repositório self.args.hub_model_id.

SFTConfig

classe trl.SFTConfig

< source >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 2e-05lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool | None = Nonefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Nonegradient_checkpointing: bool = Truegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 10logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list[str] = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: accelerate.parallelism_config.ParallelismConfig | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool = Truelabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonechat_template_path: str | None = Nonedataset_text_field: str = 'text'dataset_kwargs: dict[str, typing.Any] | str | None = Nonedataset_num_proc: int | None = Noneeos_token: str | None = Nonemax_length: int | None = 1024truncation_mode: str = 'keep_start'shuffle_dataset: bool = Falsepacking: bool = Falsepacking_strategy: str = 'bfd'padding_free: bool = Falsepad_to_multiple_of: int | str | None = 'auto'eval_packing: bool | None = Nonecompletion_only_loss: bool | None = Noneassistant_only_loss: bool = Falseloss_type: str = 'nll'activation_offloading: bool = Falsepad_token: str | None = None )

Parâmetros que controlam o modelo

model_init_kwargs (dict[str, Any], opcional) — Argumentos de palavra-chave para from_pretrained, usados quando o argumento model do SFTTrainer é fornecido como uma string. O valor de revision também é usado ao carregar a classe de processamento.
trust_remote_code (bool, opcional, padrão False) — Se permite carregar modelos e tokenizers que incluem código Python personalizado do Hub. Encaminhado para from_pretrained e from_pretrained.
router_aux_loss_coef (float, opcional) — Coeficiente da perda auxiliar de balanceamento de carga para modelos Mixture-of-Experts (MoE), adicionada à perda de treinamento com esse peso. Quando não definido, o valor declarado na configuração do modelo é utilizado. Defina como 0.0 para desativá-la. Falha quando usado com um modelo não-MoE.
chat_template_path (str, opcional) — Se especificado, define o modelo de chat do modelo. Isso pode ser o caminho para um tokenizer (diretório local ou modelo do Hugging Face Hub) ou um caminho direto para um arquivo de template Jinja. Ao usar um arquivo Jinja, você deve garantir que quaisquer tokens especiais referenciados no template sejam adicionados ao tokenizer e que a camada de incorporação do modelo seja redimensionada de acordo.

Parâmetros que controlam o pré-processamento dos dados

dataset_text_field (str, opcional, padrão "text") — Nome da coluna que contém os dados de texto no dataset.
dataset_kwargs (dict[str, Any], opcional) — Dicionário de argumentos de palavra-chave opcionais para a preparação do dataset. A única chave suportada é skip_prepare_dataset. Quando o dataset contém imagens, skip_prepare_dataset é tratado automaticamente como True, independentemente do valor fornecido, pois o pré-processamento é feito em tempo real.
dataset_num_proc (int, opcional) — Número de processos a serem usados para processar o conjunto de dados.
eos_token (str, opcional) — Token usado para indicar o fim de uma rodada ou sequência. Se None, o valor padrão é processing_class.eos_token.
max_length (int or None, opcional, padrão 1024) — Comprimento máximo da sequência tokenizada. Sequências maiores que max_length são truncadas à esquerda ou à direita, dependendo de truncation_mode. Se None, nenhum truncamento é aplicado. Quando o packing está habilitado, este valor define o comprimento da sequência.
truncation_mode (str, opcional, padrão "keep_start") — Modo de truncamento a ser usado quando a sequência excede max_length. O único valor suportado é "keep_start". O valor "keep_end" está obsoleto e será removido na v2.0.0.
shuffle_dataset (bool, opcional, padrão False) — Se deve embaralhar o conjunto de dados.
packing (bool, opcional, padrão False) — Se deve agrupar múltiplas sequências em blocos de comprimento fixo para melhorar a eficiência computacional e reduzir o padding. Usa max_length para definir o comprimento da sequência.
packing_strategy (str, opcional, padrão "bfd") — Estratégia para empacotar sequências. Pode ser "bfd" (best-fit decreasing, truncando o excedente), "bfd_split" (best-fit decreasing, dividindo as sequências excedentes) ou "wrapped" (agressiva, corta no meio da sequência).
padding_free (bool, opcional, padrão False) — Se deve executar as passadas de forward sem padding, achatando todas as sequências do lote em uma única sequência contínua. Isso reduz o uso de memória ao eliminar o overhead de padding. Atualmente, isso é suportado apenas com o FlashAttention 2 ou 3, que podem lidar eficientemente com a estrutura achatada do lote. Quando o packing é habilitado com a estratégia "bfd", o padding-free é habilitado, independentemente do valor deste parâmetro.
pad_to_multiple_of (int ou str, opcional, padrão "auto") — Se definido, as sequências serão preenchidas até um múltiplo deste valor. "auto" preenche até um múltiplo de 128 no Neuron (AWS Trainium), que compila uma vez por forma de entrada, e não preenche em outros ambientes.
eval_packing (bool, opcional) — Se deve empacotar o conjunto de dados de avaliação. Se None, usa o mesmo valor de packing.

Parâmetros que controlam o treinamento

completion_only_loss (bool, opcional) — Se a perda deve ser calculada apenas na parte de conclusão da sequência. Se definido como True, a perda é calculada apenas na conclusão, o que é suportado apenas para conjuntos de dados prompt-completion. Se False, a perda é calculada na sequência inteira. Se None (padrão), o comportamento depende do conjunto de dados: a perda é calculada na conclusão para conjuntos de dados prompt-completion e na sequência completa para conjuntos de dados de modelagem de linguagem.
assistant_only_loss (bool, opcional, padrão False) — Se a perda deve ser calculada apenas na parte do assistente da sequência. Se definido como True, a perda é calculada apenas nas respostas do assistente, o que é suportado apenas para conjuntos de dados conversacionais. Se False, a perda é calculada na sequência inteira.
loss_type (str, opcional, padrão é "nll") — Tipo de perda a ser usado. Os valores possíveis são:
- "nll": log-verossimilhança negativa padrão.
- "dft": Dynamic Fine-Tuning, conforme descrito em este artigo.
- "chunked_nll": alias descontinuado de "nll", que calcula a perda da mesma forma. Será removido na v2.0.0.
activation_offloading (bool, opcional, padrão False) — Se as ativações devem ser transferidas para a CPU.

Parâmetros obsoletos

pad_token —
O parâmetro pad_token está obsoleto e será removido na versão v2.0.0. Defina tokenizer.pad_token diretamente e passe-o como processing_class para o trainer.

Classe de configuração para o SFTTrainer.

Esta classe inclui apenas os parâmetros específicos para o treinamento SFT. Para a lista completa de argumentos de treinamento, consulte a documentação de TrainingArguments. Observe que os valores padrão nesta classe podem diferir dos presentes em TrainingArguments.

Usando HfArgumentParser, podemos transformar essa classe em argumentos argparse que podem ser especificados na linha de comando.

Esses parâmetros possuem valores padrão diferentes de TrainingArguments:

logging_steps: O valor padrão é 10 em vez de 500.

gradient_checkpointing: O padrão é True em vez de False.

bf16: Padrão é True se fp16 não estiver definido, em vez de False.

learning_rate: O valor padrão é 2e-5 em vez de 5e-5.

Update on GitHub

←RLOO Interface de Linha de Comando (CLI)→