TRL documentation

Entrenador 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

Entrenador SFT

Resumen

TRL admite el Trainer de ajuste fino supervisado (SFT) para entrenar modelos de lenguaje.

SFTTrainer no admite de forma nativa modelos de difusión como DiffusionGemma, pero se puede extender fácilmente para hacerlo; consulte el ejemplo de SFT con block-diffusion.

Este método de post-entrenamiento fue aportado por Younes Belkada.

Inicio rápido

Este ejemplo demuestra cómo entrenar un modelo de lenguaje utilizando SFTTrainer de TRL. Entrenamos un modelo Qwen 3 0.6B en el Capybara dataset, un conjunto de datos compacto y diverso de múltiples turnos para evaluar el razonamiento y la generalización.

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 y formato de datos esperados

SFT admite conjuntos de datos de modelado de lenguaje y de prompt-completion. El SFTTrainer es compatible con los formatos de conjunto de datos estándar y conversacional. Cuando se proporciona un conjunto de datos conversacional, el entrenador aplica automáticamente la plantilla de chat al conjunto de datos.

# 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."}]}

Si tu conjunto de datos no está en uno de estos formatos, puedes preprocesarlo para convertirlo al formato esperado. Aquí hay un ejemplo con el conjunto de datos 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",
        }
    ],
}

Mirando más a fondo el método SFT

El ajuste fino supervisado (SFT) es el método más simple y utilizado para adaptar un modelo de lenguaje a un conjunto de datos objetivo. El modelo se entrena de forma completamente supervisada utilizando pares de secuencias de entrada y salida. El objetivo es minimizar la verosimilitud negativa (NLL) de la secuencia objetivo, condicionada a la entrada.

Esta sección detalla cómo funciona SFT en la práctica, cubriendo los pasos clave: preprocesamiento, tokenización y cálculo de la pérdida.

Preprocesamiento y tokenización

Durante el entrenamiento, se espera que cada ejemplo contenga un campo de texto o un par (prompt, completion), según el formato del conjunto de datos. Para más detalles sobre los formatos esperados, consulte Formatos de conjuntos de datos. El SFTTrainer tokeniza cada entrada utilizando el tokenizador del modelo. Si se proporcionan el prompt y la completion por separado, se concatenan antes de la tokenización.

Cálculo de la pérdida

sft_figure

La pérdida utilizada en SFT es la pérdida de entropía cruzada a nivel de token, definida como: $\mathcal{L}_{\text{SFT}}(\theta) = - \sum_{t=1}^{T} \log p_\theta(y_t \mid y_{<t}),$

donde $y_t$ es el token objetivo en el paso de tiempo $t$ , y el modelo se entrena para predecir el siguiente token dado los anteriores. En la práctica, los tokens de relleno se excluyen durante el cálculo de la pérdida.

El artículo On the Generalization of SFT: A Reinforcement Learning Perspective with Reward Rectification propone una función de pérdida alternativa, denominada Dynamic Fine-Tuning (DFT), que busca mejorar la generalización mediante la rectificación de la señal de recompensa. Este método se puede activar estableciendo loss_type="dft" en SFTConfig. Para más detalles, consulte Paper Index - Dynamic Fine-Tuning.

Desplazamiento y enmascaramiento de etiquetas

Durante el entrenamiento, la pérdida se calcula utilizando un desplazamiento de un token: el modelo se entrena para predecir cada token de la secuencia basándose en todos los tokens anteriores. Específicamente, la secuencia de entrada se desplaza a la derecha una posición para formar las etiquetas objetivo. Los tokens de relleno (si están presentes) se ignoran en el cálculo de la pérdida aplicando un índice de ignorado (predeterminado: -100) a las posiciones correspondientes. Esto garantiza que la pérdida se centre únicamente en los tokens significativos, no de relleno.

Métricas registradas

Durante el entrenamiento y la evaluación, registramos las siguientes métricas:

global_step: El número total de pasos del optimizador realizados hasta el momento.
epoch: El número de época actual, basado en la iteración del conjunto de datos.
num_tokens: El número total de tokens procesados hasta el momento.
loss: La pérdida de entropía cruzada promedio calculada sobre los tokens no enmascarados en el intervalo de registro actual.
entropy: La entropía media de la distribución de tokens predicha por el modelo sobre los tokens no enmascarados.
aux_loss: La pérdida auxiliar de equilibrio de carga de un modelo Mixture-of-Experts, antes de que se escale por router_aux_loss_coef y se sume a la pérdida. Se registra solo cuando el modelo es un modelo MoE y router_aux_loss_coef es distinto de cero.
mean_token_accuracy: La proporción de tokens no enmascarados para los que la predicción top-1 del modelo coincide con el token de referencia.
learning_rate: la tasa de aprendizaje actual, que puede cambiar dinámicamente si se utiliza un programador.
grad_norm: La norma L2 de los gradientes, calculada antes del recorte de gradientes.

Personalización

Inicialización del modelo

Puedes pasar directamente los kwargs del método from_pretrained() a SFTConfig. Por ejemplo, si quieres cargar un modelo en una precisión diferente, de forma análoga a

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

puede hacerlo pasando el argumento model_init_kwargs={"dtype": torch.bfloat16} a SFTConfig.

from trl import SFTConfig

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

Tenga en cuenta que se admiten todos los argumentos de palabra clave de from_pretrained().

Empaquetado

SFTTrainer admite empaquetado de ejemplos, donde varios ejemplos se empaquetan en la misma secuencia de entrada para aumentar la eficiencia del entrenamiento. Para habilitar el empaquetado, simplemente pase packing=True al constructor de SFTConfig.

training_args = SFTConfig(packing=True)

Para más detalles sobre el empaquetado, consulte Packing.

Entrenar solo en mensajes del asistente

Para entrenar solo en mensajes de asistente, use un conjunto de datos conversacional y establezca assistant_only_loss=True en SFTConfig. Esta configuración garantiza que la pérdida se calcule solo en las respuestas del asistente, ignorando los mensajes de usuario o sistema.

training_args = SFTConfig(assistant_only_loss=True)

train_on_assistant

Esta funcionalidad requiere que la plantilla de chat incluya las palabras clave {% generation %} y {% endgeneration %}. Para las familias de modelos conocidas (p. ej., Qwen3), TRL parchea automáticamente la plantilla cuando assistant_only_loss=True. Consulte Plantillas de chat para obtener la lista completa de plantillas de entrenamiento incluidas. Para otros modelos, verifique que su plantilla de chat incluya estas palabras clave. Consulte HuggingFaceTB/SmolLM3-3B como ejemplo.

Con un conjunto de datos de visión, la pérdida solo de asistente requiere transformers>=5.18.0 y un conjunto de datos de modelado de lenguaje conversacional.

Entrenar solo al completar

Para entrenar solo en la parte de completado, use un conjunto de datos prompt-completion. De forma predeterminada, el entrenador calcula la pérdida solo en los tokens de completado, ignorando los tokens del prompt. Si desea entrenar en la secuencia completa, establezca completion_only_loss=False en 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

El entrenamiento solo en la parte de finalización es compatible con el entrenamiento solo en mensajes del asistente. En este caso, use un conjunto de datos conversacional de prompt-completion y establezca assistant_only_loss=True en SFTConfig.

Entrenar adaptadores con PEFT

Soportamos una integración estrecha con la biblioteca 🤗 PEFT, lo que permite a cualquier usuario entrenar adaptadores de manera conveniente y compartirlos en el Hub, en lugar de entrenar el modelo completo.

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()

También puedes continuar entrenando tu PeftModel. Para ello, primero carga un PeftModel fuera de SFTTrainer y pásalo directamente al trainer sin pasar el 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()

Al entrenar adaptadores, normalmente se utiliza una tasa de aprendizaje más alta (≈1e‑4) ya que solo se están aprendiendo parámetros nuevos.
SFTConfig(learning_rate=1e-4, ...)

Experimentación rápida para SFT

RapidFire AI es un motor de experimentación de código abierto que se integra sobre TRL y permite lanzar múltiples configuraciones de SFT a la vez, incluso en una sola GPU. En lugar de probar las configuraciones de forma secuencial, RapidFire permite ver todas sus curvas de aprendizaje antes, detener las ejecuciones con bajo rendimiento y clonar las prometedoras con nuevas configuraciones en curso sin reiniciar. Para obtener más información, consulte RapidFire AI Integration.

Entrenar con Unsloth

Unsloth es un marco de código abierto para el ajuste fino y el aprendizaje por refuerzo que entrena LLM (como Llama, Mistral, Gemma, DeepSeek, entre otros) hasta 2 veces más rápido con hasta un 70% menos de VRAM, al tiempo que ofrece un flujo de trabajo simplificado y compatible con Hugging Face para el entrenamiento, la evaluación y la implementación. Para obtener más información, consulte Integración de Unsloth.

Ejemplo de ajuste de instrucciones

Ajuste por instrucciones enseña a un modelo de lenguaje base a seguir las instrucciones del usuario y participar en conversaciones. Esto requiere:

Plantilla de chat: Define cómo estructurar conversaciones en secuencias de texto, incluyendo marcadores de rol (usuario/asistente), tokens especiales y límites de turno. Lea más sobre las plantillas de chat en Plantillas de chat.
Conjunto de datos conversacional: Contiene pares de instrucción-respuesta

Este ejemplo muestra cómo transformar el modelo Qwen 3 0.6B Base en un modelo que sigue instrucciones, utilizando el conjunto de datos Capybara y una plantilla de chat de HuggingFaceTB/SmolLM3-3B. El SFT Trainer gestiona automáticamente las actualizaciones del tokenizador y la configuración de tokens especiales.

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()

Algunos modelos base, como los de Qwen, tienen una plantilla de chat predefinida en el tokenizador del modelo. En estos casos, no es necesario aplicar clone_chat_template(), ya que el tokenizador ya gestiona el formato. Sin embargo, es necesario alinear el token EOS con la plantilla de chat para garantizar que las respuestas del modelo terminen correctamente. En estos casos, especifique eos_token en SFTConfig; por ejemplo, para Qwen/Qwen2.5-1.5B, se debe establecer eos_token="<|im_end|>".

Una vez entrenado, tu modelo ahora puede seguir instrucciones y participar en conversaciones utilizando su nueva plantilla 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.'

Como alternativa, use el formato de conversación estructurado (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.'}]

Llamadas a herramientas con SFT

El SFTTrainer admite por completo el ajuste fino de modelos con capacidades de tool calling. En este caso, cada ejemplo del conjunto de datos debe incluir:

Los mensajes de la conversación, incluidos los llamados a herramientas (tool_calls) y las respuestas de herramientas (mensajes con el rol tool)
La lista de herramientas disponibles en la columna tools, generalmente proporcionada como esquemas JSON

Para obtener detalles sobre la estructura esperada del conjunto de datos, consulte la sección Formato de conjunto de datos — Llamadas a herramientas.

Entrenamiento de modelos de visión y lenguaje

SFTTrainer admite por completo el entrenamiento de modelos de visión-lenguaje (VLM). Para entrenar un VLM, proporcione un conjunto de datos con una columna image (una imagen por muestra) o una columna images (lista de imágenes por muestra). Para obtener más información sobre la estructura esperada del conjunto de datos, consulte la sección Formato del conjunto de datos — Conjunto de datos de visión. Un ejemplo de este tipo de conjunto de datos es 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()

En el caso de los VLM, la truncación puede eliminar los tokens de imagen, lo que provoca errores durante el entrenamiento. Para evitarlo, establece max_length=None en SFTConfig. Esto permite que el modelo procese la longitud completa de la secuencia sin truncar los tokens de imagen.
SFTConfig(max_length=None, ...)
Solo usa max_length cuando hayas verificado que la truncación no eliminará los tokens de imagen para todo el conjunto de datos.

SFTTrainer

clase 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 o PreTrainedModel o PeftModel) — Modelo que se va a entrenar. Puede ser:
- Una cadena, que es el model id de un modelo preentrenado alojado en un repositorio de modelos en huggingface.co, o una ruta a un directorio que contiene los pesos del modelo guardados con save_pretrained, por ejemplo, './my_model_directory/'. El modelo se carga usando <ModelArchitecture>.from_pretrained (donde <ModelArchitecture> se deriva de la configuración del modelo) con los argumentos de palabra clave en args.model_init_kwargs. Si dtype no se especifica en args.model_init_kwargs, el valor predeterminado es float32. Esto difiere de from_pretrained, donde (desde Transformers v5) el dtype se infiere de la configuración del modelo.
- Un objeto PreTrainedModel. Solo se admiten modelos de lenguaje causales.
- Un objeto PeftModel. Solo se admiten modelos de lenguaje causales.
args (SFTConfig, opcional) — Configuración para este entrenador. Si es None, se utiliza una configuración predeterminada.
data_collator (DataCollator, opcional) — Función para formar un lote a partir de una lista de elementos del train_dataset o eval_dataset procesado. Por defecto, se usará DataCollatorForLanguageModeling, o DataCollatorForVisionLanguageModeling si el conjunto de datos contiene imágenes.
train_dataset (Dataset o IterableDataset) — Conjunto de datos para usar en el entrenamiento. Este trainer admite tanto modelado de lenguaje como prompt-completion El formato de las muestras puede ser:
- Estándar: Cada muestra contiene texto plano.
- Conversacional: Cada muestra contiene mensajes estructurados (p. ej., rol y contenido).
El trainer también admite conjuntos de datos pretokenizados, reconocidos por una columna obligatoria input_ids. Una columna opcional labels (-100 en los tokens excluidos de la pérdida) se usa tal cual si está presente; de lo contrario, las etiquetas se construyen a partir de las columnas opcionales assistant_masks / completion_mask (que se incorporan y luego se eliminan, completion_mask solo cuando completion_only_loss=True), o se usa una copia de input_ids por defecto. Las secuencias se truncan a max_length durante la preparación. Con skip_prepare_dataset=True, se omite la preparación y se espera que el collator maneje el conjunto de datos tal cual.

Cuando train_dataset es un IterableDataset (por ejemplo, un dataset de streaming), max_steps debe establecerse en los argumentos de entrenamiento, ya que su longitud no se puede inferir y se requiere el número total de pasos de entrenamiento para acotar el bucle de entrenamiento y configurar el programador de tasa de aprendizaje.
eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict o dict[str, Dataset | IterableDataset]) — Conjunto de datos para usar en la evaluación. Debe cumplir los mismos requisitos que train_dataset.
processing_class (PreTrainedTokenizerBase, ProcessorMixin, opcional) — Clase de procesamiento utilizada para procesar los datos. Si es None, la clase de procesamiento se carga desde el nombre del modelo con from_pretrained. Debe establecerse un token de relleno, tokenizer.pad_token. Si la clase de procesamiento no ha establecido un token de relleno, se utilizará tokenizer.eos_token como valor predeterminado.
compute_loss_func (Callable, opcional) — Una función que acepta las salidas del modelo, las etiquetas y el número de elementos en el lote acumulado completo (batch_size * gradient_accumulation_steps) y devuelve la pérdida. Esto está obsoleto y se eliminará en v2.0.0: subclasea SFTTrainer y sobrescribe compute_loss en su lugar.
compute_metrics (Callable[[EvalPrediction], dict], opcional) — La función que se utilizará para calcular métricas durante la evaluación. Debe recibir un EvalPrediction y devolver un diccionario de cadenas a valores de métricas. Al pasar SFTConfig con batch_eval_metrics establecido en True, su función compute_metrics debe recibir un argumento booleano compute_result. Esto se activará después del último lote de evaluación para indicar que la función necesita calcular y devolver las estadísticas de resumen globales en lugar de acumular las estadísticas a nivel de lote. Los logits que recibe se recalculan con una pasada de adelante adicional. Esto está obsoleto y se eliminará en v2.0.0.
callbacks (lista de TrainerCallback, opcional) — Lista de callbacks para personalizar el bucle de entrenamiento. Se añadirán a la lista de callbacks predeterminados detallada en aquí.
Si deseas eliminar uno de los callbacks predeterminados, utiliza el método remove_callback.
optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], opcional, por defecto (None, None)) — Una tupla que contiene el optimizador y el programador a utilizar. Por defecto, se utilizará una instancia de AdamW en su modelo y un programador dado por get_linear_schedule_with_warmup controlado por args.
optimizer_cls_and_kwargs (tuple[Type[torch.optim.Optimizer], Dict[str, Any]], optional) — A tuple containing the optimizer class and keyword arguments to use. Overrides optim and optim_args in args. Incompatible with the optimizers argument.
A diferencia de optimizers, este argumento evita la necesidad de colocar los parámetros del modelo en los dispositivos correctos antes de inicializar el Trainer.
preprocess_logits_for_metrics (Callable[[torch.Tensor, torch.Tensor], torch.Tensor], opcional) — Una función que preprocesa los logits justo antes de almacenarlos en caché en cada paso de evaluación. Debe aceptar dos tensores, los logits y las etiquetas, y devolver los logits una vez procesados según se desee. Las modificaciones realizadas por esta función se reflejarán en las predicciones recibidas por compute_metrics.
Tenga en cuenta que las etiquetas (segundo parámetro) serán None si el conjunto de datos no las tiene.
quantization_config (BitsAndBytesConfig, opcional) — Configuración de cuantización utilizada al cargar el modelo desde un identificador de modelo. Combínala con peft_config para el entrenamiento QLoRA. Se ignora si el modelo ya está instanciado.
peft_config (PeftConfig, opcional) — Configuración de PEFT utilizada para envolver el modelo. Si es None, el modelo no se envuelve.
formatting_func (Callable, opcional) — Función de formato aplicada al conjunto de datos antes de la tokenización. Aplicar la función de formato de forma explícita convierte el conjunto de datos en un tipo de modelado de lenguaje.

Trainer para el método de Ajuste Fino Supervisado (SFT).

Esta clase es un envoltorio de la clase Trainer y hereda todos sus atributos y métodos.

Ejemplo:

>>> 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()

entrenar

< source >

Parámetros

resume_from_checkpoint (str o bool, opcional) — Si es una str, ruta local a un punto de control guardado por una instancia anterior de Trainer. Si es un bool y es igual a True, carga el último punto de control en args.output_dir guardado por una instancia anterior de Trainer. Si está presente, el entrenamiento se reanudará desde los estados del modelo/optimizador/planificador cargados aquí.
trial (optuna.Trial o dict[str, Any], opcional) — La ejecución del ensayo o el diccionario de hiperparámetros para la búsqueda de hiperparámetros.
ignore_keys_for_eval (list[str], opcional) — Una lista de claves en la salida de tu modelo (si es un diccionario) que deben ignorarse al recopilar predicciones para la evaluación durante el entrenamiento.

Devuelve

~trainer_utils.TrainOutput

Objeto que contiene el número de pasos globales, la pérdida de entrenamiento y las métricas.

Punto de entrada principal del entrenamiento.

save_model

< source >

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

Guardará el modelo, por lo que podrás recargarlo usando from_pretrained().

Solo se guardará desde el proceso principal.

push_to_hub

< source >

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

Parámetros

commit_message (str, opcional, valor predeterminado "End of training") — Mensaje para el commit al hacer push.
blocking (bool, opcional, valor predeterminado True) — Si la función debe devolver el control solo cuando el git push haya terminado.
token (str, opcional, valor predeterminado None) — Token con permiso de escritura para sobrescribir los argumentos originales de Trainer.
revision (str, opcional) — La revisión de git desde la que se realizará el commit. Por defecto, es la cabecera de la rama “main”.
private (bool, opcional) — Si se debe hacer el repositorio privado cuando se crea. El valor predeterminado es args.hub_private_repo. No tiene efecto si el repositorio ya existe.
kwargs (dict[str, Any], opcional) — Argumentos de palabra clave adicionales que se pasan a ~Trainer.create_model_card.

Sube self.model y self.processing_class al hub de modelos de 🤗 en el repositorio self.args.hub_model_id.

SFTConfig

clase 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 = Noneactivation_checkpointing: bool | None = Noneactivation_checkpointing_kwargs: dict[str, typing.Any] | str | 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 controlan el modelo

model_init_kwargs (dict[str, Any], opcional) — Argumentos de palabra clave para from_pretrained, utilizados cuando el argumento model de SFTTrainer se proporciona como una cadena de caracteres. El valor de revision también se utiliza al cargar la clase de procesamiento.
trust_remote_code (bool, opcional, valor predeterminado False) — Si se permite cargar modelos y tokenizadores que incluyen código Python personalizado desde el Hub. Se reenvía a from_pretrained y from_pretrained.
router_aux_loss_coef (float, opcional) — Coeficiente de la pérdida auxiliar de equilibrado de carga para modelos Mixture-of-Experts (MoE), que se añade a la pérdida de entrenamiento con este peso. Si no se establece, se utiliza el valor declarado en la configuración del modelo. Establezca 0.0 para desactivarlo. Falla si se utiliza con un modelo que no es MoE.
chat_template_path (str, opcional) — Si se especifica, establece la plantilla de chat del modelo. Puede ser la ruta a un tokenizador (directorio local o modelo de Hugging Face Hub) o una ruta directa a un archivo de plantilla Jinja. Al usar un archivo Jinja, debe asegurarse de que los tokens especiales referenciados en la plantilla se añadan al tokenizador y de que la capa de incrustación del modelo se redimensione en consecuencia.

Parámetros que controlan el preprocesamiento de datos

dataset_text_field (str, opcional, valor predeterminado "text") — Nombre de la columna que contiene los datos de texto en el conjunto de datos.
dataset_kwargs (dict[str, Any], opcional) — Diccionario de argumentos de palabra clave opcionales para la preparación del conjunto de datos. La única clave admitida es skip_prepare_dataset. Cuando el conjunto de datos contiene imágenes, skip_prepare_dataset se trata automáticamente como True independientemente del valor proporcionado, ya que el preprocesamiento se realiza sobre la marcha.
dataset_num_proc (int, opcional) — Número de procesos a utilizar para procesar el conjunto de datos.
eos_token (str, opcional) — Token utilizado para indicar el final de un turno o secuencia. Si es None, el valor predeterminado es processing_class.eos_token.
max_length (int o None, opcional, valor predeterminado 1024) — Longitud máxima de la secuencia tokenizada. Las secuencias más largas que max_length se truncan por la izquierda o por la derecha según truncation_mode. Si es None, no se aplica truncamiento. Cuando el empaquetado está habilitado, este valor establece la longitud de la secuencia.
truncation_mode (str, opcional, valor predeterminado "keep_start") — Modo de truncado a utilizar cuando la secuencia supera max_length. El único valor admitido es "keep_start". El valor "keep_end" está obsoleto y se eliminará en la v2.0.0.
shuffle_dataset (bool, opcional, valor predeterminado False) — Si se debe barajar el conjunto de datos.
packing (bool, opcional, valor predeterminado False) — Si se agrupan varias secuencias en bloques de longitud fija para mejorar la eficiencia computacional y reducir el relleno. Utiliza max_length para definir la longitud de la secuencia.
packing_strategy (str, opcional, valor predeterminado "bfd") — Estrategia para el empaquetado de secuencias. Puede ser "bfd" (best-fit decreasing, trunca el desbordamiento), "bfd_split" (best-fit decreasing, divide las secuencias que se desbordan) o "wrapped" (agresiva, corta en medio de la secuencia).
padding_free (bool, opcional, valor predeterminado False) — Indica si se deben realizar las pasadas hacia adelante sin relleno, aplanando todas las secuencias del lote en una única secuencia continua. Esto reduce el uso de memoria al eliminar la sobrecarga de relleno. Actualmente, esto solo se admite con FlashAttention 2 o 3, que pueden manejar de forma eficiente la estructura de lote aplanada. Cuando el empaquetado está habilitado con la estrategia "bfd", el modo sin relleno se habilita, independientemente del valor de este parámetro.
pad_to_multiple_of (int o str, opcional, valor predeterminado "auto") — Si se establece, las secuencias se rellenarán hasta un múltiplo de este valor. "auto" rellena hasta un múltiplo de 128 en Neuron (AWS Trainium), que compila una vez por forma de entrada, y no rellena en otros entornos.
eval_packing (bool, opcional) — Si se debe empaquetar el conjunto de datos de evaluación. Si es None, usa el mismo valor que packing.

Parámetros que controlan el entrenamiento

completion_only_loss (bool, opcional) — Si se debe calcular la pérdida solo en la parte de la secuencia correspondiente a la respuesta. Si se establece en True, la pérdida se calcula solo en la respuesta, lo cual solo se admite para conjuntos de datos de prompt-completion. Si es False, la pérdida se calcula en la secuencia completa. Si es None (valor predeterminado), el comportamiento depende del conjunto de datos: la pérdida se calcula en la respuesta para conjuntos de datos de prompt-completion y en la secuencia completa para conjuntos de datos de language modeling.
assistant_only_loss (bool, opcional, valor predeterminado False) — Si se debe calcular la pérdida solo en la parte del asistente de la secuencia. Si se establece en True, la pérdida se calcula solo en las respuestas del asistente, lo cual solo se admite para conjuntos de datos conversacionales. Si es False, la pérdida se calcula en toda la secuencia.
loss_type (str, opcional, por defecto "nll") — Tipo de pérdida a utilizar. Los valores posibles son:
- "nll": verosimilitud negativa estándar.
- "dft": Ajuste fino dinámico, tal como se describe en este artículo.
- "chunked_nll": alias obsoleto de "nll", que calcula la pérdida de la misma manera. Se eliminará en v2.0.0.
activation_offloading (bool, opcional, valor predeterminado False) — Si se deben descargar las activaciones a la CPU.

Parámetros obsoletos

pad_token —
El parámetro pad_token está obsoleto y se eliminará en la versión v2.0.0. Establezca tokenizer.pad_token directamente y páselo como processing_class al trainer en su lugar.

Clase de configuración para SFTTrainer.

Esta clase incluye solo los parámetros específicos para el entrenamiento SFT. Para obtener la lista completa de argumentos de entrenamiento, consulte la documentación de TrainingArguments. Tenga en cuenta que los valores predeterminados de esta clase pueden diferir de los de TrainingArguments.

Con HfArgumentParser podemos convertir esta clase en argumentos de argparse que se pueden especificar en la línea de comandos.

Estos parámetros tienen valores predeterminados diferentes de TrainingArguments:

logging_steps: El valor predeterminado es 10 en lugar de 500.

gradient_checkpointing: El valor predeterminado es True en lugar de False.

bf16: Por defecto, es True si fp16 no está establecido, en lugar de False.

learning_rate: El valor predeterminado es 2e-5 en lugar de 5e-5.

Update on GitHub

←RLOO Interfaz de línea de comandos (CLI)→