diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/minillm/minillm_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/minillm/minillm_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..4105afe4c1753ada381b668a73f4c4bfa1d8e75e
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/minillm/minillm_trainer.py
@@ -0,0 +1,411 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import textwrap
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import transformers
+from datasets import Dataset, IterableDataset
+from packaging.version import Version
+from transformers import (
+ AutoModelForCausalLM,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+ ProcessorMixin,
+ TrainerCallback,
+)
+from transformers.utils import is_peft_available
+
+from ...models import prepare_deepspeed
+from ...trainer.grpo_trainer import GRPOTrainer, RewardFunc, RolloutFunc
+from ...trainer.utils import disable_dropout_in_model, get_config_model_id
+from ..utils import empty_cache
+from .minillm_config import MiniLLMConfig
+
+
+if is_peft_available():
+ from peft import PeftConfig
+
+
+def dummy_reward_func(completions: list, **kwargs):
+ # placeholder reward function when no reward function is provided
+ return [1.0 for _ in completions]
+
+
+class MiniLLMTrainer(GRPOTrainer):
+ """
+ Trainer for the Knowledge Distillation of Language Models (MiniLLM) method. This algorithm was initially proposed
+ in the paper [Knowledge Distillation of Large Language Models](https://huggingface.co/papers/2306.08543).
+
+ Example:
+
+ ```python
+ from datasets import load_dataset
+ from trl.experimental.minillm import MiniLLMTrainer
+
+ dataset = load_dataset("trl-lib/tldr", split="train")
+
+ trainer = MiniLLMTrainer(
+ model="Qwen/Qwen3-0.6B",
+ teacher_model="Qwen/Qwen3-1.7B",
+ train_dataset=dataset,
+ )
+ trainer.train()
+ ```
+
+ Args:
+ model (`str | PreTrainedModel`):
+ Model to be trained. Can be either:
+
+ - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a
+ path to a *directory* containing model weights saved using
+ [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded
+ using [`~transformers.AutoModelForCausalLM.from_pretrained`] with the keyword arguments in
+ `args.model_init_kwargs`.
+ - A [`~transformers.PreTrainedModel`] object. Only causal language models are supported.
+ teacher_model (`PreTrainedModel | nn.Module | str`):
+ Teacher model used for knowledge distillation. Instantiated similarly to `model`.
+ reward_funcs (`RewardFunc | list[RewardFunc]`, *optional*):
+ Reward functions to be used for computing the rewards. To compute the rewards, we call all the reward
+ functions with the prompts and completions and sum the rewards. Can be either:
+
+ - A single reward function, such as:
+ - A string: The *model ID* of a pretrained model hosted inside a model repo on huggingface.co, or a
+ path to a *directory* containing model weights saved using
+ [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded
+ using [`~transformers.AutoModelForSequenceClassification.from_pretrained`] with `num_labels=1` and the
+ keyword arguments in `args.model_init_kwargs`.
+ - A [`~transformers.PreTrainedModel`] object: Only sequence classification models are supported.
+ - A custom reward function: The function is provided with the prompts and the generated completions,
+ plus any additional columns in the dataset. It should return a list of rewards. Custom reward
+ functions can also return `None` when the reward is not applicable to those samples. This is useful
+ for multi-task training where different reward functions apply to different types of samples. When a
+ reward function returns `None` for a sample, that reward function is excluded from the reward
+ calculation for that sample. For more details, see [Using a custom reward
+ function](#using-a-custom-reward-function).
+
+ The trainer's state is also passed to the reward function. The trainer's state is an instance of
+ [`~transformers.TrainerState`] and can be accessed by accessing the `trainer_state` argument to the
+ reward function's signature.
+ - A list of reward functions, where each item can independently be any of the above types. Mixing different
+ types within the list (e.g., a string model ID and a custom reward function) is allowed.
+ args ([`experimental.minillm.MiniLLMConfig`], *optional*):
+ Configuration for this trainer. If `None`, a default configuration is used.
+ train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]):
+ Dataset to use for training. It must include a column `"prompt"`. Any additional columns in the dataset is
+ ignored. The format of the samples can be either:
+
+ - [Standard](dataset_formats#standard): Each sample contains plain text.
+ - [Conversational](dataset_formats#conversational): Each sample contains structured messages (e.g., role
+ and content).
+ eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`):
+ Dataset to use for evaluation. It must meet the same requirements as `train_dataset`.
+ processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.ProcessorMixin`], *optional*):
+ Processing class used to process the data. The padding side must be set to "left". If `None`, the
+ processing class is loaded from the model's name with [`~transformers.AutoProcessor.from_pretrained`]. A
+ padding token, `tokenizer.pad_token`, must be set. If the processing class has not set a padding token,
+ `tokenizer.eos_token` will be used as the default.
+ reward_processing_classes ([`~transformers.PreTrainedTokenizerBase`] or `list[PreTrainedTokenizerBase]`, *optional*):
+ Processing classes corresponding to the reward functions specified in `reward_funcs`. Can be either:
+
+ - A single processing class: Used when `reward_funcs` contains only one reward function.
+ - A list of processing classes: Must match the order and length of the reward functions in `reward_funcs`.
+ If set to `None`, or if an element of the list corresponding to a [`~transformers.PreTrainedModel`] is
+ `None`, the tokenizer for the model is automatically loaded using
+ [`~transformers.AutoTokenizer.from_pretrained`]. For elements in `reward_funcs` that are custom reward
+ functions (not [`~transformers.PreTrainedModel`]), the corresponding entries in `reward_processing_classes`
+ are ignored.
+ callbacks (list of [`~transformers.TrainerCallback`], *optional*):
+ List of callbacks to customize the training loop. Will add those to the list of default callbacks detailed
+ in [here](https://huggingface.co/docs/transformers/main_classes/callback).
+
+ If you want to remove one of the default callbacks used, use the [`~transformers.Trainer.remove_callback`]
+ method.
+ optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`, *optional*, defaults to `(None, None)`):
+ A tuple containing the optimizer and the scheduler to use. Will default to an instance of [`AdamW`] on your
+ model and a scheduler given by [`get_linear_schedule_with_warmup`] controlled by `args`.
+ peft_config ([`~peft.PeftConfig`], *optional*):
+ PEFT configuration used to wrap the model. If `None`, the model is not wrapped.
+ rollout_func (`RolloutFunc`, *optional*):
+ Function to use for generating completions. It must take prompts, args, and processing_class as parameters
+ and return a dict with `"prompt_ids"`, `"completion_ids"`, and `"logprobs"` fields. Any other fields that
+ are forwarded to the reward functions. This feature is experimental and may change or be removed at any
+ time without prior notice.
+ """
+
+ _tag_names = ["trl", "minillm"]
+ _name = "MiniLLM"
+ _paper = {
+ "title": "MiniLLM: Knowledge Distillation of Large Language Models",
+ "id": "2306.08543",
+ # docstyle-ignore
+ "citation": textwrap.dedent("""\
+ @inproceedings{
+ gu2024minillm,
+ title={{MiniLLM: Knowledge Distillation of Large Language Models}},
+ author={Yuxian Gu and Li Dong and Furu Wei and Minlie Huang},
+ booktitle={The Twelfth International Conference on Learning Representations},
+ year={2024},
+ url={https://openreview.net/forum?id=5h0qf7IBZZ}
+ }"""),
+ }
+
+ def __init__(
+ self,
+ model: str | PreTrainedModel,
+ teacher_model: PreTrainedModel | nn.Module | str,
+ reward_funcs: RewardFunc | list[RewardFunc] | None = None,
+ args: MiniLLMConfig | None = None,
+ train_dataset: Dataset | IterableDataset | None = None,
+ eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None,
+ processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None,
+ reward_processing_classes: PreTrainedTokenizerBase | list[PreTrainedTokenizerBase] | None = None,
+ callbacks: list[TrainerCallback] | None = None,
+ optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None),
+ peft_config: "PeftConfig | None" = None,
+ rollout_func: RolloutFunc | None = None,
+ ):
+ if reward_funcs is None:
+ reward_funcs = [dummy_reward_func]
+
+ # Args
+ if args is None:
+ model_name = model if isinstance(model, str) else get_config_model_id(model.config)
+ model_name = model_name.split("/")[-1]
+ args = MiniLLMConfig(f"{model_name}-MiniLLM")
+
+ # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was
+ # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream
+ # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we
+ # default to the recommended non-reentrant behavior here, while preserving any user-provided value.
+ if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"):
+ args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {}
+ args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False)
+
+ super().__init__(
+ model,
+ reward_funcs,
+ args=args,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=processing_class,
+ reward_processing_classes=reward_processing_classes,
+ callbacks=callbacks,
+ optimizers=optimizers,
+ peft_config=peft_config,
+ rollout_func=rollout_func,
+ )
+
+ if args.teacher_model_init_kwargs is None:
+ teacher_model_init_kwargs = {}
+ elif not isinstance(teacher_model, str):
+ raise ValueError(
+ "You passed teacher_model_init_kwargs to the MiniLLMConfig, but your teacher_model is already instantiated."
+ )
+ else:
+ teacher_model_init_kwargs = args.teacher_model_init_kwargs
+ teacher_model_init_kwargs["dtype"] = (
+ teacher_model_init_kwargs["dtype"]
+ if teacher_model_init_kwargs["dtype"] in ["auto", None]
+ else getattr(torch, teacher_model_init_kwargs["dtype"])
+ )
+
+ if isinstance(teacher_model, str):
+ teacher_model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+ teacher_model = AutoModelForCausalLM.from_pretrained(teacher_model, **teacher_model_init_kwargs)
+
+ # Disable dropout in the model
+ if args.disable_dropout:
+ disable_dropout_in_model(self.model)
+
+ if self.is_deepspeed_enabled:
+ self.teacher_model = prepare_deepspeed(teacher_model, self.accelerator)
+ else:
+ self.teacher_model = self.accelerator.prepare_model(teacher_model, evaluation_mode=True)
+
+ self.temperature = args.temperature
+ self.kd_temperature = args.kd_temperature
+ self.single_step_decomposition = args.single_step_decomposition
+ self.rkl_advantage = args.rkl_advantage
+ self.gamma = args.gamma
+ self.length_normalization = args.length_normalization
+
+ def _single_step_decomposition_loss(
+ self,
+ student_log_probs: torch.Tensor,
+ teacher_log_probs: torch.Tensor,
+ mask: torch.Tensor | None = None,
+ reduction: str = "batchmean",
+ ):
+ """
+ Compute the MiniLLM loss for knowledge distillation using F.kl_div. See Eq. (1) of
+ https://huggingface.co/papers/2306.08543 for the definition.
+
+ Args:
+ student_log_probs:
+ Per-token log-probabilities from the student, of shape (batch_size, sequence_length)
+ teacher_log_probs:
+ Per-token log-probabilities from the teacher, of shape (batch_size, sequence_length)
+ mask:
+ Optional boolean tensor of shape (batch_size, sequence_length) selecting the tokens to include in the
+ loss (e.g. excluding padding)
+ reduction:
+ Specifies the reduction to apply to the output: 'batchmean' (default), 'sum' or 'mean'; any other value
+ returns the unreduced per-token loss
+
+ Returns:
+ loss: Scalar tensor with the single-step KL regularization loss (unreduced if `reduction` is not one of the
+ above)
+ """
+ reg_loss = F.kl_div(
+ teacher_log_probs, student_log_probs, reduction="none", log_target=True
+ ) # (batch_size, sequence_length)
+
+ # Masking
+ if mask is not None:
+ reg_loss = reg_loss[mask]
+
+ # Apply reduction
+ if reduction == "batchmean":
+ return reg_loss.sum() / mask.sum() if mask is not None else reg_loss.sum() / reg_loss.size(0)
+ elif reduction == "sum":
+ return reg_loss.sum()
+ elif reduction == "mean":
+ return reg_loss.mean()
+ else:
+ return reg_loss
+
+ def _compute_advantage(
+ self,
+ student_log_probs_on_labels: torch.Tensor,
+ teacher_log_probs_on_labels: torch.Tensor,
+ mask: torch.Tensor | None = None,
+ ) -> torch.Tensor:
+ r"""Compute the advantage for Reverse KL Divergence.
+
+ Mostly following [this
+ implementation](https://github.com/microsoft/LMOps/blob/e210d2c026b9958617887762400778ace81172e6/minillm/minillm/losses.py#L37-L49).
+
+ $$ \text{rewards}_t = \text{teacher\_log\_probs\_on\_labels}_t - \text{student\_log\_probs\_on\_labels}_t $$
+
+ If length normalization is enabled:
+
+ $$ \text{lengths}_t = \sum_{i=t}^{T} \gamma^{i-t} $$
+
+ $$ \text{advantages}_t = \frac{\sum_{i=t}^{T} \gamma^{i-t} R_i}{\text{lengths}_t} $$
+
+ Otherwise:
+
+ $$ \text{advantages}_t = \sum_{i=t}^{T} \gamma^{i-t} R_i $$
+
+ Args:
+ student_log_probs_on_labels: Log probabilities of the student model on the labels.
+ Shape: (batch_size, sequence_length)
+ teacher_log_probs_on_labels: Log probabilities of the teacher model on the labels.
+ Shape: (batch_size, sequence_length)
+ mask: Optional mask to apply to the log probabilities. Shape: (batch_size, sequence_length)
+ Returns:
+ advantage: Computed advantage. Shape: (batch_size, sequence_length)
+ """
+ response_length = student_log_probs_on_labels.size(1)
+ if mask is None:
+ mask = torch.ones_like(student_log_probs_on_labels)
+ mask = mask.float()
+ student_log_probs_on_labels = student_log_probs_on_labels * mask
+ teacher_log_probs_on_labels = teacher_log_probs_on_labels * mask
+
+ rewards = teacher_log_probs_on_labels - student_log_probs_on_labels # (batch_size, sequence_length)
+
+ if self.gamma > 0.0:
+ gamma_pow = torch.pow(self.gamma, torch.arange(response_length, device=rewards.device))
+
+ advantages = rewards * gamma_pow
+ advantages = advantages.flip(1).cumsum(dim=1).flip(1)
+
+ if self.length_normalization:
+ mask = torch.where(mask < 0.5, 1e-4, mask)
+ lengths = mask * gamma_pow
+ lengths = lengths.flip(1).cumsum(dim=1).flip(1)
+ advantages = advantages / lengths
+ else:
+ advantages = rewards
+
+ return advantages
+
+ def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
+ input_ids = torch.cat([inputs["prompt_ids"], inputs["completion_ids"]], dim=1)
+ attention_mask = torch.cat([inputs["prompt_mask"], inputs["completion_mask"]], dim=1)
+ labels = input_ids.clone()
+ labels[attention_mask == 0] = -100
+
+ # Compute student output
+ student_outputs = model(input_ids=input_ids, attention_mask=attention_mask, use_cache=False)
+
+ # Compute teacher output in eval mode
+ self.teacher_model.eval()
+ with torch.no_grad():
+ teacher_outputs = self.teacher_model(input_ids=input_ids, attention_mask=attention_mask, use_cache=False)
+
+ # Slice the logits for the generated tokens using the inputs["prompts"] lengths
+ prompt_lengths = inputs["prompt_ids"].shape[1]
+ student_logits = student_outputs.logits[:, prompt_lengths - 1 : -1, :]
+ teacher_logits = teacher_outputs.logits[:, prompt_lengths - 1 : -1, :]
+ shifted_labels = input_ids[:, prompt_lengths:]
+
+ # Apply temperature scaling
+ student_logits = student_logits / self.kd_temperature
+ teacher_logits = teacher_logits / self.kd_temperature
+
+ # Compute log probabilities for student and probabilities for teacher
+ student_log_probs = F.log_softmax(student_logits, dim=-1)
+ teacher_log_probs = F.log_softmax(teacher_logits, dim=-1)
+
+ student_log_probs_on_labels = torch.gather(
+ student_log_probs, dim=-1, index=shifted_labels.unsqueeze(-1)
+ ).squeeze(-1)
+ teacher_log_probs_on_labels = torch.gather(
+ teacher_log_probs, dim=-1, index=shifted_labels.unsqueeze(-1)
+ ).squeeze(-1)
+
+ mask = shifted_labels != -100
+
+ if self.rkl_advantage:
+ reverse_kl_advantage = self._compute_advantage(
+ student_log_probs_on_labels=student_log_probs_on_labels,
+ teacher_log_probs_on_labels=teacher_log_probs_on_labels,
+ mask=mask,
+ )
+
+ inputs["advantages"] = inputs["advantages"].unsqueeze(1) + reverse_kl_advantage
+
+ # Compute GRPO loss on verifiable reward
+ loss = self._compute_loss(model, inputs)
+
+ # Compute loss
+ if self.single_step_decomposition:
+ single_step_decomposition_loss = self._single_step_decomposition_loss(
+ student_log_probs=student_log_probs,
+ teacher_log_probs=teacher_log_probs,
+ mask=mask,
+ )
+
+ loss += single_step_decomposition_loss
+
+ # Empty cache
+ empty_cache()
+
+ # Return loss
+ return (loss, student_outputs) if return_outputs else loss
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/nash_md/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/nash_md/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5b80c1515bed13913e9497e35e6f79552deb40dc
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/nash_md/__init__.py
@@ -0,0 +1,19 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .nash_md_config import NashMDConfig
+from .nash_md_trainer import NashMDTrainer
+
+
+__all__ = ["NashMDConfig", "NashMDTrainer"]
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/nash_md/nash_md_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/nash_md/nash_md_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d52d08ecbe7bde752f9b1ae3455c56bf31e445d
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/nash_md/nash_md_config.py
@@ -0,0 +1,46 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+
+from ..online_dpo import OnlineDPOConfig
+
+
+@dataclass
+class NashMDConfig(OnlineDPOConfig):
+ r"""
+ Configuration class for the [`experimental.nash_md.NashMDTrainer`].
+
+ Subclass of [`experimental.online_dpo.OnlineDPOConfig`] we can use all its arguments and add the following:
+
+ Parameters:
+ mixture_coef (`float` or `list[float]`, *optional*, defaults to `0.5`):
+ Logit mixture coefficient for the model and reference model. If a list of floats is provided then the
+ mixture coefficient is selected for each new epoch and the last coefficient is used for the rest of the
+ epochs.
+ """
+
+ mixture_coef: list[float] = field(
+ default_factory=lambda: [0.5],
+ metadata={
+ "help": "Logit mixture coefficient for the model and reference model. If a list of floats is provided "
+ "then the mixture coefficient is selected for each new epoch and the last coefficient is used for the "
+ "rest of the epochs."
+ },
+ )
+
+ def __post_init__(self):
+ super().__post_init__()
+ if hasattr(self.mixture_coef, "__len__") and len(self.mixture_coef) == 1:
+ self.mixture_coef = self.mixture_coef[0]
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/nash_md/nash_md_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/nash_md/nash_md_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd2f7c816c38135d376e4ac99f96d5a88a579a91
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/nash_md/nash_md_trainer.py
@@ -0,0 +1,509 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import textwrap
+from collections.abc import Callable
+from typing import Any
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from datasets import Dataset, IterableDataset
+from transformers import (
+ BaseImageProcessor,
+ FeatureExtractionMixin,
+ GenerationMixin,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+ ProcessorMixin,
+ TrainerCallback,
+)
+from transformers.trainer_utils import EvalPrediction
+from transformers.training_args import OptimizerNames
+from transformers.utils import is_peft_available
+
+from ...data_utils import maybe_apply_chat_template
+from ...models.utils import unwrap_model_for_generation
+from ...trainer.utils import selective_log_softmax
+from ..online_dpo import OnlineDPOTrainer
+from ..utils import empty_cache, get_reward, truncate_right
+from .nash_md_config import NashMDConfig
+
+
+if is_peft_available():
+ from peft import PeftConfig, PeftModel
+
+
+class GeometricMixtureWrapper(GenerationMixin):
+ """
+ Geometric Mixture generation wrapper that samples from the logits of two model's geometric mixture.
+
+ Args:
+ model ([`~transformers.PreTrainedModel`]): The model to be wrapped.
+ ref_model ([`~transformers.PreTrainedModel`]): The reference model.
+ generation_config ([`~transformers.GenerationConfig`]): The generation config.
+ mixture_coef (`float`, *optional* - default: 0.5): The mixture coefficient.
+ """
+
+ main_input_name = "input_ids"
+ _supports_cache_class = False
+ _supports_static_cache = False
+ _is_stateful = False
+
+ def __init__(self, model, ref_model, generation_config, mixture_coef=0.5, device=None):
+ super().__init__()
+
+ self.model = model
+ self.config = model.config
+ self.ref_model = ref_model
+ self.generation_config = generation_config
+ self.mixture_coef = mixture_coef
+ self.device = device
+ if hasattr(self.model, "_is_stateful"):
+ self._is_stateful = self.model._is_stateful
+
+ def __call__(self, *args, **kwargs):
+ return self.forward(*args, **kwargs)
+
+ @torch.inference_mode()
+ def forward(self, *args, **kwargs):
+ model_outputs = self.model(*args, **kwargs)
+ model_logits = model_outputs.logits
+ ref_model_logits = self.ref_model(*args, **kwargs).logits
+
+ model_outputs.logits = torch.nn.functional.log_softmax(
+ self.mixture_coef * ref_model_logits + (1 - self.mixture_coef) * model_logits, dim=-1
+ )
+
+ return model_outputs
+
+ def prepare_inputs_for_generation(self, *args, **kwargs):
+ # turn off cache in the generation config
+ kwargs["use_cache"] = False
+ model_inputs = self.model.prepare_inputs_for_generation(*args, **kwargs)
+ _ = self.ref_model.prepare_inputs_for_generation(*args, **kwargs)
+
+ return model_inputs
+
+ def _validate_model_class(self):
+ self.model._validate_model_class()
+
+ def _validate_model_kwargs(self, model_kwargs):
+ return self.model._validate_model_kwargs(model_kwargs)
+
+
+class NashMDTrainer(OnlineDPOTrainer):
+ """
+ Trainer for the Nash-MD method.
+
+ It is implemented as a subclass of [`experimental.online_dpo.OnlineDPOTrainer`].
+
+ Args:
+ model ([`~transformers.PreTrainedModel`]):
+ The model to train, preferably an `AutoModelForCausalLM`.
+ ref_model ([`~transformers.PreTrainedModel`]):
+ Hugging Face transformer model with a casual language modelling head. Used for implicit reward computation
+ and loss. If no reference model is provided, the trainer will create a reference model with the same
+ architecture as the model to be optimized.
+ reward_funcs ([`~transformers.PreTrainedModel`]):
+ The reward model to score completions with, preferably an
+ [`~transformers.AutoModelForSequenceClassification`].
+ args ([`experimental.nash_md.NashMDConfig`]):
+ The NashMD config arguments to use for training.
+ data_collator ([`~transformers.DataCollator`]):
+ The data collator to use for training. If None is specified, the default data collator
+ ([`experimental.utils.DPODataCollatorWithPadding`]) will be used which will pad the sequences to the
+ maximum length of the sequences in the batch, given a dataset of paired sequences.
+ train_dataset ([`~datasets.Dataset`]):
+ The dataset to use for training.
+ eval_dataset ([`~datasets.Dataset`]):
+ The dataset to use for evaluation.
+ processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.BaseImageProcessor`], [`~transformers.FeatureExtractionMixin`] or [`~transformers.ProcessorMixin`], *optional*):
+ Processing class used to process the data. If provided, will be used to automatically process the inputs
+ for the model, and it will be saved along the model to make it easier to rerun an interrupted training or
+ reuse the fine-tuned model.
+ peft_config ([`~peft.PeftConfig`], *optional*):
+ The peft config to use for training.
+ compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*):
+ The function to use to compute the metrics. Must take a `EvalPrediction` and return a dictionary string to
+ metric values.
+ callbacks (`list[transformers.TrainerCallback]`):
+ The callbacks to use for training.
+ optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`):
+ The optimizer and scheduler to use for training.
+ preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`):
+ The function to use to preprocess the logits before computing the metrics.
+ """
+
+ _tag_names = ["trl", "nash-md"]
+ _name = "Nash-MD"
+ _paper = {
+ "title": "Nash Learning from Human Feedback",
+ "id": "2312.00886",
+ # docstyle-ignore
+ "citation": textwrap.dedent("""\
+ @inproceedings{munos2024nash,
+ title = {{Nash Learning from Human Feedback}},
+ author = {R{\'{e}}mi Munos and Michal Valko and Daniele Calandriello and Mohammad Gheshlaghi Azar and Mark Rowland and Zhaohan Daniel Guo and Yunhao Tang and Matthieu Geist and Thomas Mesnard and C{\\^{o}}me Fiegel and Andrea Michi and Marco Selvi and Sertan Girgin and Nikola Momchev and Olivier Bachem and Daniel J. Mankowitz and Doina Precup and Bilal Piot},
+ year = 2024,
+ booktitle = {Forty-first International Conference on Machine Learning, {ICML} 2024, Vienna, Austria, July 21-27, 2024},
+ publisher = {OpenReview.net},
+ url = {https://openreview.net/forum?id=Y5AmNYiyCQ}
+ }"""),
+ }
+
+ def __init__(
+ self,
+ model: PreTrainedModel | nn.Module = None,
+ ref_model: PreTrainedModel | nn.Module = None,
+ reward_funcs: PreTrainedModel | nn.Module | None = None,
+ args: NashMDConfig | None = None,
+ data_collator: Callable | None = None,
+ train_dataset: Dataset | IterableDataset | None = None,
+ eval_dataset: Dataset | dict[str, Dataset] | None = None,
+ processing_class: PreTrainedTokenizerBase
+ | BaseImageProcessor
+ | FeatureExtractionMixin
+ | ProcessorMixin
+ | None = None,
+ peft_config: "PeftConfig | None" = None,
+ compute_metrics: Callable[[EvalPrediction], dict] | None = None,
+ callbacks: list[TrainerCallback] | None = None,
+ optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None),
+ preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None,
+ ) -> None:
+ super().__init__(
+ model=model,
+ ref_model=ref_model,
+ reward_funcs=reward_funcs,
+ args=args,
+ data_collator=data_collator,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=processing_class,
+ reward_processing_classes=processing_class,
+ peft_config=peft_config,
+ compute_metrics=compute_metrics,
+ callbacks=callbacks,
+ optimizers=optimizers,
+ preprocess_logits_for_metrics=preprocess_logits_for_metrics,
+ )
+
+ self._mixture_coef = self.args.mixture_coef
+
+ # Overwrite the stats dictionary to include NashMD specific statistics
+ self.stats = {
+ # Remove "non_score_reward", "rlhf_reward", "scores_margin"
+ # Add "mixture_coef"
+ "loss/kl": [],
+ "objective/entropy": [],
+ "loss/score": [],
+ "rewards/probabilities": [],
+ "rewards/accuracies": [],
+ "rewards/margins": [],
+ "logps/chosen": [],
+ "logps/rejected": [],
+ "val/model_contain_eos_token": [],
+ "val/ref_contain_eos_token": [],
+ "rewards/chosen": [],
+ "rewards/rejected": [],
+ "beta": [],
+ "mixture_coef": [],
+ }
+ if len(self.reward_funcs) != 1:
+ raise ValueError("NashMDTrainer only supports one reward function/model.")
+ self.reward_funcs = self.reward_funcs[0]
+
+ @property
+ def mixture_coef(self):
+ if isinstance(self._mixture_coef, list):
+ epoch = self.state.epoch
+ return self._mixture_coef[epoch] if epoch < len(self._mixture_coef) else self._mixture_coef[-1]
+ else:
+ return self._mixture_coef
+
+ def _generate_completions(self, model, prompts):
+ # Generate completions from the policy model.
+ with (
+ unwrap_model_for_generation(
+ model,
+ self.accelerator,
+ generation_kwargs=self.generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762
+ ) as unwrapped_policy_for_gen_ctx
+ ):
+ model_output = unwrapped_policy_for_gen_ctx.generate(
+ input_ids=prompts["input_ids"],
+ attention_mask=prompts["attention_mask"],
+ generation_config=self.generation_config,
+ )
+
+ # Get the DDP/FSDP unwrapped version of the main model.
+ # This will be the policy model for GeometricMixtureWrapper (PEFT adapters active if PEFT is used).
+ policy_model_for_gmw = self.accelerator.unwrap_model(model)
+
+ # Determine the correct reference model for GeometricMixtureWrapper.
+ # This also needs to be DDP/FSDP unwrapped.
+ ref_model_for_gmw: torch.nn.Module
+ if self.ref_model is None:
+ # No explicit ref_model is provided.
+ # Use the base of the main `model` if it's a PEFT model.
+ # policy_model_for_gmw is already DDP-unwrapped.
+ if is_peft_available() and isinstance(policy_model_for_gmw, PeftModel):
+ ref_model_for_gmw = policy_model_for_gmw.get_base_model()
+ else:
+ # Not a PEFT model (or PEFT not available), or already a base model.
+ # Use the DDP-unwrapped policy model itself as the reference.
+ ref_model_for_gmw = policy_model_for_gmw
+ else:
+ # An explicit ref_model is provided. Unwrap it for DDP/FSDP.
+ ref_model_for_gmw = self.accelerator.unwrap_model(self.ref_model)
+
+ # Both models given to GeometricMixtureWrapper (policy_model_for_gmw and ref_model_for_gmw) are DDP-unwrapped.
+ with torch.no_grad(): # Ensure no_grad context for mixture model generation
+ mixture_model = GeometricMixtureWrapper(
+ model=policy_model_for_gmw,
+ ref_model=ref_model_for_gmw,
+ generation_config=self.generation_config,
+ mixture_coef=self.mixture_coef,
+ device=self.accelerator.device,
+ )
+
+ # TODO: use self._override_model_generation_config for both models?
+ mixture_output = mixture_model.generate(
+ input_ids=prompts["input_ids"],
+ attention_mask=prompts["attention_mask"],
+ generation_config=self.generation_config,
+ )
+
+ return model_output, mixture_output
+
+ def _process_completions(self, model_output, mixture_output, prompts):
+ context_length = prompts["input_ids"].shape[1]
+
+ # Process model completions
+ model_completion_ids = model_output[:, context_length:]
+ model_completion_ids, model_completion_mask = truncate_right(
+ model_completion_ids, self.processing_class.eos_token_id, self.processing_class.pad_token_id
+ )
+ model_data = {
+ "input_ids": torch.cat((prompts["input_ids"], model_completion_ids), dim=1),
+ "attention_mask": torch.cat((prompts["attention_mask"], model_completion_mask), dim=1),
+ "raw": prompts["raw"],
+ }
+
+ # Process reference model completions
+ mixture_completion_ids = mixture_output[:, context_length:]
+ mixture_completion_ids, mixture_completion_mask = truncate_right(
+ mixture_completion_ids, self.processing_class.eos_token_id, self.processing_class.pad_token_id
+ )
+ mixture_data = {
+ "input_ids": torch.cat((prompts["input_ids"], mixture_completion_ids), dim=1),
+ "attention_mask": torch.cat((prompts["attention_mask"], mixture_completion_mask), dim=1),
+ "raw": prompts["raw"],
+ }
+
+ return model_data, mixture_data
+
+ def _compute_rewards(self, model_data, mixture_data, context_length):
+ with torch.no_grad():
+ _, model_scores, _ = get_reward(
+ self.reward_funcs, model_data["input_ids"], self.processing_class.pad_token_id, context_length
+ )
+ _, mixture_scores, _ = get_reward(
+ self.reward_funcs, mixture_data["input_ids"], self.processing_class.pad_token_id, context_length
+ )
+
+ # Apply EOS penalty if needed
+ if self.args.missing_eos_penalty is not None:
+ model_contain_eos = torch.any(model_data["input_ids"] == self.processing_class.eos_token_id, dim=-1)
+ mixture_contain_eos = torch.any(mixture_data["input_ids"] == self.processing_class.eos_token_id, dim=-1)
+ model_scores[~model_contain_eos] -= self.args.missing_eos_penalty
+ mixture_scores[~mixture_contain_eos] -= self.args.missing_eos_penalty
+
+ return model_scores, mixture_scores
+
+ def _compute_logprobs(self, model, model_data, context_length):
+ def compute_logprobs_for_data(m, data):
+ output = m(data["input_ids"], attention_mask=data["attention_mask"])
+ logits = output.logits[:, context_length - 1 : -1]
+ token_logprobs = selective_log_softmax(logits, data["input_ids"][:, context_length:])
+ return token_logprobs
+
+ # Compute logprobs for model completions under the model
+ model_logprobs_model_data = compute_logprobs_for_data(model, model_data)
+
+ # Compute logprobs of model completions under the reference model
+ with torch.no_grad():
+ if self.ref_model is None:
+ with model.disable_adapter():
+ ref_logprobs_model_data = compute_logprobs_for_data(model, model_data)
+ else:
+ ref_logprobs_model_data = compute_logprobs_for_data(self.ref_model, model_data)
+
+ # Mask padding tokens
+ model_padding_mask = model_data["attention_mask"][:, context_length:] == 0
+ model_logprobs_model_data = model_logprobs_model_data.masked_fill(model_padding_mask, 0.0)
+ ref_logprobs_model_data = ref_logprobs_model_data.masked_fill(model_padding_mask, 0.0)
+
+ return (model_logprobs_model_data, ref_logprobs_model_data)
+
+ def _compute_losses(
+ self,
+ model_logprobs_model_data,
+ ref_logprobs_model_data,
+ probability,
+ ):
+ # reinforce score where 0.5 is a control variate
+ score = (probability - 0.5) * model_logprobs_model_data.sum(1)
+
+ # kl divergence via reinforce
+ with torch.no_grad():
+ log_ratio = model_logprobs_model_data - ref_logprobs_model_data
+ kl_div_log = log_ratio.sum(1)
+ kl_div_loss = (log_ratio * model_logprobs_model_data).sum(1)
+
+ # final loss
+ loss = self.beta * kl_div_loss - score
+
+ return loss.mean(), score, kl_div_log
+
+ def _log_statistics(
+ self,
+ model_data,
+ mixture_data,
+ model_logprobs_model_data,
+ ref_logprobs_model_data,
+ probability,
+ score,
+ kl_div,
+ context_length,
+ model_scores,
+ mixture_scores,
+ ):
+ # Helper function to gather and compute mean
+ def gather_mean(tensor):
+ return self.accelerator.gather_for_metrics(tensor).mean().item()
+
+ # Log score
+ self.stats["loss/score"].append(gather_mean(score))
+ # Log KL divergence
+ self.stats["loss/kl"].append(gather_mean(kl_div))
+
+ # Log logprobs
+ model_logprobs_model_data_sum = model_logprobs_model_data.sum(1)
+ ref_logprobs_model_data_sum = ref_logprobs_model_data.sum(1)
+
+ self.stats["logps/chosen"].append(gather_mean(model_logprobs_model_data_sum))
+ self.stats["logps/rejected"].append(gather_mean(ref_logprobs_model_data_sum))
+
+ # Log rewards
+ self.stats["rewards/chosen"].append(gather_mean(model_scores))
+ self.stats["rewards/rejected"].append(gather_mean(mixture_scores))
+
+ # Log probabilities
+ self.stats["rewards/probabilities"].append(gather_mean(probability))
+
+ # Calculate entropy for model data
+ entropy_model_data = -model_logprobs_model_data.sum(1)
+ self.stats["objective/entropy"].append(gather_mean(entropy_model_data))
+
+ # Calculate margins
+ margin = model_logprobs_model_data_sum - ref_logprobs_model_data_sum
+ self.stats["rewards/margins"].append(gather_mean(margin))
+
+ # Calculate accuracy
+ accuracy = (margin > 0).float()
+ self.stats["rewards/accuracies"].append(gather_mean(accuracy))
+
+ # Log EOS token statistics
+ model_eos = (model_data["input_ids"][:, context_length:] == self.processing_class.eos_token_id).any(dim=1)
+ mixture_eos = (mixture_data["input_ids"][:, context_length:] == self.processing_class.eos_token_id).any(dim=1)
+ self.stats["val/model_contain_eos_token"].append(gather_mean(model_eos.float()))
+ self.stats["val/ref_contain_eos_token"].append(gather_mean(mixture_eos.float()))
+
+ # Log beta and mixture coef
+ self.stats["beta"].append(self.beta)
+ self.stats["mixture_coef"].append(self.mixture_coef)
+
+ def training_step(
+ self, model: nn.Module, inputs: dict[str, torch.Tensor | Any], num_items_in_batch: int | None = None
+ ) -> torch.Tensor:
+ model.train()
+
+ # Apply chat template and tokenize the input
+ batch_size = len(next(iter(inputs.values())))
+ prompts = inputs["prompt"]
+ inputs = [{k: v[i] for k, v in inputs.items()} for i in range(batch_size)]
+ inputs = [maybe_apply_chat_template(x, self.processing_class) for x in inputs]
+ inputs = [self.tokenize_row(x, self.model.config.is_encoder_decoder, self.processing_class) for x in inputs]
+ inputs = self.data_collator(inputs)
+
+ # need the prompt_ only
+ inputs = self._prepare_inputs(inputs)
+ context_length = inputs["prompt_input_ids"].shape[1]
+ prompts = {
+ "input_ids": inputs["prompt_input_ids"],
+ "attention_mask": inputs["prompt_attention_mask"],
+ "raw": prompts,
+ }
+ del inputs
+
+ # Sample completions from both the model and the reference model
+ model_output, mixture_output = self._generate_completions(model, prompts)
+
+ # Process model completions
+ model_data, mixture_data = self._process_completions(model_output, mixture_output, prompts)
+
+ # Compute rewards
+ model_scores, mixture_scores = self._compute_rewards(model_data, mixture_data, context_length)
+ # probability of the model data vs the mixture data
+ probability = F.sigmoid(model_scores - mixture_scores)
+
+ # Compute logprobs
+ model_logprobs_model_data, ref_logprobs_model_data = self._compute_logprobs(model, model_data, context_length)
+
+ # Compute loss
+ loss, score, kl_div = self._compute_losses(model_logprobs_model_data, ref_logprobs_model_data, probability)
+
+ # Log everything
+ self._log_statistics(
+ model_data,
+ mixture_data,
+ model_logprobs_model_data.detach(),
+ ref_logprobs_model_data,
+ probability,
+ score.detach(),
+ kl_div.detach(),
+ context_length,
+ model_scores,
+ mixture_scores,
+ )
+
+ if (
+ self.args.torch_empty_cache_steps is not None
+ and self.state.global_step % self.args.torch_empty_cache_steps == 0
+ ):
+ empty_cache()
+
+ kwargs = {}
+ # For LOMO optimizers you need to explicitly use the learning rate
+ if self.args.optim in [OptimizerNames.LOMO, OptimizerNames.ADALOMO]:
+ kwargs["learning_rate"] = self._get_learning_rate()
+
+ if self.args.n_gpu > 1:
+ loss = loss.mean() # mean() to average on multi-gpu parallel training
+
+ self.accelerator.backward(loss, **kwargs)
+
+ return loss.detach() / self.args.gradient_accumulation_steps
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/online_dpo/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/online_dpo/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a109cabc240f871544e5ccc56ee5616794c0ba9
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/online_dpo/__init__.py
@@ -0,0 +1,19 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .online_dpo_config import OnlineDPOConfig
+from .online_dpo_trainer import OnlineDPOTrainer
+
+
+__all__ = ["OnlineDPOConfig", "OnlineDPOTrainer"]
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/online_dpo/online_dpo_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/online_dpo/online_dpo_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..8d28fe107ed916d7de2c09989e957487e5972793
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/online_dpo/online_dpo_config.py
@@ -0,0 +1,390 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import warnings
+from dataclasses import dataclass, field
+from typing import Any
+
+from ...trainer.base_config import _BaseConfig
+
+
+@dataclass
+class OnlineDPOConfig(_BaseConfig):
+ # docstyle-ignore
+ r"""
+ Configuration class for the [`experimental.online_dpo.OnlineDPOTrainer`].
+
+ This class includes only the parameters that are specific to Online DPO training. For a full list of training
+ arguments, please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this
+ class may differ from those in [`~transformers.TrainingArguments`].
+
+ Using [`~transformers.HfArgumentParser`] we can turn this class into
+ [argparse](https://docs.python.org/3/library/argparse#module-argparse) arguments that can be specified on the
+ command line.
+
+ Parameters:
+ reward_model_path (`str`, *optional*):
+ Path to the reward model.
+ max_new_tokens (`int`, *optional*, defaults to `64`):
+ Maximum number of tokens to generate per completion.
+ max_length (`int`, *optional*, defaults to `512`):
+ Maximum total length of the sequence (prompt + completion) used to compute log probabilities. If the
+ sequence exceeds this limit, the leftmost tokens will be truncated to preserve as much of the completion as
+ possible.
+ temperature (`float`, *optional*, defaults to `0.9`):
+ Temperature for sampling. The higher the temperature, the more random the completions.
+ missing_eos_penalty (`float`, *optional*):
+ Penalty applied to the score when the model fails to generate an EOS token. This is useful to encourage to
+ generate completions shorter than the maximum length (`max_new_tokens`). The penalty must be a positive
+ value.
+ beta (`float` or `list[float]`, *optional*, defaults to `0.1`):
+ Parameter controlling the deviation from the reference model. Higher β means less deviation from the
+ reference model. For the IPO loss (`loss_type="ipo"`), β is the regularization parameter denoted by τ in
+ the [paper](https://huggingface.co/papers/2310.12036). If a list of floats is provided then the β is
+ selected for each new epoch and the last β is used for the rest of the epochs.
+ loss_type (`str`, *optional*, defaults to `"sigmoid"`):
+ Type of loss to use. Possible values are:
+
+ - `"sigmoid"`: sigmoid loss from the original [DPO](https://huggingface.co/papers/2305.18290) paper.
+ - `"ipo"`: IPO loss from the [IPO](https://huggingface.co/papers/2310.12036) paper.
+ disable_dropout (`bool`, *optional*, defaults to `True`):
+ Whether to disable dropout in the model and reference model.
+
+ > Parameters that control generation
+
+ top_p (`float`, *optional*, defaults to `1.0`):
+ Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. Set to
+ `1.0` to consider all tokens.
+ top_k (`int`, *optional*, defaults to `0`):
+ Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, top-k-filtering is
+ disabled and all tokens are considered.
+ min_p (`float`, *optional*):
+ Minimum token probability, which will be scaled by the probability of the most likely token. It must be a
+ value between `0.0` and `1.0`. Typical values are in the `0.01-0.2` range.
+ repetition_penalty (`float`, *optional*, defaults to `1.0`):
+ Float that penalizes new tokens based on whether they appear in the prompt and the generated text so far.
+ Values > `1.0` encourage the model to use new tokens, while values < `1.0` encourage the model to repeat
+ tokens.
+ cache_implementation (`str`, *optional*):
+ Implementation of the cache method for faster generation when `use_vllm` is set to `False`.
+ generation_kwargs (`dict[str, Any]`, *optional*):
+ Additional keyword arguments to pass to [`~transformers.GenerationConfig`] (if using transformers) or
+ `SamplingParams` (if using vLLM) when sampling completions. This can be used to further customize the
+ generation behavior, such as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that conflict
+ with the other generation parameters (like `min_p`, `top_p`, etc.), they will override them.
+
+ > Parameters that control generation acceleration powered by vLLM
+
+ use_vllm (`bool`, *optional*, defaults to `False`):
+ Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for generation
+ instead of the default model.generate(). Requires `vllm` to be installed.
+ vllm_model_impl (`str`, *optional*, defaults to `"vllm"`):
+ Model implementation to use for vLLM. Must be one of `"transformers"` or `"vllm"`. `"transformers"`: Use
+ the `transformers` backend for model implementation. `"vllm"`: Use the `vllm` library for model
+ implementation.
+ vllm_mode (`str`, *optional*, defaults to `"colocate"`):
+ Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `"server"` or
+ `"colocate"`.
+
+ - `"server"`: The trainer will send generation requests to a separate vLLM server. Make sure a TRL vLLM
+ server is running (start with `trl vllm-serve`).
+ - `"colocate"`: vLLM will run in the same process and share the training GPUs. This avoids the need for a
+ separate server but may cause resource contention with training.
+ vllm_structured_outputs_regex (`str`, *optional*):
+ Regex for vLLM structured outputs. If `None` (default), structured outputs is disabled.
+
+ > Parameters that control the vLLM server (only used when `vllm_mode` is `"server"`)
+
+ vllm_server_base_url (`str`, *optional*):
+ Base URL for the vLLM server (e.g., `"http://localhost:8000"`). If provided, `vllm_server_host` and
+ `vllm_server_port` are ignored.
+ vllm_server_host (`str`, *optional*, defaults to `"0.0.0.0"`):
+ Host of the vLLM server to connect to. Ignored if `vllm_server_base_url` is provided.
+ vllm_server_port (`int`, *optional*, defaults to `8000`):
+ Port of the vLLM server to connect to. Ignored if `vllm_server_base_url` is provided.
+ vllm_server_timeout (`float`, *optional*, defaults to `240.0`):
+ Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up after the
+ timeout, a `ConnectionError` is raised.
+ vllm_group_port (`int`, *optional*, defaults to `51216`):
+ Port number for the weight update group. This is used to communicate with the vLLM server. Unless the port
+ is occupied, there is no need to change it.
+
+ > Parameters that control colocated vLLM execution (only used when `vllm_mode` is `"colocate"`)
+
+ vllm_gpu_memory_utilization (`float`, *optional*, defaults to `0.55`):
+ Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set to
+ `"colocate"`. If you are using `vllm_mode="server"`, this parameter must be passed separately when
+ launching the vLLM server via the `--vllm_gpu_memory_utilization` flag.
+ vllm_tensor_parallel_size (`int`, *optional*, defaults to `1`):
+ Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set to
+ `"colocate"`. If you are using `vllm_mode="server"`, this parameter must be passed separately when
+ launching the vLLM server via the `--vllm_tensor_parallel_size` flag.
+ vllm_enable_sleep_mode (`bool`, *optional*, defaults to `False`):
+ Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory usage low, but
+ waking the engine adds host–device transfer latency.
+
+ > Other parameters
+
+ ds3_gather_for_generation (`bool`, *optional*, defaults to `True`):
+ This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for generation,
+ improving generation speed. However, disabling this option allows training models that exceed the VRAM
+ capacity of a single GPU, albeit at the cost of slower generation. Disabling this option is not compatible
+ with vLLM generation.
+ model_init_kwargs (`dict[str, Any]`, *optional*):
+ Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the model from a
+ string.
+ trust_remote_code (`bool`, *optional*, defaults to `False`):
+ Whether to allow loading models that ship custom Python code from the Hub. Forwarded to
+ [`~transformers.AutoModelForCausalLM.from_pretrained`]. Also applied to reward-model and reward-tokenizer
+ loads.
+ reward_weights (`list[float]`, *optional*):
+ Weights for combining multiple reward functions. Must match the number of reward functions. If `None`, all
+ reward functions are equally weighted.
+
+ > [!NOTE]
+ > These parameters have default values different from [`~transformers.TrainingArguments`]:
+ > - `logging_steps`: Defaults to `10` instead of `500`.
+ > - `gradient_checkpointing`: Defaults to `True` instead of `False`.
+ > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`.
+ > - `learning_rate`: Defaults to `5e-7` instead of `5e-5`.
+ > - `remove_unused_columns`: Defaults to `False` instead of `True`.
+ """
+
+ _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs"]
+
+ # Parameters whose default values are overridden from TrainingArguments
+ learning_rate: float = field(
+ default=5e-7,
+ metadata={"help": "The initial learning rate for AdamW."},
+ )
+ remove_unused_columns: bool = field(
+ default=False,
+ metadata={"help": "Whether or not to automatically remove the columns unused by the model forward method."},
+ )
+
+ reward_model_path: str | None = field(
+ default=None,
+ metadata={"help": "Path to the reward model."},
+ )
+ max_new_tokens: int = field(
+ default=64,
+ metadata={"help": "Maximum number of tokens to generate per completion."},
+ )
+ max_length: int = field(
+ default=512,
+ metadata={
+ "help": "Maximum total length of the sequence (prompt + completion) used to compute log probabilities. If "
+ "the sequence exceeds this limit, the leftmost tokens will be truncated to preserve as much of the "
+ "completion as possible."
+ },
+ )
+ temperature: float = field(
+ default=0.9,
+ metadata={"help": "Temperature for sampling. The higher the temperature, the more random the completions."},
+ )
+ top_p: float = field(
+ default=1.0,
+ metadata={
+ "help": "Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. "
+ "Set to 1.0 to consider all tokens."
+ },
+ )
+ top_k: int = field(
+ default=0,
+ metadata={
+ "help": "Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, "
+ "top-k-filtering is disabled and all tokens are considered."
+ },
+ )
+ min_p: float | None = field(
+ default=None,
+ metadata={
+ "help": "Minimum token probability, which will be scaled by the probability of the most likely token. It "
+ "must be a value between 0.0 and 1.0. Typical values are in the 0.01-0.2 range."
+ },
+ )
+ repetition_penalty: float = field(
+ default=1.0,
+ metadata={
+ "help": "Float that penalizes new tokens based on whether they appear in the prompt and the generated "
+ "text so far. Values > 1.0 encourage the model to use new tokens, while values < 1.0 encourage the model "
+ "to repeat tokens."
+ },
+ )
+ generation_kwargs: dict | None = field(
+ default=None,
+ metadata={
+ "help": "Additional keyword arguments to pass to `GenerationConfig` (if using transformers) or "
+ "`SamplingParams` (if using vLLM) when sampling completions. This can be used to further customize the "
+ "generation behavior, such as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that "
+ "conflict with the other generation parameters (like `min_p`, `top_p`, etc.), they will override them."
+ },
+ )
+ cache_implementation: str | None = field(
+ default=None,
+ metadata={"help": "Implementation of the cache method for faster generation when use_vllm is set to False."},
+ )
+ missing_eos_penalty: float | None = field(
+ default=None,
+ metadata={
+ "help": "Penalty applied to the score when the model fails to generate an EOS token. This is useful to "
+ "encourage to generate completions shorter than the maximum length (`max_new_tokens`). The penalty must be "
+ "a positive value."
+ },
+ )
+ beta: list[float] = field(
+ default_factory=lambda: [0.1],
+ metadata={
+ "help": "Parameter controlling the deviation from the reference model. Higher β means less deviation from "
+ "the reference model. For the IPO loss (`loss_type='ipo'`), β is the regularization parameter denoted by "
+ "τ in the [paper](https://huggingface.co/papers/2310.12036). If a list of floats is provided then the β "
+ "is selected for each new epoch and the last β is used for the rest of the epochs."
+ },
+ )
+ loss_type: str = field(
+ default="sigmoid",
+ metadata={
+ "help": "Type of loss to use.",
+ "choices": ["sigmoid", "ipo"],
+ },
+ )
+ disable_dropout: bool = field(
+ default=True,
+ metadata={"help": "Whether to disable dropout in the model."},
+ )
+ use_vllm: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to use vLLM for generating completions. Requires vLLM to be installed "
+ "(`pip install trl[vllm]`)."
+ },
+ )
+ vllm_model_impl: str = field(
+ default="vllm",
+ metadata={
+ "help": "Model implementation to use for vLLM. Must be one of `transformers` or `vllm`. `transformers`: "
+ "Use the `transformers` backend for model implementation. `vllm`: Use the `vllm` library for "
+ "model implementation."
+ },
+ )
+ vllm_structured_outputs_regex: str | None = field(
+ default=None,
+ metadata={"help": "Regex for vLLM structured outputs. If `None` (default), structured outputs is disabled."},
+ )
+ vllm_gpu_memory_utilization: float | None = field(
+ default=0.55,
+ metadata={
+ "help": "Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set "
+ "to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when "
+ "launching the vLLM server via the `--vllm_gpu_memory_utilization` flag.",
+ },
+ )
+ vllm_mode: str = field(
+ default="colocate",
+ metadata={
+ "help": "Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `'server'` or "
+ "`'colocate'`. `'server'`: The trainer will send generation requests to a separate vLLM server. Make sure "
+ "a TRL vLLM server is running (start with `trl vllm-serve`). `'colocate'`: vLLM will run in the same "
+ "process and share the training GPUs. This avoids the need for a separate server but may cause resource "
+ "contention with training.",
+ },
+ )
+ vllm_server_base_url: str | None = field(
+ default=None,
+ metadata={
+ "help": "Base URL for the vLLM server (e.g., 'http://localhost:8000'). If provided, `vllm_server_host` "
+ "and `vllm_server_port` are ignored.",
+ },
+ )
+ vllm_server_host: str = field(
+ default="0.0.0.0",
+ metadata={"help": "Host of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."},
+ )
+ vllm_server_port: int = field(
+ default=8000,
+ metadata={"help": "Port of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."},
+ )
+ vllm_server_timeout: float = field(
+ default=240.0,
+ metadata={
+ "help": "Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up "
+ "after the timeout, a `ConnectionError` is raised.",
+ },
+ )
+ vllm_group_port: int = field(
+ default=51216,
+ metadata={
+ "help": "Port number for the weight update group. This is used to communicate with the vLLM server. "
+ "Unless the port is occupied, there is no need to change it.",
+ },
+ )
+ vllm_tensor_parallel_size: int = field(
+ default=1,
+ metadata={
+ "help": "Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set "
+ "to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when "
+ "launching the vLLM server via the `--vllm_tensor_parallel_size` flag.",
+ },
+ )
+ vllm_enable_sleep_mode: bool = field(
+ default=False,
+ metadata={
+ "help": "Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory "
+ "usage low, but waking the engine adds host–device transfer latency."
+ },
+ )
+ ds3_gather_for_generation: bool = field(
+ default=True,
+ metadata={
+ "help": "This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for "
+ "generation, improving generation speed. However, disabling this option allows training models that "
+ "exceed the VRAM capacity of a single GPU, albeit at the cost of slower generation. Disabling this option "
+ "is not compatible with vLLM generation."
+ },
+ )
+ model_init_kwargs: dict[str, Any] | str | None = field(
+ default=None,
+ metadata={
+ "help": "Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the model "
+ "from a string."
+ },
+ )
+ trust_remote_code: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to allow loading models that ship custom Python code from the Hub. Forwarded to "
+ "`AutoModelForCausalLM.from_pretrained`. Also applied to reward-model and reward-tokenizer loads."
+ },
+ )
+ reward_weights: list[float] | None = field(
+ default=None,
+ metadata={
+ "help": "Weights for combining multiple reward functions. Must match the number of reward functions. "
+ "If None, all reward functions are equally weighted."
+ },
+ )
+
+ def __post_init__(self):
+ super().__post_init__()
+
+ if hasattr(self.beta, "__len__") and len(self.beta) == 1:
+ self.beta = self.beta[0]
+
+ if self.max_new_tokens >= self.max_length:
+ warnings.warn(
+ f"The configuration has `max_new_tokens` ({self.max_new_tokens}) >= `max_length` ({self.max_length}). "
+ "This will cause prompts to be truncated or completely removed in the forward pass. "
+ "To preserve prompts, ensure e.g. `max_length > max_new_tokens + 512`. ",
+ stacklevel=3,
+ )
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/online_dpo/online_dpo_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/online_dpo/online_dpo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..f6da8910935a76a7f3eb8b2ca2f0e4913dfe0c84
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/online_dpo/online_dpo_trainer.py
@@ -0,0 +1,1354 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import re
+import textwrap
+from collections.abc import Callable
+from contextlib import nullcontext
+from pathlib import Path
+from typing import Any
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.data
+import transformers
+from accelerate.logging import get_logger
+from accelerate.utils import broadcast_object_list, gather_object, is_peft_model
+from datasets import Dataset
+from packaging.version import Version
+from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+from torch.utils.data import IterableDataset
+from transformers import (
+ AutoModelForCausalLM,
+ AutoModelForSequenceClassification,
+ AutoTokenizer,
+ DataCollator,
+ GenerationConfig,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+ ProcessorMixin,
+ TrainerCallback,
+ is_bitsandbytes_available,
+)
+from transformers.models.auto.modeling_auto import MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES
+from transformers.trainer_utils import EvalPrediction
+from transformers.training_args import OptimizerNames
+from transformers.utils import is_peft_available, is_sagemaker_mp_enabled
+
+from ...data_utils import apply_chat_template, is_conversational, maybe_apply_chat_template
+from ...extras.profiling import profiling_context
+from ...generation.vllm_client import VLLMClient
+from ...import_utils import is_vllm_available
+from ...models.utils import prepare_deepspeed, prepare_fsdp, unwrap_model_for_generation
+from ...trainer.base_trainer import _BaseTrainer
+from ...trainer.utils import disable_dropout_in_model, ensure_master_addr_port, get_config_model_id
+from ..utils import DPODataCollatorWithPadding, create_reference_model, empty_cache, prepare_peft_model, truncate_right
+from .online_dpo_config import OnlineDPOConfig
+
+
+if is_peft_available():
+ from peft import PeftConfig
+
+
+if is_sagemaker_mp_enabled():
+ from smdistributed.modelparallel import __version__ as SMP_VERSION
+
+ IS_SAGEMAKER_MP_POST_1_10 = Version(SMP_VERSION) >= Version("1.10")
+
+else:
+ IS_SAGEMAKER_MP_POST_1_10 = False
+
+
+if Version(transformers.__version__) >= Version("5.2.0"):
+ from transformers.trainer_pt_utils import nested_gather
+
+
+if is_vllm_available():
+ from vllm import LLM, SamplingParams
+ from vllm.sampling_params import StructuredOutputsParams
+
+if is_bitsandbytes_available():
+ import bitsandbytes as bnb
+
+logger = get_logger(__name__)
+
+# A reward function can be a string, interpreted as a model ID and loaded as a pretrained model, a pretrained model, or
+# a callable that returns a list of floats (the rewards). The callable receives prompts, completions, and additional
+# arguments from the trainer (refer to the trainer's source for details). To ensure forward compatibility, it should
+# accept **kwargs.
+RewardFunc = str | PreTrainedModel | Callable[..., list[float | None]]
+
+
+class OnlineDPOTrainer(_BaseTrainer):
+ r"""
+ Initialize OnlineDPOTrainer.
+
+ Args:
+ model (`str | nn.Module | PreTrainedModel`):
+ Model to be trained. Can be either:
+
+ - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a
+ path to a *directory* containing model weights saved using
+ [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded
+ using [`~transformers.AutoModelForCausalLM.from_pretrained`] with the keyword arguments in
+ `args.model_init_kwargs`.
+ - A [`~transformers.PreTrainedModel`] object. Only causal language models are supported.
+ ref_model ([`~transformers.PreTrainedModel`] or `torch.nn.Module` or `None`):
+ The reference model to use for training. If None is specified, the reference model will be created from the
+ model.
+ reward_funcs (`RewardFunc | list[RewardFunc]`):
+ Reward functions to be used for computing the rewards. To compute the rewards, we call all the reward
+ functions with the prompts and completions and sum the rewards. Can be either:
+
+ - A single reward function: Can be a string (path to model), a [`~transformers.PreTrainedModel`], or a
+ custom callable function.
+ - A list of reward functions: Must all be of compatible types.
+ args ([`experimental.online_dpo.OnlineDPOConfig`]):
+ The online DPO config arguments to use for training.
+ data_collator ([`~transformers.DataCollator`]):
+ The data collator to use for training. If None is specified, the default data collator
+ ([`experimental.utils.DPODataCollatorWithPadding`]) will be used which will pad the sequences to the
+ maximum length of the sequences in the batch, given a dataset of paired sequences.
+ train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]):
+ The dataset to use for training.
+ eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`):
+ The dataset to use for evaluation.
+ processing_class ([`~transformers.PreTrainedTokenizerBase`] or [`~transformers.ProcessorMixin`], *optional*):
+ Processing class used to process the data. If provided, will be used to automatically process the inputs
+ for the model, and it will be saved along the model to make it easier to rerun an interrupted training or
+ reuse the fine-tuned model.
+ reward_processing_classes ([`~transformers.PreTrainedTokenizerBase`] or `list[PreTrainedTokenizerBase]`, *optional*):
+ Processing classes corresponding to the reward functions specified in `reward_funcs`. Can be either:
+
+ - A single processing class: Used when `reward_funcs` contains only one reward function.
+ - A list of processing classes: Must match the order and length of the reward functions in `reward_funcs`.
+
+ If set to `None`, the tokenizer for each model-based reward function is automatically loaded using
+ [`~transformers.AutoTokenizer.from_pretrained`].
+ peft_config ([`~peft.PeftConfig`], *optional*):
+ PEFT configuration used to wrap the model. If `None`, the model is not wrapped.
+ compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*):
+ The function to use to compute the metrics. Must take a `EvalPrediction` and return a dictionary string to
+ metric values.
+ callbacks (`list[transformers.TrainerCallback]`):
+ The callbacks to use for training.
+ optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`):
+ The optimizer and scheduler to use for training.
+ preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`):
+ The function to use to preprocess the logits before computing the metrics.
+ """
+
+ _tag_names = ["trl", "online-dpo"]
+ _name = "Online DPO"
+ _paper = {
+ "title": "Direct Language Model Alignment from Online AI Feedback",
+ "id": "2402.04792",
+ # docstyle-ignore
+ "citation": textwrap.dedent("""\
+ @article{guo2024direct,
+ title = {{Direct Language Model Alignment from Online AI Feedback}},
+ author = {Shangmin Guo and Biao Zhang and Tianlin Liu and Tianqi Liu and Misha Khalman and Felipe Llinares and Alexandre Ram{\'{e}} and Thomas Mesnard and Yao Zhao and Bilal Piot and Johan Ferret and Mathieu Blondel},
+ year = 2024,
+ eprint = {arXiv:2402.04792}
+ }"""),
+ }
+
+ def __init__(
+ self,
+ model: PreTrainedModel | nn.Module | str,
+ ref_model: PreTrainedModel | nn.Module | None = None,
+ reward_funcs: RewardFunc | list[RewardFunc] | None = None,
+ args: OnlineDPOConfig | None = None,
+ data_collator: DataCollator | None = None,
+ train_dataset: Dataset | IterableDataset | None = None,
+ eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None,
+ processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None,
+ reward_processing_classes: PreTrainedTokenizerBase | list[PreTrainedTokenizerBase] | None = None,
+ peft_config: "PeftConfig | None" = None,
+ compute_metrics: Callable[[EvalPrediction], dict] | None = None,
+ callbacks: list[TrainerCallback] | None = None,
+ optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None),
+ preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None,
+ ) -> None:
+ if train_dataset is None:
+ raise ValueError("`train_dataset` is required")
+
+ if ref_model is model:
+ raise ValueError(
+ "`model` and `ref_model` cannot be the same object. If you want `ref_model` to be the "
+ "same as `model`, either omit the `ref_model` argument or pass `None`."
+ )
+
+ self.ref_model = ref_model
+
+ if reward_funcs is None:
+ raise ValueError("`reward_funcs` must be provided.")
+
+ # Handle reward_funcs
+ if not isinstance(reward_funcs, list):
+ reward_funcs = [reward_funcs]
+ self.reward_func_names = []
+
+ # Process reward functions (convert strings to models, collect names)
+ model_init_kwargs = args.model_init_kwargs or {}
+ model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+ for i, reward_func in enumerate(reward_funcs):
+ if isinstance(reward_func, str):
+ # Load model from string path
+ reward_funcs[i] = AutoModelForSequenceClassification.from_pretrained(
+ reward_func, num_labels=1, **model_init_kwargs
+ )
+ if isinstance(reward_funcs[i], nn.Module):
+ self.reward_func_names.append(get_config_model_id(reward_funcs[i].config).split("/")[-1])
+ else:
+ self.reward_func_names.append(reward_funcs[i].__name__)
+ self.reward_funcs = reward_funcs
+
+ # Handle reward processing classes for reward_funcs
+ if reward_processing_classes is None:
+ reward_processing_classes = [None] * len(reward_funcs)
+ elif not isinstance(reward_processing_classes, list):
+ reward_processing_classes = [reward_processing_classes]
+ else:
+ if len(reward_processing_classes) != len(reward_funcs):
+ raise ValueError("The number of reward processing classes must match the number of reward functions.")
+
+ self.reward_processing_classes = []
+ for reward_processing_class_i, reward_func in zip(reward_processing_classes, reward_funcs, strict=True):
+ if isinstance(reward_func, PreTrainedModel):
+ if reward_processing_class_i is None:
+ reward_processing_class_i = AutoTokenizer.from_pretrained(
+ reward_func.config._name_or_path, trust_remote_code=args.trust_remote_code
+ )
+ if reward_processing_class_i.pad_token_id is None:
+ reward_processing_class_i.pad_token = reward_processing_class_i.eos_token
+ # Set pad token ID on reward model config
+ reward_func.config.pad_token_id = reward_processing_class_i.pad_token_id
+ self.reward_processing_classes.append(reward_processing_class_i)
+
+ # Handle reward_weights
+ if args.reward_weights is not None:
+ if len(args.reward_weights) != len(self.reward_funcs):
+ raise ValueError(
+ f"Number of reward weights ({len(args.reward_weights)}) must match number of reward "
+ f"functions ({len(self.reward_funcs)})"
+ )
+ self.reward_weights = torch.tensor(args.reward_weights, dtype=torch.float32)
+ else:
+ self.reward_weights = torch.ones(len(self.reward_funcs), dtype=torch.float32)
+
+ if args is None:
+ raise ValueError("`args` must be provided.")
+
+ # Check that the processing_class is provided
+ if processing_class is None:
+ raise ValueError("`processing_class` must be provided.")
+
+ model_init_kwargs = args.model_init_kwargs or {}
+ if isinstance(model, str):
+ model_id = model
+
+ # Handle dtype in model_init_kwargs
+ dtype = model_init_kwargs.get("dtype", "auto")
+ if isinstance(dtype, torch.dtype) or dtype == "auto" or dtype is None:
+ pass
+ elif isinstance(dtype, str):
+ dtype = getattr(torch, dtype)
+ model_init_kwargs["dtype"] = dtype
+ else:
+ raise ValueError(
+ "Invalid `dtype` passed to `OnlineDPOConfig`. Expected either 'auto' or a string "
+ f"representing a `torch.dtype` (e.g., 'float32'), but got {dtype}."
+ )
+ model_init_kwargs["device_map"] = model_init_kwargs.get("device_map", "auto")
+ model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+
+ model = AutoModelForCausalLM.from_pretrained(model_id, **model_init_kwargs)
+ else:
+ if args.model_init_kwargs is not None:
+ raise ValueError(
+ "You passed `model_init_kwargs` to the `OnlineDPOConfig`, but your model is already instantiated. "
+ "This argument can only be used when the `model` argument is a string."
+ )
+ self.is_encoder_decoder = model.config.is_encoder_decoder
+ self.is_vision_model = model.config.model_type in MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES.keys()
+
+ # PEFT
+ if peft_config is not None:
+ if not is_peft_available():
+ raise ImportError(
+ "You passed `peft_config` but the `peft` library is not installed. "
+ "Install it with `pip install trl[peft]`."
+ )
+ if not isinstance(peft_config, PeftConfig):
+ raise TypeError(
+ f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), "
+ f"got {type(peft_config).__name__}."
+ )
+ if peft_config is not None or is_peft_model(model):
+ model = prepare_peft_model(model, peft_config, args)
+
+ # Enable gradient checkpointing if requested
+ if args.gradient_checkpointing:
+ model = self._enable_gradient_checkpointing(model, args)
+
+ # Disable dropout in the model and reference model
+ if args.disable_dropout:
+ disable_dropout_in_model(model)
+ if self.ref_model is not None:
+ disable_dropout_in_model(self.ref_model)
+
+ # Handle the ref_model
+ # Usually, the user wants the ref model to be the initial version of the model. When using PEFT, it's easy to
+ # get the ref model, as it's just the model with a disabled adapter. When not using PEFT, we need to create
+ # the ref model from the model by copying it and disable the gradients and set it in evaluation mode.
+ if ref_model is None: # No ref model provided, the most common case
+ if peft_config is None:
+ self.ref_model = create_reference_model(model) # copy, disable gradients, set eval mode
+ else:
+ self.ref_model = None # we don't need a ref model here, we can just disable the adapter.
+ else: # rare case, the user provided a ref model
+ self.ref_model = ref_model
+ self.ref_model.eval()
+
+ # Disable the gradient and set the reward model in eval mode
+ if reward_funcs is not None:
+ for reward_func in reward_funcs:
+ if isinstance(reward_func, PreTrainedModel):
+ reward_func.eval()
+
+ self.max_length = args.max_length
+
+ self.stats = {
+ "objective/kl": [],
+ "objective/entropy": [],
+ "objective/non_score_reward": [],
+ "rewards/chosen": [],
+ "rewards/rejected": [],
+ "rewards/accuracies": [],
+ "rewards/margins": [],
+ "logps/chosen": [],
+ "logps/rejected": [],
+ "val/contain_eos_token": [],
+ "beta": [],
+ }
+ if self.reward_funcs is not None:
+ self.stats["objective/rlhf_reward"] = []
+ self.stats["objective/scores_margin"] = []
+ self.stats["objective/scores"] = []
+
+ # Store generation parameters for later use
+ self.use_vllm = args.use_vllm
+ self.num_generations = 2 # Generate 2 completions per prompt for Online DPO
+ self.temperature = args.temperature
+ self.top_p = args.top_p
+ self.top_k = args.top_k
+ self.min_p = args.min_p
+ self.repetition_penalty = args.repetition_penalty
+ self.vllm_mode = args.vllm_mode if args.use_vllm else None
+ self.vllm_gpu_memory_utilization = args.vllm_gpu_memory_utilization
+ self.vllm_tensor_parallel_size = args.vllm_tensor_parallel_size
+ self.vllm_model_impl = args.vllm_model_impl
+
+ # Handle pad token for processors or tokenizers
+ if isinstance(processing_class, ProcessorMixin):
+ self._tokenizer = processing_class.tokenizer
+ elif isinstance(processing_class, PreTrainedTokenizerBase):
+ self._tokenizer = processing_class
+ else:
+ raise TypeError("The `processing_class` must be either a `PreTrainedTokenizerBase` or a `ProcessorMixin`")
+
+ if self._tokenizer.pad_token is None:
+ self._tokenizer.pad_token = self._tokenizer.eos_token
+
+ # Vision tokens for VLM support
+ self.image_token_id = getattr(processing_class, "image_token_id", None)
+ self.vision_start_token_id = getattr(processing_class, "vision_start_token_id", None)
+ self.vision_end_token_id = getattr(processing_class, "vision_end_token_id", None)
+ # Get the image token string for token collapsing
+ self.image_token = None
+ if self.image_token_id is not None:
+ self.image_token = self._tokenizer.decode([self.image_token_id])
+
+ # Define the collator if not provided
+ if data_collator is None:
+ data_collator = DPODataCollatorWithPadding(pad_token_id=self._tokenizer.pad_token_id)
+
+ # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was
+ # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream
+ # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we
+ # default to the recommended non-reentrant behavior here, while preserving any user-provided value.
+ if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"):
+ args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {}
+ args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False)
+
+ super().__init__(
+ model=model,
+ args=args,
+ data_collator=data_collator,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=processing_class,
+ compute_metrics=compute_metrics,
+ callbacks=callbacks,
+ optimizers=optimizers,
+ preprocess_logits_for_metrics=preprocess_logits_for_metrics,
+ )
+
+ # Add tags for models that have been loaded with the correct transformers version
+ if hasattr(self.model, "add_model_tags"):
+ self.model.add_model_tags(self._tag_names)
+
+ self._beta = args.beta
+
+ # Set up generation configuration and vLLM after super().__init__
+ if self.use_vllm:
+ if not is_vllm_available():
+ raise ImportError(
+ "vLLM is not available and `use_vllm` is set to True. Please install vLLM with "
+ "`pip install trl[vllm]` to use it."
+ )
+
+ if self.vllm_mode == "server":
+ if self.accelerator.is_main_process:
+ if args.vllm_server_base_url is not None:
+ base_url = args.vllm_server_base_url
+ else:
+ base_url = f"http://{args.vllm_server_host}:{args.vllm_server_port}"
+ self.vllm_client = VLLMClient(
+ base_url=base_url, group_port=args.vllm_group_port, connection_timeout=args.vllm_server_timeout
+ )
+
+ # Determine device type (supports cuda, xpu, etc.)
+ accelerator_type = torch.accelerator.current_accelerator().type
+ current_device = getattr(torch, accelerator_type).current_device()
+ self.vllm_client.init_communicator(device=current_device)
+ else:
+ self.vllm_client = None
+ elif self.vllm_mode == "colocate":
+ # vLLM dynamically adjusts the size of the key-value cache based on available GPU memory at instantiation.
+ # A larger cache size improves speed, so we would expect gpu_memory_utilization=1.
+ # However, at this stage, the optimizer's weights are not yet loaded onto the GPU; they will be loaded
+ # after the first optimizer step and remain in GPU memory throughout training. So we must reserve enough
+ # space for them.
+ # Configure vLLM parameters
+ vllm_quantization = None
+ if is_bitsandbytes_available():
+ for _, module in model.named_modules():
+ if isinstance(module, bnb.nn.Linear4bit):
+ vllm_quantization = "bitsandbytes"
+ break
+ elif isinstance(module, bnb.nn.Linear8bitLt):
+ raise ValueError("vLLM does not support in-flight 8-bit quantization.")
+ vllm_kwargs = {
+ "model": model.name_or_path,
+ "tensor_parallel_size": self.vllm_tensor_parallel_size,
+ "gpu_memory_utilization": self.vllm_gpu_memory_utilization,
+ "model_impl": self.vllm_model_impl,
+ "max_num_seqs": self.args.per_device_train_batch_size * self.vllm_tensor_parallel_size,
+ "max_model_len": args.max_length + args.max_new_tokens, # max_length includes prompt + completion
+ "distributed_executor_backend": "external_launcher",
+ # Feed identical seed for tp groups to ensure sampling results are the same across workers
+ "seed": self.accelerator.process_index // self.vllm_tensor_parallel_size,
+ # Latest vLLM v1 memory profiler is misled by the high default value (i.e., 32768)
+ "max_num_batched_tokens": 4096,
+ "enable_sleep_mode": self.args.vllm_enable_sleep_mode,
+ "quantization": vllm_quantization,
+ }
+
+ # vLLM requires the environment variables to be set for distributed training.
+ os.environ["RANK"] = str(self.accelerator.process_index)
+ os.environ["LOCAL_RANK"] = str(self.accelerator.local_process_index)
+ os.environ["WORLD_SIZE"] = str(self.accelerator.num_processes)
+ # Ensure distributed rendezvous variables are set without colliding across concurrent runs
+ ensure_master_addr_port()
+
+ self.llm = LLM(**vllm_kwargs)
+ if self.args.vllm_enable_sleep_mode:
+ self.llm.sleep(level=2)
+ else:
+ raise ValueError(f"vllm_mode must be either 'server' or 'colocate', got '{self.vllm_mode}'.")
+ # vLLM specific sampling arguments
+ self.structured_outputs_regex = args.vllm_structured_outputs_regex
+ self._last_loaded_step = -1 # tag to avoid useless loading during grad accumulation
+
+ # Set up vLLM generation config
+ generation_kwargs = {
+ "n": 2, # 2 generations per prompt for Online DPO
+ "repetition_penalty": self.repetition_penalty,
+ "temperature": self.temperature,
+ "top_p": self.top_p,
+ "top_k": self.top_k,
+ "min_p": 0.0 if self.min_p is None else self.min_p,
+ "max_tokens": args.max_new_tokens,
+ "detokenize": False, # to avoid vllm to decode (we don't need it)
+ }
+ if args.generation_kwargs is not None:
+ generation_kwargs.update(args.generation_kwargs)
+ if self.structured_outputs_regex is not None:
+ if generation_kwargs.get("structured_outputs") is not None:
+ logger.warning(
+ "Both `vllm_structured_outputs_regex` and `generation_kwargs['structured_outputs']` are set; "
+ "`vllm_structured_outputs_regex` takes precedence."
+ )
+ generation_kwargs["structured_outputs"] = StructuredOutputsParams(regex=self.structured_outputs_regex)
+ elif isinstance(structured_outputs_kwargs := generation_kwargs.get("structured_outputs"), dict):
+ generation_kwargs["structured_outputs"] = StructuredOutputsParams(**structured_outputs_kwargs)
+ self.generation_config = SamplingParams(**generation_kwargs)
+
+ # When using vLLM, the main process is responsible for loading the model weights. This can cause process
+ # desynchronization and seems to lead to DeepSpeed hanging during initialization. To prevent this, we
+ # synchronize all processes after vLLM has been fully initialized.
+ self.accelerator.wait_for_everyone()
+ else:
+ # Set up transformers generation config
+ generation_kwargs = {
+ "max_new_tokens": args.max_new_tokens,
+ "do_sample": True,
+ "pad_token_id": self._tokenizer.pad_token_id,
+ "bos_token_id": self._tokenizer.bos_token_id,
+ "eos_token_id": self._tokenizer.eos_token_id,
+ "temperature": self.temperature,
+ "top_k": self.top_k,
+ "top_p": self.top_p,
+ "repetition_penalty": self.repetition_penalty,
+ "use_cache": True if not self.args.gradient_checkpointing else False,
+ }
+ # Add min_p if supported
+ if self.min_p is not None:
+ generation_kwargs["min_p"] = self.min_p
+ if args.generation_kwargs is not None:
+ generation_kwargs.update(args.generation_kwargs)
+ # Remove None values
+ generation_kwargs = {k: v for k, v in generation_kwargs.items() if v is not None}
+ self.generation_config = GenerationConfig(**generation_kwargs)
+ # Keep training-specific generation kwargs to overwrite model's original generation config
+ self.generation_kwargs = generation_kwargs
+
+ if self.ref_model is not None:
+ if self.is_deepspeed_enabled:
+ self.ref_model = prepare_deepspeed(self.ref_model, self.accelerator)
+ elif self.is_fsdp_enabled:
+ self.ref_model = prepare_fsdp(self.ref_model, self.accelerator)
+ else:
+ self.ref_model = self.accelerator.prepare_model(self.ref_model, evaluation_mode=True)
+ if self.reward_funcs is not None:
+ for i, reward_func in enumerate(self.reward_funcs):
+ if isinstance(reward_func, PreTrainedModel):
+ if self.is_deepspeed_enabled:
+ self.reward_funcs[i] = prepare_deepspeed(reward_func, self.accelerator)
+ else:
+ # set device placement to True to make `prepare_model` move `reward_func` to device when using fsdp
+ self.reward_funcs[i] = self.accelerator.prepare_model(
+ reward_func, evaluation_mode=True, device_placement=True
+ )
+
+ @property
+ def beta(self):
+ if isinstance(self._beta, list):
+ epoch = self.state.epoch
+ return self._beta[epoch] if epoch < len(self._beta) else self._beta[-1]
+ else:
+ return self._beta
+
+ @staticmethod
+ def tokenize_row(feature, is_encoder_decoder: bool, tokenizer: PreTrainedTokenizerBase) -> dict[str, Any]:
+ """Tokenize a single row from a DPO specific dataset."""
+ if not is_encoder_decoder:
+ batch = tokenizer(feature["prompt"], add_special_tokens=False)
+ # Add BOS token to head of prompt. Avoid adding if it's already there
+ if tokenizer.bos_token_id is not None:
+ prompt_len_input_ids = len(batch["input_ids"])
+ if prompt_len_input_ids == 0 or tokenizer.bos_token_id != batch["input_ids"][0]:
+ batch["input_ids"] = [tokenizer.bos_token_id] + batch["input_ids"]
+ batch["attention_mask"] = [1] + batch["attention_mask"]
+ else:
+ batch = tokenizer(feature["prompt"], add_special_tokens=True)
+ batch = {f"prompt_{key}": value for key, value in batch.items()}
+ return batch
+
+ def _enable_gradient_checkpointing(self, model: PreTrainedModel, args: OnlineDPOConfig) -> PreTrainedModel:
+ """Enables gradient checkpointing for the model."""
+ # Ensure use_cache is disabled
+ model.config.use_cache = False
+
+ # Enable gradient checkpointing on the base model for PEFT
+ if is_peft_model(model):
+ model.base_model.gradient_checkpointing_enable()
+ # Enable gradient checkpointing for non-PEFT models
+ else:
+ model.gradient_checkpointing_enable()
+
+ model.enable_input_require_grads()
+ return model
+
+ def _generate_vllm(self, prompts, images=None):
+ eos_token_id = self._tokenizer.eos_token_id
+ pad_token_id = self._tokenizer.pad_token_id
+
+ # Generate completion_ids and prompt_ids based on mode
+ if self.vllm_mode == "server":
+ completion_ids, prompt_ids = self._generate_vllm_server(prompts, images)
+ elif self.vllm_mode == "colocate":
+ completion_ids, prompt_ids = self._generate_vllm_colocate(prompts, images)
+
+ # Shared padding, masking, and tensor conversion logic
+ max_prompt_length = max(len(ids) for ids in prompt_ids)
+ prompt_mask = [[0] * (max_prompt_length - len(ids)) + [1] * len(ids) for ids in prompt_ids]
+ prompt_ids = [[pad_token_id] * (max_prompt_length - len(ids)) + ids for ids in prompt_ids]
+ max_tokens = self.generation_config.max_tokens
+ completion_mask = [[1] * len(ids) + [0] * (max_tokens - len(ids)) for ids in completion_ids]
+ completion_ids = [
+ ids + [eos_token_id] if ids[-1] != eos_token_id and len(ids) < max_tokens else ids
+ for ids in completion_ids
+ ]
+ completion_ids = [ids + [pad_token_id] * (max_tokens - len(ids)) for ids in completion_ids]
+
+ # Convert to tensors
+ prompt_ids = torch.tensor(prompt_ids, device=self.accelerator.device)
+ prompt_mask = torch.tensor(prompt_mask, device=self.accelerator.device)
+ completion_ids = torch.tensor(completion_ids, device=self.accelerator.device)
+ completion_mask = torch.tensor(completion_mask, device=self.accelerator.device)
+
+ return prompt_ids, prompt_mask, completion_ids, completion_mask
+
+ def _generate_vllm_server(self, prompts, images=None):
+ """Generate completions using vLLM server mode"""
+ has_images = images is not None
+
+ # Update vLLM server weights if needed
+ if hasattr(self, "_last_loaded_step") and self.state.global_step != self._last_loaded_step:
+ self._move_model_to_vllm()
+ self._last_loaded_step = self.state.global_step
+ elif not hasattr(self, "_last_loaded_step"):
+ self._move_model_to_vllm()
+ self._last_loaded_step = self.state.global_step
+
+ # Apply chat template if conversational
+ if is_conversational({"prompt": prompts[0]}):
+ prompts_text = [apply_chat_template({"prompt": p}, self.processing_class)["prompt"] for p in prompts]
+ else:
+ prompts_text = prompts
+ # Gather all prompts to main process
+ all_prompts = gather_object(prompts_text)
+ if has_images:
+ all_images = gather_object(images)
+
+ if self.accelerator.is_main_process:
+ # Since 'prompts' contains 'num_generations' duplicates, we first take unique prompts, and generate
+ # num_generations outputs for each one. This is faster than generating outputs for each duplicate
+ # prompt individually.
+ ordered_set_of_prompts = all_prompts[:: self.num_generations]
+ if has_images:
+ ordered_set_of_images = [
+ [img] if img is not None else None for img in all_images[:: self.num_generations]
+ ]
+ else:
+ ordered_set_of_images = None
+ completion_ids = self.vllm_client.generate(
+ prompts=ordered_set_of_prompts,
+ images=ordered_set_of_images,
+ n=self.num_generations,
+ repetition_penalty=self.repetition_penalty,
+ temperature=self.temperature,
+ top_p=self.top_p,
+ top_k=-1 if self.top_k is None else self.top_k,
+ min_p=0.0 if self.min_p is None else self.min_p,
+ max_tokens=self.generation_config.max_tokens,
+ structured_outputs_regex=self.structured_outputs_regex
+ if hasattr(self, "structured_outputs_regex")
+ else None,
+ generation_kwargs=self.args.generation_kwargs,
+ )["completion_ids"]
+ # Flatten: each prompt generates 2 completions
+ completion_ids = [[comp_id] for prompt_completions in completion_ids for comp_id in prompt_completions]
+ else:
+ completion_ids = [None] * (len(all_prompts) * 2)
+
+ # Broadcast completions to all processes
+ completion_ids = broadcast_object_list(completion_ids, from_process=0)
+
+ # Each process takes its slice
+ process_slice = slice(
+ self.accelerator.process_index * len(prompts) * 2,
+ (self.accelerator.process_index + 1) * len(prompts) * 2,
+ )
+ completion_ids = completion_ids[process_slice]
+
+ # Create prompt_ids by tokenizing locally
+ prompt_inputs = self.processing_class(
+ text=prompts_text,
+ return_tensors="pt",
+ padding=True,
+ padding_side="left",
+ add_special_tokens=False,
+ )
+ prompt_ids = []
+ for prompt_tokens in prompt_inputs["input_ids"]:
+ prompt_ids.extend([prompt_tokens.tolist(), prompt_tokens.tolist()]) # 2 copies for 2 completions
+ return completion_ids, prompt_ids
+
+ def _generate_vllm_colocate(self, prompts, images=None):
+ """Generate completions using vLLM colocate mode"""
+ if self.args.vllm_enable_sleep_mode:
+ # wake up colocated vLLM instances if needed
+ torch.cuda.empty_cache() # required to avoid OOM in some cases
+ self.llm.wake_up(tags=["weights"])
+
+ # Update model weights if needed - only after gradient accumulation completes
+ if self.state.global_step != self._last_loaded_step:
+ self._move_model_to_vllm()
+ self._last_loaded_step = self.state.global_step
+
+ # Apply chat template if conversational
+ if is_conversational({"prompt": prompts[0]}):
+ prompts_text = [apply_chat_template({"prompt": p}, self.processing_class)["prompt"] for p in prompts]
+ else:
+ prompts_text = prompts
+
+ # Prepare vLLM inputs with images if available
+ if images is not None:
+ vllm_inputs = []
+ for prompt, image in zip(prompts_text, images, strict=True):
+ if image is not None:
+ vllm_inputs.append({"prompt": prompt, "multi_modal_data": {"image": image}})
+ else:
+ vllm_inputs.append(prompt)
+ else:
+ vllm_inputs = prompts_text
+
+ if self.args.vllm_enable_sleep_mode:
+ self.llm.wake_up(tags=["kv_cache"])
+
+ outputs = self.llm.generate(vllm_inputs, self.generation_config, use_tqdm=False)
+
+ completion_ids = [list(output.outputs[i].token_ids) for i in range(2) for output in outputs]
+ prompt_ids = [list(output.prompt_token_ids) for _ in range(2) for output in outputs]
+ if self.args.vllm_enable_sleep_mode:
+ self.llm.sleep(level=2)
+
+ return completion_ids, prompt_ids
+
+ def _sync_fsdp2_params_to_vllm(self, module: nn.Module):
+ # For FSDP2, module.state_dict() already covers all parameters, so no need for recursion
+ for name, param in module.state_dict().items():
+ # When using PEFT, we need to recover the original parameter name
+ name = name.removeprefix("base_model.model.").replace(".base_layer", "")
+ # Skip PEFT layers: they don’t exist in vLLM, and they are merged already.
+ if is_peft_model(module) and module.prefix in name:
+ continue
+ # When module to save, remove its prefix and discard the original module
+ if "original_module" in name:
+ continue
+ name = self._fix_param_name_to_vllm(name, extra_prefixes=["modules_to_save.default."])
+
+ if param.is_cpu:
+ param = param.to(torch.device("cuda"))
+ param = param.full_tensor()
+
+ if self.vllm_mode == "server" and self.accelerator.is_main_process:
+ self.vllm_client.update_named_param(name, param)
+ elif self.vllm_mode == "colocate":
+ llm_model = self.llm.llm_engine.model_executor.driver_worker.model_runner.model
+ llm_model.load_weights([(name, param)])
+
+ def _move_model_to_vllm(self):
+ # For DeepSpeed ZeRO-3 and FSDP, we need to gather all parameters before operations
+ deepspeed_plugin = self.accelerator.state.deepspeed_plugin
+ zero_stage_3 = deepspeed_plugin is not None and deepspeed_plugin.zero_stage == 3
+ if zero_stage_3:
+ import deepspeed
+
+ gather_if_zero3 = deepspeed.zero.GatheredParameters
+ else:
+ gather_if_zero3 = nullcontext
+
+ if is_peft_model(self.model):
+ # With PEFT and FSDP/DeepSpeed ZeRO Stage 3, we must gather the full model at once before merging, as
+ # merging adapters in a sharded manner is not supported.
+ # TODO: does this work with FSDP?
+ with gather_if_zero3(list(self.model.parameters())):
+ self.model.merge_adapter()
+
+ # Update vLLM weights while parameters are gathered
+ if self.is_fsdp_enabled: # note if using FSDP, gather_if_zero3 is nullcontext
+ # Update vLLM weights while parameters are gathered
+ # For PEFT with FSDP we need to use the memory efficient post-order traversal
+ fsdp_plugin = getattr(self.accelerator.state, "fsdp_plugin", None)
+ fsdp_version = getattr(fsdp_plugin, "fsdp_version", 1) if fsdp_plugin else 1
+ if fsdp_version == 1:
+ self._sync_fsdp1_params_to_vllm(
+ self.model
+ ) # use memory-efficient post-order traversal for FSDP
+ elif fsdp_version == 2:
+ self._sync_fsdp2_params_to_vllm(self.model)
+ else:
+ # DeepSpeed ZeRO-3 with PEFT
+ for name, param in self.model.named_parameters():
+ # When using PEFT, we need to recover the original parameter name
+ name = name.removeprefix("base_model.model.").replace(".base_layer", "")
+ # Skip PEFT layers: they don’t exist in vLLM, and they are merged already.
+ if self.model.prefix in name:
+ continue
+ # When module to save, remove its prefix and discard the original module
+ if "original_module" in name:
+ continue
+ name = self._fix_param_name_to_vllm(name, extra_prefixes=["modules_to_save.default."])
+
+ if self.vllm_mode == "server" and self.accelerator.is_main_process:
+ self.vllm_client.update_named_param(name, param.data)
+ elif self.vllm_mode == "colocate":
+ llm_model = self.llm.llm_engine.model_executor.driver_worker.model_runner.model
+ llm_model.load_weights([(name, param.data)])
+ # Unmerge adapters while parameters are still gathered
+ self.model.unmerge_adapter()
+ # Parameters will automatically be repartitioned when exiting the context
+ else:
+ # For non-PEFT models, simply gather (if needed) and update each parameter individually.
+ if self.is_fsdp_enabled:
+ fsdp_plugin = getattr(self.accelerator.state, "fsdp_plugin", None)
+ fsdp_version = getattr(fsdp_plugin, "fsdp_version", 1) if fsdp_plugin else 1
+ if fsdp_version == 1:
+ self._sync_fsdp1_params_to_vllm(self.model) # use memory-efficient post-order traversal for FSDP
+ elif fsdp_version == 2:
+ self._sync_fsdp2_params_to_vllm(self.model)
+ else:
+ for name, param in self.model.named_parameters():
+ name = self._fix_param_name_to_vllm(name)
+ with gather_if_zero3([param]):
+ if self.vllm_mode == "server" and self.accelerator.is_main_process:
+ self.vllm_client.update_named_param(name, param.data)
+ elif self.vllm_mode == "colocate":
+ llm_model = self.llm.llm_engine.model_executor.driver_worker.model_runner.model
+ llm_model.load_weights([(name, param.data)])
+
+ # Reset cache on vLLM
+ if self.vllm_mode == "server" and self.accelerator.is_main_process:
+ self.vllm_client.reset_prefix_cache()
+ elif self.vllm_mode == "colocate":
+ self.llm.reset_prefix_cache()
+
+ def _sync_fsdp1_params_to_vllm(self, module: nn.Module, prefix: str = "", visited=None):
+ """Memory-efficient post-order traversal of FSDP modules to extract full parameters and sync with vLLM."""
+ # For FSDP1, we need to recurse into children and also use summon_full_params
+ if visited is None:
+ visited = set()
+ for child_name, child_module in module.named_children():
+ child_prefix = f"{prefix}.{child_name}" if prefix else child_name
+ self._sync_fsdp1_params_to_vllm(
+ child_module, prefix=child_prefix, visited=visited
+ ) # recurse into the child
+
+ if isinstance(module, FSDP):
+ with FSDP.summon_full_params(module, recurse=False, writeback=False):
+ for param_name, param in module.named_parameters():
+ full_name = f"{prefix}.{param_name}" if prefix else param_name
+ full_name = self._fix_param_name_to_vllm(full_name, extra_prefixes=["_fsdp_wrapped_module."])
+
+ if full_name in visited:
+ continue # skip FSDP subtrees already traversed
+ visited.add(full_name)
+
+ if self.vllm_mode == "server" and self.accelerator.is_main_process:
+ self.vllm_client.update_named_param(full_name, param.data)
+ elif self.vllm_mode == "colocate":
+ llm_model = self.llm.llm_engine.model_executor.driver_worker.model_runner.model
+ llm_model.load_weights([(full_name, param.data)])
+
+ def _fix_param_name_to_vllm(self, name, extra_prefixes: list[str] | None = None):
+ """Clean parameter names for vLLM compatibility"""
+ extra_prefixes = extra_prefixes or []
+ prefixes = ["_checkpoint_wrapped_module."] + extra_prefixes
+ for prefix in prefixes:
+ name = name.replace(prefix, "")
+ return name
+
+ def process_vision_row(
+ self, features: dict[str, list | torch.Tensor], processing_class=None
+ ) -> dict[str, list[int]]:
+ """
+ Process a vision row for VLM models (adapted from DPO trainer)
+ """
+ processor = processing_class or self.processing_class
+ processed_features = processor(images=[features["image"]], text=features["prompt"], add_special_tokens=False)
+
+ prompt_input_ids = processed_features["input_ids"][0]
+
+ # Create the output dict with required fields
+ output = {
+ "prompt_input_ids": prompt_input_ids,
+ "prompt_attention_mask": processed_features["attention_mask"][0],
+ }
+
+ # Add vision-specific fields
+ if "pixel_values" in processed_features:
+ output["pixel_values"] = processed_features["pixel_values"][0]
+ if "pixel_attention_mask" in processed_features:
+ output["pixel_attention_mask"] = processed_features["pixel_attention_mask"][0]
+ if "image_sizes" in processed_features:
+ output["image_sizes"] = processed_features["image_sizes"][0]
+
+ return output
+
+ def _generate(self, model, prompts, images=None):
+ """Generate completions using the model"""
+ device = next(model.parameters()).device
+ eos_token_id = self._tokenizer.eos_token_id
+ pad_token_id = self._tokenizer.pad_token_id
+
+ # Apply chat template and tokenize the input
+ inputs = [{"prompt": prompt} for prompt in prompts]
+
+ # Add images if provided (VLM support)
+ if images is not None:
+ for i, image in enumerate(images):
+ inputs[i]["image"] = image
+
+ # Apply chat template to get text prompts
+ prompts_text = [maybe_apply_chat_template(x, self.processing_class)["prompt"] for x in inputs]
+
+ # Handle image token collapsing/removal
+ # The chat template sometimes inserts a single image token into the prompt text. However, when this text is
+ # later tokenized, the single image token string is expanded into multiple image token IDs, depending on the
+ # image size. We need to handle this properly.
+ if self.image_token is not None and images is not None:
+ escaped_img_token = re.escape(self.image_token)
+ # Search for the image token in the chat template
+ if hasattr(self.processing_class, "chat_template") and self.processing_class.chat_template:
+ if re.search(escaped_img_token, self.processing_class.chat_template):
+ # Collapse repeated image tokens back into a single token
+ prompts_text = [
+ re.sub(rf"({escaped_img_token})+", self.image_token, text) for text in prompts_text
+ ]
+ else:
+ # If the chat template doesn't use the image token, remove all instances
+ if self.vision_end_token_id is not None:
+ escaped_eoi_token = re.escape(self._tokenizer.decode([self.vision_end_token_id]))
+ prompts_text = [
+ re.sub(rf"({escaped_img_token})+{escaped_eoi_token}", "", text) for text in prompts_text
+ ]
+ else:
+ # If vision_end_token_id is None, just remove the image tokens
+ prompts_text = [re.sub(rf"({escaped_img_token})+", "", text) for text in prompts_text]
+
+ # Prepare kwargs for processing class
+ kwargs = {}
+ if images is not None:
+ kwargs = {"images": [[img] for img in images]}
+
+ # Process inputs using the processing class (handles both VLM and LLM)
+ prompt_inputs = self.processing_class(
+ text=prompts_text,
+ return_tensors="pt",
+ padding=True,
+ padding_side="left",
+ add_special_tokens=False,
+ **kwargs,
+ )
+
+ prompt_inputs = {k: v.to(device) for k, v in prompt_inputs.items()}
+ # Convert vision inputs to model's dtype for proper computation
+ if "pixel_values" in prompt_inputs:
+ # Handle DataParallel wrapped models
+ model_dtype = getattr(model, "dtype", None)
+ if model_dtype is None and hasattr(model, "module"):
+ model_dtype = model.module.dtype
+ if model_dtype is not None:
+ prompt_inputs["pixel_values"] = prompt_inputs["pixel_values"].to(model_dtype)
+
+ # Sample 2 completions per prompt of size `max_new_tokens` from the model
+ prompt_ids = prompt_inputs["input_ids"].repeat(2, 1)
+ prompt_mask = prompt_inputs["attention_mask"].repeat(2, 1)
+
+ # Prepare vision inputs if available
+ vision_generation_kwargs = {}
+ if self.is_vision_model and images is not None:
+ if "pixel_values" in prompt_inputs:
+ vision_generation_kwargs["pixel_values"] = prompt_inputs["pixel_values"].repeat(2, 1, 1, 1)
+ if "pixel_attention_mask" in prompt_inputs:
+ vision_generation_kwargs["pixel_attention_mask"] = prompt_inputs["pixel_attention_mask"].repeat(2, 1)
+ if "image_sizes" in prompt_inputs:
+ vision_generation_kwargs["image_sizes"] = prompt_inputs["image_sizes"].repeat(2, 1)
+ if "image_grid_thw" in prompt_inputs:
+ vision_generation_kwargs["image_grid_thw"] = prompt_inputs["image_grid_thw"].repeat(2, 1)
+
+ with (
+ profiling_context(self, "transformers.generate"),
+ unwrap_model_for_generation(
+ model,
+ self.accelerator,
+ gather_deepspeed3_params=self.args.ds3_gather_for_generation,
+ generation_kwargs=self.generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762
+ ) as unwrapped_model,
+ torch.no_grad(),
+ FSDP.summon_full_params(self.model_wrapped, recurse=False) if self.is_fsdp_enabled else nullcontext(),
+ ):
+ # Setup cache implementation if specified
+ if self.args.cache_implementation is not None:
+ unwrapped_model.generation_config.cache_implementation = self.args.cache_implementation
+
+ # Standard generation
+ output = unwrapped_model.generate(
+ input_ids=prompt_ids,
+ attention_mask=prompt_mask,
+ generation_config=self.generation_config,
+ **vision_generation_kwargs,
+ )
+
+ completion_ids = output[:, prompt_ids.size(1) :]
+ completion_ids, completion_mask = truncate_right(completion_ids, eos_token_id, pad_token_id)
+
+ return prompt_ids, prompt_mask, completion_ids, completion_mask
+
+ def _calculate_rewards_from_functions(self, prompts, completions, completion_ids_list, **reward_kwargs):
+ """
+ Calculate rewards using reward functions
+ """
+ device = self.accelerator.device
+ rewards_per_func = torch.zeros(len(prompts), len(self.reward_funcs), device=device)
+
+ # Add trainer state to reward kwargs for dynamic reward shaping
+ reward_kwargs["trainer_state"] = self.state
+
+ for i, (reward_func, reward_processing_class) in enumerate(
+ zip(self.reward_funcs, self.reward_processing_classes, strict=True)
+ ):
+ if isinstance(reward_func, nn.Module): # Model-based reward function
+ # Handle conversational vs text input
+ if is_conversational({"prompt": prompts[0]}):
+ messages = [{"messages": p + c} for p, c in zip(prompts, completions, strict=True)]
+ texts = [apply_chat_template(x, reward_processing_class)["text"] for x in messages]
+ else:
+ texts = [p + c for p, c in zip(prompts, completions, strict=True)]
+
+ # Tokenize and get reward scores
+ reward_inputs = reward_processing_class(
+ text=texts, return_tensors="pt", padding=True, padding_side="right", add_special_tokens=False
+ )
+ reward_inputs = {k: v.to(device) for k, v in reward_inputs.items()}
+
+ with torch.inference_mode():
+ rewards_per_func[:, i] = reward_func(**reward_inputs).logits[:, 0] # Shape (B*G,)
+ else:
+ # Custom reward function
+ output_reward_func = reward_func(
+ prompts=prompts, completions=completions, completion_ids=completion_ids_list, **reward_kwargs
+ )
+ # Convert None values to NaN
+ output_reward_func = [reward if reward is not None else torch.nan for reward in output_reward_func]
+ rewards_per_func[:, i] = torch.tensor(output_reward_func, dtype=torch.float32, device=device)
+
+ # Weight and sum across all reward functions
+ if self.reward_weights is not None:
+ total_rewards = (rewards_per_func * self.reward_weights.to(device).unsqueeze(0)).nansum(dim=1)
+ else:
+ total_rewards = rewards_per_func.nansum(dim=1)
+
+ return total_rewards
+
+ def _forward(self, model, prompt_ids, prompt_mask, completion_ids, completion_mask, vision_inputs=None):
+ # Get the number of tokens to truncate from prompt
+ num_tokens_to_truncate = max(prompt_ids.size(1) + completion_ids.size(1) - self.max_length, 0)
+
+ # Truncate left to avoid oom
+ prompt_ids = prompt_ids[:, num_tokens_to_truncate:]
+ prompt_mask = prompt_mask[:, num_tokens_to_truncate:]
+
+ # Concat the prompt and completion
+ prompt_completion_ids = torch.cat((prompt_ids, completion_ids), dim=1)
+ prompt_completion_mask = torch.cat((prompt_mask, completion_mask), dim=1)
+
+ # Prepare model kwargs with vision inputs if available
+ model_kwargs = {"attention_mask": prompt_completion_mask}
+ if vision_inputs is not None:
+ if "pixel_values" in vision_inputs:
+ model_kwargs["pixel_values"] = vision_inputs["pixel_values"]
+ if "pixel_attention_mask" in vision_inputs:
+ model_kwargs["pixel_attention_mask"] = vision_inputs["pixel_attention_mask"]
+ if "image_sizes" in vision_inputs:
+ model_kwargs["image_sizes"] = vision_inputs["image_sizes"]
+ if "image_grid_thw" in vision_inputs:
+ model_kwargs["image_grid_thw"] = vision_inputs["image_grid_thw"]
+
+ # Get the logprobs of the completions from the model
+ output = model(prompt_completion_ids, **model_kwargs)
+
+ # There is 1 offset, because the model predicts the next token
+ prompt_len = prompt_ids.size(1)
+ start_idx = prompt_len - 1 if prompt_len > 0 else 0
+ # Only slice off the last logit when we have a prompt, otherwise we need all logits
+ end_idx = -1 if prompt_len > 0 else None
+ logits = output.logits[:, start_idx:end_idx]
+
+ # Take the completion tokens logprob
+ logprobs = torch.take_along_dim(logits.log_softmax(dim=-1), completion_ids.unsqueeze(-1), dim=2).squeeze(-1)
+ return logprobs
+
+ def training_step(
+ self, model: nn.Module, inputs: dict[str, torch.Tensor | Any], num_items_in_batch: int | None = None
+ ) -> torch.Tensor:
+ model.train()
+
+ prompts = inputs["prompt"]
+ batch_size = len(prompts)
+
+ # Handle images for VLM support
+ has_images = "image" in inputs
+ images = None
+ if has_images:
+ images = inputs["image"]
+ # Convert conversational prompts to include image tokens
+ for prompt in prompts:
+ if isinstance(prompt, list):
+ for message in prompt:
+ if not isinstance(message, dict):
+ continue
+ content = message.get("content")
+ role = message.get("role")
+ if isinstance(content, str):
+ if role == "user":
+ message["content"] = [{"type": "image"}, {"type": "text", "text": content}]
+ elif role == "system":
+ message["content"] = [{"type": "text", "text": content}]
+
+ if self.args.use_vllm:
+ prompt_ids, prompt_mask, completion_ids, completion_mask = self._generate_vllm(prompts, images)
+ else:
+ prompt_ids, prompt_mask, completion_ids, completion_mask = self._generate(model, prompts, images)
+
+ contain_eos_token = torch.any(completion_ids == self._tokenizer.eos_token_id, dim=-1)
+
+ # Extract vision inputs if available for VLM support
+ vision_inputs = None
+ if has_images and self.is_vision_model and not self.args.use_vllm:
+ # For vision models with transformers generation, we need to prepare vision inputs
+ # Process the images to get vision inputs that can be passed through the forward pass
+ vision_inputs = {}
+ kwargs = {"images": [[img] for img in images]}
+ processed = self.processing_class(
+ text=[""] * len(images), # Dummy text for vision processing
+ return_tensors="pt",
+ **kwargs,
+ )
+ # Handle DataParallel wrapped models
+ model_device = getattr(model, "device", None)
+ model_dtype = getattr(model, "dtype", None)
+ if model_device is None and hasattr(model, "module"):
+ model_device = model.module.device
+ model_dtype = model.module.dtype
+ # Move vision tensors to device and convert to model dtype
+ # Need to duplicate for 2 completions per prompt
+ if "pixel_values" in processed:
+ vision_inputs["pixel_values"] = (
+ processed["pixel_values"].to(model_device, dtype=model_dtype).repeat(2, 1, 1, 1)
+ )
+ if "pixel_attention_mask" in processed:
+ vision_inputs["pixel_attention_mask"] = processed["pixel_attention_mask"].to(model_device).repeat(2, 1)
+ if "image_sizes" in processed:
+ vision_inputs["image_sizes"] = processed["image_sizes"].to(model_device).repeat(2, 1)
+ if "image_grid_thw" in processed:
+ vision_inputs["image_grid_thw"] = processed["image_grid_thw"].to(model_device).repeat(2, 1)
+
+ logprobs = self._forward(model, prompt_ids, prompt_mask, completion_ids, completion_mask, vision_inputs)
+ with torch.no_grad():
+ if self.ref_model is not None:
+ ref_logprobs = self._forward(
+ self.ref_model, prompt_ids, prompt_mask, completion_ids, completion_mask, vision_inputs
+ )
+ else: # peft case: we just need to disable the adapter
+ with self.model.disable_adapter():
+ ref_logprobs = self._forward(
+ self.model, prompt_ids, prompt_mask, completion_ids, completion_mask, vision_inputs
+ )
+
+ # Decode the completions, and format them if the input is conversational
+ device = logprobs.device
+ completions = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True)
+ if is_conversational({"prompt": prompts[0]}):
+ completions = [[{"role": "assistant", "content": completion}] for completion in completions]
+
+ # Get the reward from reward functions
+ # First create completion_ids_list for custom reward functions
+ completion_ids_list = [completion_ids[i].tolist() for i in range(completion_ids.shape[0])]
+
+ # Extract additional fields from inputs for reward functions
+ reward_kwargs = {}
+ keys = [key for key in inputs if key not in ["prompt"]]
+ for key in keys:
+ if isinstance(inputs[key], (list, tuple)):
+ # Repeat input fields to match number of completions (2 per prompt)
+ reward_kwargs[key] = inputs[key] * 2
+ else:
+ reward_kwargs[key] = inputs[key]
+
+ # Calculate rewards using reward functions
+ rewards = self._calculate_rewards_from_functions(
+ prompts=2 * prompts, completions=completions, completion_ids_list=completion_ids_list, **reward_kwargs
+ )
+
+ # Apply missing EOS penalty if configured
+ if self.args.missing_eos_penalty is not None:
+ rewards[~contain_eos_token] -= self.args.missing_eos_penalty
+
+ # Split rewards into chosen/rejected pairs
+ first_half, second_half = rewards.split(batch_size)
+ mask = first_half >= second_half
+
+ batch_range = torch.arange(batch_size, device=device)
+ chosen_indices = batch_range + (~mask * batch_size)
+ rejected_indices = batch_range + (mask * batch_size)
+
+ # Build tensor so that the first half is the chosen examples and the second half the rejected examples
+ cr_indices = torch.cat((chosen_indices, rejected_indices), dim=0) # cr = chosen and rejected
+ cr_logprobs = logprobs[cr_indices]
+ cr_ref_logprobs = ref_logprobs[cr_indices]
+
+ # mask out the padding tokens
+ padding_mask = ~completion_mask.bool()
+ cr_padding_mask = padding_mask[cr_indices]
+
+ cr_logprobs_sum = (cr_logprobs * ~cr_padding_mask).sum(1)
+ cr_ref_logprobs_sum = (cr_ref_logprobs * ~cr_padding_mask).sum(1)
+
+ # Split the chosen and rejected examples
+ chosen_logprobs_sum, rejected_logprobs_sum = torch.split(cr_logprobs_sum, batch_size)
+ chosen_ref_logprobs_sum, rejected_ref_logprobs_sum = torch.split(cr_ref_logprobs_sum, batch_size)
+ pi_logratios = chosen_logprobs_sum - rejected_logprobs_sum
+ ref_logratios = chosen_ref_logprobs_sum - rejected_ref_logprobs_sum
+
+ logits = pi_logratios - ref_logratios
+
+ if self.args.loss_type == "sigmoid":
+ losses = -F.logsigmoid(self.beta * logits)
+ elif self.args.loss_type == "ipo":
+ losses = (logits - 1 / (2 * self.beta)) ** 2
+ else:
+ raise NotImplementedError(f"invalid loss type {self.args.loss_type}")
+
+ loss = losses.mean()
+
+ # Log everything
+ if self.reward_funcs is not None:
+ # When using reward_funcs, we have rewards instead of scores
+ scores_margin = rewards[chosen_indices] - rewards[rejected_indices]
+ self.stats["objective/scores_margin"].append(
+ self.accelerator.gather_for_metrics(scores_margin.mean()).mean().item()
+ )
+ self.stats["objective/scores"].append(self.accelerator.gather_for_metrics(rewards.mean()).mean().item())
+ self.stats["val/contain_eos_token"].append(contain_eos_token.float().mean().item())
+ self.stats["logps/chosen"].append(self.accelerator.gather_for_metrics(chosen_logprobs_sum).mean().item())
+ self.stats["logps/rejected"].append(self.accelerator.gather_for_metrics(rejected_logprobs_sum).mean().item())
+
+ kl = logprobs - ref_logprobs
+ mean_kl = kl.sum(1).mean()
+ self.stats["objective/kl"].append(self.accelerator.gather_for_metrics(mean_kl).mean().item())
+ non_score_reward = (-self.beta * kl).sum(1)
+ mean_non_score_reward = non_score_reward.mean()
+ self.stats["objective/non_score_reward"].append(
+ self.accelerator.gather_for_metrics(mean_non_score_reward).mean().item()
+ )
+ if self.reward_funcs is not None:
+ # Calculate RLHF reward by combining rewards with non_score_reward
+ rlhf_reward = rewards + non_score_reward
+ self.stats["objective/rlhf_reward"].append(self.accelerator.gather_for_metrics(rlhf_reward).mean().item())
+
+ mean_entropy = -logprobs.sum(1).mean()
+ self.stats["objective/entropy"].append(self.accelerator.gather_for_metrics(mean_entropy).mean().item())
+ chosen_rewards = self.beta * (chosen_logprobs_sum - chosen_ref_logprobs_sum)
+ gathered_chosen_rewards = self.accelerator.gather_for_metrics(chosen_rewards)
+ self.stats["rewards/chosen"].append(gathered_chosen_rewards.mean().item())
+ rejected_rewards = self.beta * (rejected_logprobs_sum - rejected_ref_logprobs_sum)
+ gathered_rejected_rewards = self.accelerator.gather_for_metrics(rejected_rewards)
+ self.stats["rewards/rejected"].append(gathered_rejected_rewards.mean().item())
+ margin = gathered_chosen_rewards - gathered_rejected_rewards
+ self.stats["rewards/margins"].append(margin.mean().item())
+ accuracy = margin > 0
+ self.stats["rewards/accuracies"].append(accuracy.float().mean().item())
+ self.stats["beta"].append(self.beta)
+
+ if (
+ self.args.torch_empty_cache_steps is not None
+ and self.state.global_step % self.args.torch_empty_cache_steps == 0
+ ):
+ empty_cache()
+
+ kwargs = {}
+
+ # For LOMO optimizers you need to explicitly use the learning rate
+ if self.args.optim in [OptimizerNames.LOMO, OptimizerNames.ADALOMO]:
+ kwargs["learning_rate"] = self._get_learning_rate()
+
+ if self.args.n_gpu > 1:
+ loss = loss.mean() # mean() to average on multi-gpu parallel training
+
+ self.accelerator.backward(loss, **kwargs)
+
+ return loss.detach() / self.args.gradient_accumulation_steps
+
+ # Same as Trainer._maybe_log_save_evaluate but log our metrics
+ def _maybe_log_save_evaluate(
+ self, tr_loss, grad_norm, model, trial, epoch, ignore_keys_for_eval, start_time, learning_rate=None
+ ):
+ if self.control.should_log and self.state.global_step > self._globalstep_last_logged:
+ logs: dict[str, float] = {}
+
+ # all_gather + mean() to get average loss over all processes
+ if Version(transformers.__version__) >= Version("5.2.0"):
+ tr_loss_scalar = nested_gather(tr_loss, self.args.parallel_mode).mean().item()
+ else:
+ tr_loss_scalar = self._nested_gather(tr_loss).mean().item()
+
+ # reset tr_loss to zero
+ tr_loss -= tr_loss
+
+ logs["loss"] = round(tr_loss_scalar / (self.state.global_step - self._globalstep_last_logged), 4)
+ if grad_norm is not None:
+ logs["grad_norm"] = grad_norm.detach().item() if isinstance(grad_norm, torch.Tensor) else grad_norm
+ if learning_rate is not None:
+ logs["learning_rate"] = learning_rate
+ else:
+ logs["learning_rate"] = self._get_learning_rate()
+
+ # Add our metrics
+ for key, val in self.stats.items():
+ logs[key] = sum(val) / len(val)
+ self.stats = {key: [] for key in self.stats} # reset stats
+
+ self._total_loss_scalar += tr_loss_scalar
+ self._globalstep_last_logged = self.state.global_step
+ self.store_flos()
+ self.log(logs, start_time)
+
+ metrics = None
+ if self.control.should_evaluate:
+ metrics = self._evaluate(trial, ignore_keys_for_eval)
+ is_new_best_metric = self._determine_best_metric(metrics=metrics, trial=trial)
+
+ if self.args.save_strategy == "best":
+ self.control.should_save = is_new_best_metric
+
+ if self.control.should_save:
+ self._save_checkpoint(model, trial)
+ self.control = self.callback_handler.on_save(self.args, self.state, self.control)
+
+ # Ensure the model card is saved along with the checkpoint
+ def _save_checkpoint(self, model, trial):
+ if self.args.hub_model_id is None:
+ model_name = Path(self.args.output_dir).name
+ else:
+ model_name = self.args.hub_model_id.split("/")[-1]
+ self.create_model_card(model_name=model_name)
+ super()._save_checkpoint(model, trial)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/openenv/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/openenv/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4325e17f284102bd02848b432cd9d9ffedd32f58
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/openenv/__init__.py
@@ -0,0 +1,18 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .utils import generate_rollout_completions
+
+
+__all__ = ["generate_rollout_completions"]
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/openenv/utils.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/openenv/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8f4d573854a4fa9cf93fb8f7a354d54c7fad0c9
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/openenv/utils.py
@@ -0,0 +1,214 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any
+
+import torch
+
+from ...data_utils import is_conversational
+from ...extras.profiling import profiling_context
+from ...import_utils import is_vllm_available
+
+
+if is_vllm_available():
+ from vllm import SamplingParams
+ from vllm.sampling_params import StructuredOutputsParams
+
+
+def _build_base_generation_kwargs(
+ trainer,
+ overrides: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+ """Build base generation kwargs common to both colocate and server modes."""
+ generation_kwargs: dict[str, Any] = {
+ "n": 1,
+ "temperature": trainer.temperature,
+ "top_k": trainer.top_k,
+ "min_p": 0.0 if trainer.min_p is None else trainer.min_p,
+ "max_tokens": trainer.max_completion_length,
+ }
+ if trainer.repetition_penalty is not None:
+ generation_kwargs["repetition_penalty"] = trainer.repetition_penalty
+ if trainer.top_p is not None:
+ generation_kwargs["top_p"] = trainer.top_p
+
+ if trainer.args.generation_kwargs is not None:
+ generation_kwargs.update(trainer.args.generation_kwargs)
+
+ if overrides is not None:
+ generation_kwargs.update(overrides)
+
+ generation_kwargs = {key: value for key, value in generation_kwargs.items() if value is not None}
+
+ if generation_kwargs.get("n", 1) != 1:
+ raise ValueError("generate_rollout_completions expects n=1.")
+
+ return generation_kwargs
+
+
+def _build_colocate_sampling_params(
+ trainer,
+ overrides: dict[str, Any] | None = None,
+ *,
+ logprobs: bool = True,
+) -> "SamplingParams":
+ """Build SamplingParams for colocate mode."""
+ generation_kwargs = _build_base_generation_kwargs(trainer, overrides)
+
+ # Add colocate-specific parameters
+ if trainer.vllm_generation.structured_outputs_regex:
+ generation_kwargs["structured_outputs"] = StructuredOutputsParams(
+ regex=trainer.vllm_generation.structured_outputs_regex
+ )
+ if logprobs:
+ generation_kwargs["logprobs"] = 0
+
+ return SamplingParams(**generation_kwargs)
+
+
+def _build_server_generation_kwargs(
+ trainer,
+ overrides: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+ """Build generation kwargs for server mode."""
+ return _build_base_generation_kwargs(trainer, overrides)
+
+
+def generate_rollout_completions(
+ trainer,
+ prompts: list[str],
+ *,
+ generation_overrides: dict[str, Any] | None = None,
+ as_chat: bool | None = None,
+) -> list[dict[str, Any]]:
+ """
+ Generate completions for custom rollouts when vLLM is running in colocate or server mode.
+
+ Returns one result per prompt, containing prompt and completion token ids along with per-token log probabilities
+ and the generated text.
+ """
+
+ if not prompts:
+ return []
+
+ if not trainer.use_vllm:
+ raise RuntimeError("Custom rollouts require vLLM to call generate_rollout_completions.")
+
+ if trainer.vllm_mode == "server":
+ return _generate_rollout_completions_server(trainer, prompts, generation_overrides, as_chat)
+ elif trainer.vllm_mode == "colocate":
+ return _generate_rollout_completions_colocate(trainer, prompts, generation_overrides, as_chat)
+ else:
+ raise ValueError(f"vllm_mode must be 'server' or 'colocate', got '{trainer.vllm_mode}'")
+
+
+def _generate_rollout_completions_server(
+ trainer,
+ prompts: list[str],
+ generation_overrides: dict[str, Any] | None = None,
+ as_chat: bool | None = None,
+) -> list[dict[str, Any]]:
+ """Generate completions using vLLM server mode."""
+ generation_kwargs = _build_server_generation_kwargs(trainer, generation_overrides)
+
+ if as_chat is None:
+ as_chat = prompts and is_conversational({"prompt": prompts[0]})
+
+ with profiling_context(trainer, "vLLM.generate_rollout_server"):
+ if as_chat:
+ # Prompts are raw message dicts; use .chat() so the vLLM server applies the chat template
+ output = trainer.vllm_generation.vllm_client.chat(
+ messages=prompts,
+ **generation_kwargs,
+ chat_template_kwargs=trainer.chat_template_kwargs,
+ tools=trainer.tools or None,
+ chat_template=trainer.chat_template,
+ )
+ else:
+ output = trainer.vllm_generation.vllm_client.generate(prompts=prompts, **generation_kwargs)
+
+ # Format results to match colocate output format
+ results: list[dict[str, Any]] = []
+ for i in range(len(prompts)):
+ results.append(
+ {
+ "prompt_ids": output["prompt_ids"][i],
+ "completion_ids": list(output["completion_ids"][i]),
+ "logprobs": list(output["logprobs"][i]),
+ "text": trainer.processing_class.decode(output["completion_ids"][i], skip_special_tokens=True),
+ }
+ )
+
+ return results
+
+
+def _generate_rollout_completions_colocate(
+ trainer,
+ prompts: list[str],
+ generation_overrides: dict[str, Any] | None = None,
+ as_chat: bool | None = None,
+) -> list[dict[str, Any]]:
+ """Generate completions using vLLM colocate mode."""
+ sampling_params = _build_colocate_sampling_params(trainer, generation_overrides)
+ prompts_for_generation = prompts
+ original_size = len(prompts)
+
+ if trainer.vllm_tensor_parallel_size > 1:
+ gathered_prompts = [None for _ in range(trainer.vllm_tensor_parallel_size)]
+ torch.distributed.all_gather_object(gathered_prompts, prompts, group=trainer.vllm_generation.tp_group)
+ prompts_for_generation = [prompt for group_prompts in gathered_prompts for prompt in group_prompts]
+
+ if as_chat is None:
+ as_chat = prompts_for_generation and is_conversational({"prompt": prompts_for_generation[0]})
+
+ if trainer.args.vllm_enable_sleep_mode:
+ trainer.vllm_generation.llm.wake_up(tags=["kv_cache"])
+ # Work around for https://github.com/vllm-project/vllm/issues/29341
+ trainer.vllm_generation.llm.collective_rpc("reload_weights")
+
+ with profiling_context(trainer, "vLLM.generate_rollout"):
+ if as_chat:
+ vllm_outputs = trainer.vllm_generation.llm.chat(
+ prompts_for_generation, sampling_params=sampling_params, use_tqdm=False
+ )
+ else:
+ vllm_outputs = trainer.vllm_generation.llm.generate(
+ prompts_for_generation, sampling_params=sampling_params, use_tqdm=False
+ )
+
+ results: list[dict[str, Any]] = []
+ for request in vllm_outputs:
+ if not request.outputs:
+ results.append({"prompt_ids": request.prompt_token_ids, "completion_ids": [], "logprobs": [], "text": ""})
+ continue
+ sequence = request.outputs[0]
+ logprobs = [next(iter(token_logprob.values())).logprob for token_logprob in sequence.logprobs]
+ results.append(
+ {
+ "prompt_ids": request.prompt_token_ids,
+ "completion_ids": sequence.token_ids,
+ "logprobs": logprobs,
+ "text": sequence.text,
+ }
+ )
+
+ if trainer.vllm_tensor_parallel_size > 1:
+ local_rank_in_group = torch.distributed.get_rank(group=trainer.vllm_generation.tp_group)
+ tp_slice = slice(local_rank_in_group * original_size, (local_rank_in_group + 1) * original_size)
+ results = results[tp_slice]
+
+ if trainer.args.vllm_enable_sleep_mode:
+ trainer.vllm_generation.llm.sleep(level=2)
+
+ return results
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/openreward/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/openreward/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..eae7806a5a213157f814cead9b2d76158ea07bb4
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/openreward/__init__.py
@@ -0,0 +1,18 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ._spec import OpenRewardSpec
+
+
+__all__ = ["OpenRewardSpec"]
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/openreward/_spec.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/openreward/_spec.py
new file mode 100644
index 0000000000000000000000000000000000000000..76dd6b0d91e9f29dd428f57983df17c430acb3cf
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/openreward/_spec.py
@@ -0,0 +1,359 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""User-facing spec object for the OpenReward × TRL integration.
+
+The user constructs **one** ``OpenRewardSpec`` (a thin specification holding the env target + a few options) and reads
+three properties off of it — ``.train_dataset``, ``.environment_factory``, ``.reward_funcs`` — each of which plugs
+directly into the matching ``GRPOTrainer`` kwarg:
+
+```python
+from trl import GRPOConfig, GRPOTrainer
+from trl.experimental.openreward import OpenRewardSpec
+
+spec = OpenRewardSpec("Eigent/SETA", num_tasks=64)
+
+trainer = GRPOTrainer(
+ model="Qwen/Qwen3-4B",
+ args=GRPOConfig(num_generations=2, max_steps=5, max_tool_calling_iterations=20),
+ train_dataset=spec.train_dataset,
+ environment_factory=spec.environment_factory,
+ reward_funcs=spec.reward_funcs,
+)
+trainer.train()
+```
+
+Backed by the official ``openreward`` SDK (lazy-imported); install with ``pip install trl[openreward]``.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from collections.abc import Callable
+from functools import cached_property
+from typing import Any
+
+from .environment import _import_openreward, _RolloutEnvironment, _spec_to_dict
+
+
+logger = logging.getLogger(__name__)
+
+
+def _tool_specs_from_session_list_tools(out: Any) -> list[Any]:
+ """Normalise ``session.list_tools()`` / ``environment.list_tools()`` to a flat list.
+
+ The client SDK (``openreward.api``) returns ``list[ToolSpec]`` directly.
+ """
+ return list(out)
+
+
+def _to_spec(task) -> dict[str, Any]:
+ """Normalise an SDK ``Task`` (or already-a-dict) to its task_spec dict."""
+ if isinstance(task, dict):
+ return task
+ return task.task_spec
+
+
+def _outcome_only_reward_func(environments, **_):
+ """Default reward function: last non-null reward in each rollout's trajectory.
+
+ Suitable for sparse-outcome envs (e.g. SETA, where only `submit_solution` returns a non-null reward). Override by
+ passing a different callable to ``reward_funcs=``.
+ """
+ return [env.reward for env in environments]
+
+
+class OpenRewardSpec:
+ """Single spec object that wires an ORS environment into a TRL trainer.
+
+ Args:
+ target (`str`):
+ Either an openreward.ai catalog name (`"Eigent/SETA"`) or a URL pointing at any ORS server
+ (`"https://you-seta.hf.space"`, `"http://localhost:8080"`). Auto-detected by the presence of `://` in the
+ string.
+ num_tasks (`int`, *optional*):
+ Cap on the number of tasks pulled into the dataset. ``None`` uses every task the env exposes.
+ split (`str`, *optional*, defaults to `"train"`):
+ Which split's task list to draw from.
+ indices (`list[int]`, *optional*):
+ Specific task indices to train on. Mutually exclusive with ``num_tasks``. Useful for debugging or
+ curriculum subsets.
+ api_key (`str`, *optional*):
+ ``OPENREWARD_API_KEY`` override. Only used when ``target`` is a catalog name.
+ secrets (`dict[str, str]`, *optional*):
+ Per-session secrets forwarded to ``env.session(secrets=)``.
+ env_name (`str`, *optional*):
+ Override for the env name to look up on the server. Rarely needed.
+ include_metadata (`bool`, *optional*, defaults to `True`):
+ Fold per-task metadata (`difficulty`, `category`, `tags`, ...) into the dataset rows so reward funcs can
+ read them via TRL's ``inputs`` argument.
+ discover_task_tools (`bool`, *optional*, defaults to `True`):
+ If ``True``, opens a short-lived ORS session and uses ``session.list_tools()`` so task-specific tools
+ (``GET …/task_tools`` per ORS — e.g. ``@tool(shared=False)`` and ``list_task_tools()``) are bound for GRPO.
+ If probe fails, falls back to ``environment.list_tools()`` only. Set ``False`` to skip the extra session
+ (shared tools only / offline quirks).
+ task_tools_discovery_index (`int`, *optional*):
+ Task index used only for the discovery session when set; **overrides** multi-index probing below. When
+ omitted and ``indices=`` is set, discovery opens one probe session per **distinct** entry in ``indices``
+ (sorted) and **merges** tool specs by name so task-specific tools from every listed task are bound. When
+ omitted and ``num_tasks`` / full-list mode is used, probes task ``0`` only. Ignored when
+ ``discover_task_tools=False``.
+ """
+
+ def __init__(
+ self,
+ target: str,
+ *,
+ num_tasks: int | None = None,
+ split: str = "train",
+ indices: list[int] | None = None,
+ api_key: str | None = None,
+ secrets: dict[str, str] | None = None,
+ env_name: str | None = None,
+ include_metadata: bool = True,
+ discover_task_tools: bool = True,
+ task_tools_discovery_index: int | None = None,
+ ) -> None:
+ if num_tasks is not None and indices is not None:
+ raise ValueError("Provide num_tasks or indices, not both.")
+
+ self._target = target
+ self._is_url = "://" in target
+ self._num_tasks = num_tasks
+ self._split = split
+ self._indices = indices
+ self._api_key = api_key
+ self._secrets = secrets
+ self._env_name = env_name
+ self._include_metadata = include_metadata
+ self._discover_task_tools = discover_task_tools
+ self._task_tools_discovery_index = task_tools_discovery_index
+
+ # ── public surface ──────────────────────────────────────────────
+
+ @cached_property
+ def train_dataset(self):
+ """A `datasets.Dataset` derived from the env's task list.
+
+ Plugs directly into TRL's ``train_dataset=`` slot. Built lazily on first access. Has at minimum:
+ - `prompt`: empty user message (TRL appends the env's prompt).
+ - `task_index`: int passed to the adapter's `reset()`.
+ - per-task metadata columns (when `include_metadata=True`).
+ """
+ from datasets import Dataset
+
+ env = self._sdk_env
+
+ # When the user asked for a specific subset (`num_tasks` cap or
+ # explicit `indices`), fetch only those — `list_tasks` returns
+ # the whole split (1376 entries for SETA, etc.) and is slow on
+ # the platform. Per-index `get_task` is fast and cheap.
+ if self._indices is not None:
+ indexes = list(self._indices)
+ task_specs = [_to_spec(env.get_task(self._split, i)) for i in indexes]
+ elif self._num_tasks is not None:
+ n_total = env.num_tasks(self._split)
+ n = min(self._num_tasks, n_total)
+ indexes = list(range(n))
+ task_specs = [_to_spec(env.get_task(self._split, i)) for i in indexes]
+ else:
+ # No cap — fetch everything in one shot.
+ try:
+ tasks = env.list_tasks(self._split)
+ except Exception: # noqa: BLE001
+ n = env.num_tasks(self._split)
+ tasks = [env.get_task(self._split, i) for i in range(n)]
+ task_specs = [_to_spec(t) for t in tasks]
+ indexes = list(range(len(task_specs)))
+
+ rows: dict[str, list[Any]] = {
+ "prompt": [[{"role": "user", "content": ""}] for _ in indexes],
+ "task_index": indexes,
+ }
+
+ if self._include_metadata and task_specs:
+ metadata_keys: set[str] = set()
+ for spec in task_specs:
+ if isinstance(spec, dict):
+ metadata_keys.update(spec.keys())
+ # Never let a task-spec key overwrite our reserved row columns
+ # (e.g. an env that exposes a `prompt` task-spec field would
+ # otherwise replace our chat-format prompt with a raw string).
+ metadata_keys -= rows.keys()
+ for key in sorted(metadata_keys):
+ rows[key] = [s.get(key) if isinstance(s, dict) else None for s in task_specs]
+
+ return Dataset.from_dict(rows)
+
+ @cached_property
+ def environment_factory(self) -> Callable[[], _RolloutEnvironment]:
+ """Zero-arg callable that returns a fresh ``_RolloutEnvironment``.
+
+ Plugs directly into TRL's ``environment_factory=`` slot. TRL calls this once per rollout at trainer
+ construction time, so each rollout has an isolated ORS session. Reuses the spec's already-discovered SDK env +
+ tool specs to skip per-env HTTP at trainer init.
+ """
+ # Pre-fetch tool specs once at the spec level. ORS exposes shared tools on GET /tools and the full
+ # shared+task-specific set on GET /task_tools (session-scoped). GRPO inspects methods before reset(), so we
+ # must bind every tool the episode will see — use session.list_tools() when discover_task_tools=True.
+ env = self._sdk_env
+ tool_specs = self._discovered_tool_specs(env)
+ client = self._sdk_client
+
+ # Each spec gets its own `_RolloutEnvironment` subclass so two specs
+ # for different envs (different tool sets) never clobber each other's
+ # bound methods on the shared parent class.
+ rollout_cls = type(f"_RolloutEnvironment_{id(self):x}", (_RolloutEnvironment,), {})
+
+ kwargs = {
+ "split": self._split,
+ "secrets": self._effective_secrets(),
+ "env_name": self._env_name,
+ "_client": client,
+ "_env": env,
+ "_tool_specs": tool_specs,
+ }
+ if self._is_url:
+ kwargs["base_url"] = self._target
+ else:
+ kwargs["name"] = self._target
+ if self._api_key:
+ kwargs["api_key"] = self._api_key
+
+ kwargs = {k: v for k, v in kwargs.items() if v is not None}
+
+ def _make() -> _RolloutEnvironment:
+ return rollout_cls(**kwargs)
+
+ return _make
+
+ @property
+ def reward_funcs(self) -> Callable[..., list[float]]:
+ """Default outcome-only reward function (last non-null reward per rollout).
+
+ Plugs directly into TRL's ``reward_funcs=`` slot. Stable identity — module-level function, picklable for
+ multi-process workers.
+ """
+ return _outcome_only_reward_func
+
+ # ── internals ───────────────────────────────────────────────────
+
+ def _effective_secrets(self) -> dict[str, str] | None:
+ """Auto-forward ``OPENREWARD_API_KEY`` as the conventional ``api_key``
+ per-session secret on platform mode (most envs need it)."""
+ if self._secrets is not None or self._is_url:
+ return self._secrets
+ key = self._api_key or os.environ.get("OPENREWARD_API_KEY")
+ return {"api_key": key} if key else None
+
+ def _task_tools_probe_indices(self) -> list[int]:
+ """Pick task indices for ``session.list_tools()`` discovery (ORS ``/task_tools``)."""
+ if self._task_tools_discovery_index is not None:
+ return [self._task_tools_discovery_index]
+ if self._indices is not None:
+ return sorted(set(self._indices))
+ return [0]
+
+ def _discovered_tool_specs(self, env):
+ """Return ToolSpec list for binding on `_RolloutEnvironment`.
+
+ Prefer ``session.list_tools()`` (ORS ``/task_tools``) so task-specific tools match what the OpenReward SDK
+ exposes during rollouts. Fall back to ``environment.list_tools()`` on failure or when disabled.
+ """
+ shared = env.list_tools()
+ shared = _tool_specs_from_session_list_tools(shared)
+ if not self._discover_task_tools:
+ return shared
+
+ try:
+ n = env.num_tasks(self._split)
+ except Exception as e: # noqa: BLE001
+ logger.warning("OpenRewardSpec: num_tasks failed (%s); using shared tools only.", e)
+ return shared
+
+ if n <= 0:
+ return shared
+
+ probe_indices = self._task_tools_probe_indices()
+ bad = [idx for idx in probe_indices if idx < 0 or idx >= n]
+ if bad:
+ logger.warning(
+ "OpenRewardSpec: task tool probe index(es) %s out of range for split=%r (num_tasks=%s); ignoring them.",
+ bad,
+ self._split,
+ n,
+ )
+ probe_indices = [idx for idx in probe_indices if 0 <= idx < n]
+ if not probe_indices:
+ logger.warning("OpenRewardSpec: no valid task indices for tool discovery; using shared tools only.")
+ return shared
+
+ secrets = self._effective_secrets()
+ merged: list[Any] = []
+ seen: dict[str, Any] = {}
+ any_probe_ok = False
+
+ for idx in probe_indices:
+ try:
+ with env.session(split=self._split, index=idx, secrets=secrets) as sess:
+ specs = _tool_specs_from_session_list_tools(sess.list_tools())
+ except Exception as e: # noqa: BLE001
+ logger.warning(
+ "OpenRewardSpec: session tool discovery failed for task_index=%s (%s); skipping.",
+ idx,
+ e,
+ )
+ continue
+ any_probe_ok = True
+ for spec in specs:
+ d = _spec_to_dict(spec)
+ name = d["name"]
+ if name not in seen:
+ seen[name] = spec
+ merged.append(spec)
+ elif _spec_to_dict(seen[name]) != d:
+ logger.warning(
+ "OpenRewardSpec: tool %r has differing schemas across probe tasks; keeping first.",
+ name,
+ )
+
+ if not any_probe_ok:
+ logger.warning("OpenRewardSpec: all task tool probes failed; using shared tools only.")
+ return shared
+ return merged
+
+ @cached_property
+ def _sdk_client(self):
+ """The shared ``openreward.OpenReward`` client used by `dataset` and `factory`."""
+ openreward = _import_openreward()
+ kwargs: dict[str, Any] = {}
+ if self._api_key:
+ kwargs["api_key"] = self._api_key
+ elif not self._is_url and "OPENREWARD_API_KEY" in os.environ:
+ kwargs["api_key"] = os.environ["OPENREWARD_API_KEY"]
+ if self._is_url:
+ kwargs["base_url"] = self._target
+ return openreward.OpenReward(**kwargs)
+
+ @cached_property
+ def _sdk_env(self):
+ """The shared SDK ``Environment`` handle."""
+ if self._is_url:
+ # Self-hosted single-env URL — pass any name; the SDK redirects.
+ # Fallback to "env" matches `_RolloutEnvironment.__init__`.
+ target = self._env_name or "env"
+ else:
+ target = self._target
+ return self._sdk_client.environments.get(target)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/openreward/environment.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/openreward/environment.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b969ee1c2c0b2a9ebacd6bb62f00d0ebff74fff
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/openreward/environment.py
@@ -0,0 +1,404 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""TRL `environment_factory` adapter for any ORS-compliant server.
+
+Wraps the official ``openreward`` SDK so platform quirks (X-Secrets encoding, ephemeral session for discovery,
+sticky-routing subdomain, SSE chunk reassembly, ping keepalive, …) are handled by code that ships with the spec. Our
+job is only to expose the SDK's per-rollout session as a TRL-compatible class with dynamically-bound tool methods.
+
+Install: ``pip install trl[openreward]``.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+from typing import Any
+
+
+logger = logging.getLogger(__name__)
+
+
+def _import_openreward():
+ """Lazy-import the openreward package with a friendly error message."""
+ try:
+ import openreward
+
+ return openreward
+ except ImportError as e:
+ raise ImportError(
+ "trl.experimental.openreward requires the `openreward` package. "
+ "Install with `pip install trl[openreward]`."
+ ) from e
+
+
+# ── JSON Schema → Python type mapping (used by dynamic tool binding) ──
+
+_JSON_TYPE_TO_PY: dict[str, str] = {
+ "string": "str",
+ "integer": "int",
+ "number": "float",
+ "boolean": "bool",
+ "array": "list",
+ "object": "dict",
+}
+
+_PY_TYPE_OBJECTS: dict[str, type] = {
+ "str": str,
+ "int": int,
+ "float": float,
+ "bool": bool,
+ "list": list,
+ "dict": dict,
+}
+
+_PY_TYPE_FROM_VALUE: dict[type, str] = {
+ bool: "bool",
+ int: "int",
+ float: "float",
+ str: "str",
+ list: "list",
+ dict: "dict",
+}
+
+
+def _resolve_param_type(pdef: dict[str, Any]) -> str:
+ """Pick the best Python type name for one JSON-Schema property.
+
+ Handles primitive ``"type"``, Pydantic's ``anyOf``/``oneOf`` form for ``Optional[T]``, and falls back to the type
+ of ``default``. Critical because transformers' tool-schema generator uses our Python annotations to build the
+ schema the model sees.
+ """
+ t = pdef.get("type")
+ if isinstance(t, str) and t in _JSON_TYPE_TO_PY:
+ return _JSON_TYPE_TO_PY[t]
+ for key in ("anyOf", "oneOf"):
+ for opt in pdef.get(key) or []:
+ if isinstance(opt, dict):
+ inner = opt.get("type")
+ if isinstance(inner, str) and inner in _JSON_TYPE_TO_PY and inner != "null":
+ return _JSON_TYPE_TO_PY[inner]
+ if "default" in pdef and pdef["default"] is not None:
+ for value_type, name in _PY_TYPE_FROM_VALUE.items():
+ if isinstance(pdef["default"], value_type):
+ return name
+ return "str"
+
+
+# ────────────────────────────────────────────────────────────────────
+
+
+class _RolloutEnvironment:
+ """Per-rollout TRL adapter backed by the ``openreward`` SDK.
+
+ **Internal class.** Users don't construct this directly; they create an :class:`OpenRewardSpec` and pass
+ ``spec.environment_factory`` to ``GRPOTrainer``. TRL's trainer then constructs one instance of this per rollout
+ slot.
+
+ The tool surface is built once at construction by reading the env's tools and binding one Python method per ORS
+ tool — so swapping the URL or env name is the only thing needed to train against a different environment.
+
+ Args:
+ name (`str`, *optional*):
+ openreward.ai catalog name (e.g. ``"Eigent/SETA"``). Mutually exclusive with `base_url`. Requires
+ ``OPENREWARD_API_KEY`` (env var or `api_key=`).
+ base_url (`str`, *optional*):
+ Direct URL of an ORS server (HF Space, local Docker, etc.). Mutually exclusive with `name`.
+ env_name (`str`, *optional*):
+ Name to look up on the server. Defaults to the canonical name parsed from `name`/`base_url`.
+ split (`str`, *optional*, defaults to `"train"`):
+ Split passed to ``env.session(split=, index=)``.
+ api_key (`str`, *optional*):
+ Override for ``OPENREWARD_API_KEY``. Only used with `name=`.
+ secrets (`dict[str, str]`, *optional*):
+ Per-session secrets. Forwarded to ``env.session(secrets=)``; the SDK encodes them and adds platform-domain
+ entries.
+ timeout (`float`, *optional*):
+ Reserved for future use. The SDK manages its own timeouts.
+
+ Attributes:
+ reward (`float`):
+ Last non-null reward in the trajectory (outcome-only convention).
+ rewards (`list[float | None]`):
+ Per-step reward sequence in tool-call order.
+ metadata (`list[dict | None]`):
+ Per-step ``ToolOutput.metadata`` dicts.
+ finished (`bool`):
+ True after a tool returned ``finished: true``.
+ last_output (`str`):
+ Joined text of the most recent tool result.
+ """
+
+ def __init__(
+ self,
+ *,
+ name: str | None = None,
+ base_url: str | None = None,
+ env_name: str | None = None,
+ split: str = "train",
+ api_key: str | None = None,
+ secrets: dict[str, str] | None = None,
+ timeout: float | None = None,
+ _client: Any = None,
+ _env: Any = None,
+ _tool_specs: list[Any] | None = None,
+ ) -> None:
+ if (name is None) == (base_url is None):
+ raise ValueError("Provide exactly one of: name, base_url.")
+
+ # Reuse a pre-built client/env when the spec has already discovered
+ # them (saves N HTTP calls at trainer init); otherwise build fresh.
+ if _client is None:
+ openreward = _import_openreward()
+ client_kwargs: dict[str, Any] = {}
+ if api_key:
+ client_kwargs["api_key"] = api_key
+ elif name and "OPENREWARD_API_KEY" in os.environ:
+ client_kwargs["api_key"] = os.environ["OPENREWARD_API_KEY"]
+ if base_url:
+ client_kwargs["base_url"] = base_url
+ self._client = openreward.OpenReward(**client_kwargs)
+ else:
+ self._client = _client
+
+ if _env is None:
+ target = name if name is not None else env_name or ""
+ if base_url and not target:
+ # Self-hosted single-env URL — pass any name; SDK redirects.
+ target = "env"
+ self._env = self._client.environments.get(target)
+ else:
+ self._env = _env
+
+ self._split = split
+ self._secrets = secrets
+ self._session_cm = None # the SDK context manager itself, retained for clean teardown
+ self._session = None # the entered Session object
+
+ # Episode state — read by the trainer's reward_func.
+ self.reward: float = 0.0
+ self.rewards: list[float | None] = []
+ self.metadata: list[dict[str, Any] | None] = []
+ self.finished: bool = False
+ self.last_output: str = ""
+
+ # Bind one Python method per server-side tool. Pre-fetched specs
+ # come from the spec object; otherwise we ask the SDK ourselves.
+ specs = _tool_specs if _tool_specs is not None else self._env.list_tools()
+ for spec in specs:
+ _bind_tool_method(self.__class__, _spec_to_dict(spec))
+
+ # ── TRL contract ─────────────────────────────────────────────────
+
+ def reset(
+ self,
+ *,
+ task_index: int = 0,
+ task_spec: dict[str, Any] | None = None,
+ **_: Any,
+ ) -> str:
+ """Open a fresh ORS session for this rollout.
+
+ Closes any prior session, starts a new one via the SDK's ``env.session(...)`` context manager, fetches the
+ prompt, and returns its text (which TRL appends to the user message).
+ """
+ self._teardown_session()
+ self.reward = 0.0
+ self.rewards = []
+ self.metadata = []
+ self.finished = False
+ self.last_output = ""
+
+ if task_spec is not None:
+ from openreward.api.environments.client import Task
+
+ task = Task(
+ server_name=self._env.server,
+ environment_name=self._env.name,
+ task_spec=task_spec,
+ namespace=self._env.namespace,
+ )
+ cm = self._env.session(task=task, secrets=self._secrets)
+ else:
+ cm = self._env.session(split=self._split, index=int(task_index), secrets=self._secrets)
+
+ # Retain the context manager itself so `_teardown_session` can call
+ # its __exit__; calling __exit__ on the entered Session alone leaves
+ # the CM's exit logic (which deletes the env state + sid) unrun.
+ self._session_cm = cm
+ self._session = cm.__enter__()
+ prompt = self._session.get_prompt()
+ return _join_text_blocks(prompt)
+
+ # Leading underscore so TRL's tool collector at grpo_trainer.py:502-506
+ # excludes this from the model's tool surface.
+ def _close(self) -> None:
+ """Tear down the active session (best-effort)."""
+ self._teardown_session()
+
+ # ── helpers ──────────────────────────────────────────────────────
+
+ def _teardown_session(self) -> None:
+ if self._session_cm is None:
+ return
+ try:
+ # Exit the SDK's Session context manager — this deletes both
+ # the per-rollout env state and the sid on the server.
+ self._session_cm.__exit__(None, None, None)
+ except Exception as e: # noqa: BLE001
+ logger.debug("session teardown failed: %s", e)
+ self._session_cm = None
+ self._session = None
+
+ def _call_ors_tool(self, tool_name: str, tool_input: dict[str, Any]) -> str:
+ """Invoke a server-side tool and update episode state."""
+ if self._session is None:
+ raise RuntimeError("Cannot call a tool before reset() opens a session.")
+
+ try:
+ out = self._session.call_tool(tool_name, tool_input)
+ except Exception as e: # noqa: BLE001
+ self.rewards.append(None)
+ self.metadata.append(None)
+ self.last_output = f"Error: {e}"
+ return self.last_output
+
+ # `out` is `openreward.api.environments.types.ToolOutput` — a stable dataclass
+ # with `blocks: list`, `reward: Optional[float]`, `metadata: Optional[dict]`, `finished: bool`.
+ text = _join_text_blocks(out.blocks or []) or "(no output)"
+
+ step_reward: float | None = None
+ if out.reward is not None:
+ try:
+ step_reward = float(out.reward)
+ except (TypeError, ValueError):
+ step_reward = None
+ self.rewards.append(step_reward)
+ if step_reward is not None:
+ self.reward = step_reward # last-non-null wins (outcome-only convention)
+
+ self.metadata.append(out.metadata if isinstance(out.metadata, dict) else None)
+ self.finished = bool(out.finished)
+ self.last_output = text
+ return text
+
+
+# ── dynamic tool binding ─────────────────────────────────────────────
+
+
+_VALID_TOOL_NAME = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+
+def _bind_tool_method(cls: type, spec: dict[str, Any]) -> None:
+ """Generate a typed Python method for one ORS tool spec.
+
+ Signature comes from the JSON Schema; docstring is Google-style so ``transformers.utils.get_json_schema`` (used by
+ vLLM) can produce a correct tool schema for the model.
+
+ Untrusted text from the server (tool name, descriptions) is never spliced raw into the generated source — the name
+ is validated against a Python-identifier regex and the description / per-param descriptions are passed through
+ ``repr()`` before being interpolated, so a tool description containing triple quotes can't break binding.
+ """
+ tool_name = spec["name"]
+ if not _VALID_TOOL_NAME.match(tool_name):
+ logger.warning("skipping tool with non-identifier name: %r", tool_name)
+ return
+ if tool_name in cls.__dict__:
+ # Already bound by an earlier instance — idempotent skip.
+ return
+
+ description = spec.get("description") or f"Call the {tool_name} tool."
+ schema = spec.get("input_schema") or {}
+ properties: dict[str, dict[str, Any]] = schema.get("properties") or {}
+ required: set[str] = set(schema.get("required") or [])
+
+ # Required params must come before optional ones in Python — sort.
+ required_props = [(n, p) for n, p in properties.items() if n in required]
+ optional_props = [(n, p) for n, p in properties.items() if n not in required]
+
+ params_src: list[str] = []
+ annotations: dict[str, type] = {}
+ args_doc_lines: list[str] = []
+ for pname, pdef in required_props + optional_props:
+ if not _VALID_TOOL_NAME.match(pname):
+ logger.warning("skipping tool %r — non-identifier param name: %r", tool_name, pname)
+ return
+ py_type = _resolve_param_type(pdef)
+ annotations[pname] = _PY_TYPE_OBJECTS[py_type]
+ if pname in required:
+ params_src.append(f"{pname}: {py_type}")
+ else:
+ default = pdef.get("default", None)
+ params_src.append(f"{pname}: {py_type} = {default!r}")
+ pdesc = pdef.get("description") or pdef.get("title") or pname
+ args_doc_lines.append(f" {pname}: {pdesc}")
+
+ # Build the docstring as a single repr-quoted string so triple-quotes / quotes / newlines in the description or
+ # arg text can never close out the generated docstring early.
+ docstring = description + (("\n\n Args:\n" + "\n".join(args_doc_lines)) if args_doc_lines else "")
+ src = (
+ f"def {tool_name}(self, {', '.join(params_src)}) -> str:\n"
+ f" {docstring!r}\n"
+ f" _kwargs = dict(locals()); _kwargs.pop('self', None)\n"
+ f" return self._call_ors_tool({tool_name!r}, _kwargs)\n"
+ )
+ ns: dict[str, Any] = {}
+ exec(src, ns)
+ fn = ns[tool_name]
+ fn.__qualname__ = f"{cls.__name__}.{tool_name}"
+ fn.__annotations__ = {**annotations, "return": str}
+ setattr(cls, tool_name, fn)
+
+
+# ── small utilities ──────────────────────────────────────────────────
+
+
+def _spec_to_dict(spec: Any) -> dict[str, Any]:
+ """Normalise SDK ``ToolSpec`` and dict shapes to the same dict form.
+
+ ``openreward.api.environments.types.ToolSpec`` is a stable dataclass with ``name``, ``description``,
+ ``input_schema`` fields, so direct attribute access is safe.
+ """
+ if isinstance(spec, dict):
+ return spec
+ return {
+ "name": spec.name,
+ "description": spec.description,
+ "input_schema": spec.input_schema or {},
+ }
+
+
+def _join_text_blocks(blocks: list[Any]) -> str:
+ """Concatenate the ``text`` field of every text block in order.
+
+ Accepts both SDK ``TextBlock`` dataclasses and plain dicts. Both shapes expose a ``type`` discriminator (`"text"`
+ vs `"image"`); non-text blocks are skipped so e.g. ``ImageBlock`` doesn't trip up the join.
+ """
+ if not blocks:
+ return ""
+ parts: list[str] = []
+ for b in blocks:
+ if isinstance(b, dict):
+ if b.get("type") != "text":
+ continue
+ text = b.get("text")
+ else:
+ if b.type != "text":
+ continue
+ text = b.text
+ if text:
+ parts.append(str(text))
+ return "\n".join(parts)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/orpo/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/orpo/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..88abd9e1826eae8a0d201b84a048614059b9e264
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/orpo/__init__.py
@@ -0,0 +1,19 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .orpo_config import ORPOConfig
+from .orpo_trainer import ORPOTrainer
+
+
+__all__ = ["ORPOConfig", "ORPOTrainer"]
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/orpo/orpo_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/orpo/orpo_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..78c98788824b7ce4fbfb8676dcb6fd89e488de2a
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/orpo/orpo_config.py
@@ -0,0 +1,134 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from ...trainer.base_config import _BaseConfig
+
+
+@dataclass
+class ORPOConfig(_BaseConfig):
+ # docstyle-ignore
+ r"""
+ Configuration class for the [`experimental.orpo.ORPOTrainer`].
+
+ This class includes only the parameters that are specific to ORPO training. For a full list of training arguments,
+ please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may
+ differ from those in [`~transformers.TrainingArguments`].
+
+ Using [`~transformers.HfArgumentParser`] we can turn this class into
+ [argparse](https://docs.python.org/3/library/argparse#module-argparse) arguments that can be specified on the
+ command line.
+
+ Parameters:
+ max_length (`int` or `None`, *optional*, defaults to `1024`):
+ Maximum length of the sequences (prompt + completion) in the batch. This argument is required if you want
+ to use the default data collator.
+ max_completion_length (`int`, *optional*):
+ Maximum length of the completion. This argument is required if you want to use the default data collator
+ and your model is an encoder-decoder.
+ beta (`float`, *optional*, defaults to `0.1`):
+ Parameter controlling the relative ratio loss weight in the ORPO loss. In the
+ [paper](https://huggingface.co/papers/2403.07691), it is denoted by λ. In the
+ [code](https://github.com/xfactlab/orpo), it is denoted by `alpha`.
+ disable_dropout (`bool`, *optional*, defaults to `True`):
+ Whether to disable dropout in the model.
+ padding_value (`int`, *optional*):
+ Padding value to use. If `None`, the padding value of the tokenizer is used.
+ generate_during_eval (`bool`, *optional*, defaults to `False`):
+ If `True`, generates and logs completions from the model to W&B or Comet during evaluation.
+ is_encoder_decoder (`bool`, *optional*):
+ When using the `model_init` argument (callable) to instantiate the model instead of the `model` argument,
+ you need to specify if the model returned by the callable is an encoder-decoder model.
+ model_init_kwargs (`dict[str, Any]`, *optional*):
+ Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the model from a
+ string.
+ trust_remote_code (`bool`, *optional*, defaults to `False`):
+ Whether to allow loading models that ship custom Python code from the Hub. Forwarded to
+ [`~transformers.AutoModelForCausalLM.from_pretrained`].
+ dataset_num_proc (`int`, *optional*):
+ Number of processes to use for processing the dataset.
+
+ > [!NOTE]
+ > These parameters have default values different from [`~transformers.TrainingArguments`]:
+ > - `logging_steps`: Defaults to `10` instead of `500`.
+ > - `gradient_checkpointing`: Defaults to `True` instead of `False`.
+ > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`.
+ > - `learning_rate`: Defaults to `1e-6` instead of `5e-5`.
+ """
+
+ _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs"]
+
+ # Parameters whose default values are overridden from TrainingArguments
+ learning_rate: float = field(
+ default=1e-6,
+ metadata={"help": "The initial learning rate for AdamW."},
+ )
+
+ max_length: int | None = field(
+ default=1024,
+ metadata={"help": "Maximum length of the sequences (prompt + completion) in the batch."},
+ )
+ max_completion_length: int | None = field(
+ default=None,
+ metadata={
+ "help": "Maximum length of the completion. This argument is required if you want to use the default data "
+ "collator and your model is an encoder-decoder."
+ },
+ )
+ beta: float = field(
+ default=0.1,
+ metadata={
+ "help": "Parameter controlling the relative ratio loss weight in the ORPO loss. In the paper, it is "
+ "denoted by λ."
+ },
+ )
+ disable_dropout: bool = field(
+ default=True,
+ metadata={"help": "Whether to disable dropout in the model."},
+ )
+ padding_value: int | None = field(
+ default=None,
+ metadata={"help": "Padding value to use. If `None`, the padding value of the tokenizer is used."},
+ )
+ generate_during_eval: bool = field(
+ default=False,
+ metadata={"help": "If `True`, generates and logs completions from the model to W&B during evaluation."},
+ )
+ is_encoder_decoder: bool | None = field(
+ default=None,
+ metadata={
+ "help": "When using the `model_init` argument (callable) to instantiate the model instead of the `model` "
+ "argument, you need to specify if the model returned by the callable is an encoder-decoder model."
+ },
+ )
+ model_init_kwargs: dict[str, Any] | str | None = field(
+ default=None,
+ metadata={
+ "help": "Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the model "
+ "from a string."
+ },
+ )
+ trust_remote_code: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to allow loading models that ship custom Python code from the Hub. Forwarded to "
+ "`AutoModelForCausalLM.from_pretrained`."
+ },
+ )
+ dataset_num_proc: int | None = field(
+ default=None,
+ metadata={"help": "Number of processes to use for processing the dataset."},
+ )
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/orpo/orpo_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/orpo/orpo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..2208baf98e984b75b23f1f39465ed0c3ba732a83
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/orpo/orpo_trainer.py
@@ -0,0 +1,1042 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import inspect
+import random
+import textwrap
+from collections import defaultdict
+from collections.abc import Callable
+from contextlib import nullcontext
+from pathlib import Path
+from typing import Any, Literal
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import transformers
+from accelerate import PartialState
+from accelerate.logging import get_logger
+from accelerate.utils import is_peft_model
+from datasets import Dataset
+from packaging.version import Version
+from torch import autocast
+from torch.utils.data import DataLoader
+from transformers import (
+ AutoModelForCausalLM,
+ BaseImageProcessor,
+ DataCollator,
+ FeatureExtractionMixin,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+ ProcessorMixin,
+ TrainerCallback,
+ is_comet_available,
+ is_torch_xla_available,
+ is_wandb_available,
+)
+from transformers.trainer_utils import EvalLoopOutput
+from transformers.utils import is_peft_available, is_torch_fx_proxy
+
+from ...data_utils import maybe_apply_chat_template, maybe_extract_prompt
+from ...trainer.base_trainer import _BaseTrainer
+from ...trainer.utils import disable_dropout_in_model, log_table_to_comet_experiment, selective_log_softmax
+from ..utils import (
+ DPODataCollatorWithPadding,
+ add_bos_token_if_needed,
+ add_eos_token_if_needed,
+ pad_to_length,
+ peft_module_casting_to_bf16,
+)
+from .orpo_config import ORPOConfig
+
+
+if is_peft_available():
+ from peft import PeftConfig, get_peft_model, prepare_model_for_kbit_training
+
+
+if is_wandb_available():
+ import wandb
+
+if is_torch_xla_available():
+ import torch_xla.core.xla_model as xm
+
+
+logger = get_logger(__name__)
+
+
+def log1mexp(x: torch.FloatTensor) -> torch.FloatTensor:
+ """Numerically stable computation of log(1-exp(x))."""
+ # branch at -ln 2 ~ -0.693 to avoid cancellation
+ t = -0.6931471805599453
+ return torch.where(x < t, torch.log1p(-torch.exp(x)), torch.log(-torch.expm1(x)))
+
+
+class ORPOTrainer(_BaseTrainer):
+ r"""
+ Initialize ORPOTrainer.
+
+ Args:
+ model ([`~transformers.PreTrainedModel`]):
+ The model to train, preferably an [`~transformers.AutoModelForSequenceClassification`].
+ args ([`experimental.orpo.ORPOConfig`]):
+ The ORPO config arguments to use for training.
+ data_collator ([`~transformers.DataCollator`]):
+ The data collator to use for training. If None is specified, the default data collator
+ ([`experimental.utils.DPODataCollatorWithPadding`]) will be used which will pad the sequences to the
+ maximum length of the sequences in the batch, given a dataset of paired sequences.
+ train_dataset ([`~datasets.Dataset`]):
+ The dataset to use for training.
+ eval_dataset ([`~datasets.Dataset`]):
+ The dataset to use for evaluation.
+ processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.BaseImageProcessor`], [`~transformers.FeatureExtractionMixin`] or [`~transformers.ProcessorMixin`], *optional*):
+ Processing class used to process the data. If provided, will be used to automatically process the inputs
+ for the model, and it will be saved along the model to make it easier to rerun an interrupted training or
+ reuse the fine-tuned model.
+ model_init (`Callable[[], transformers.PreTrainedModel]`):
+ The model initializer to use for training. If None is specified, the default model initializer will be
+ used.
+ callbacks (`list[transformers.TrainerCallback]`):
+ The callbacks to use for training.
+ optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`):
+ The optimizer and scheduler to use for training.
+ preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`):
+ The function to use to preprocess the logits before computing the metrics.
+ peft_config ([`~peft.PeftConfig`], *optional*):
+ The PEFT configuration to use for training. If you pass a PEFT configuration, the model will be wrapped in
+ a PEFT model.
+ compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*):
+ The function to use to compute the metrics. Must take a `EvalPrediction` and return a dictionary string to
+ metric values.
+ """
+
+ _tag_names = ["trl", "orpo"]
+ _name = "ORPO"
+ _paper = {
+ "title": "ORPO: Monolithic Preference Optimization without Reference Model",
+ "id": "2403.07691",
+ # docstyle-ignore
+ "citation": textwrap.dedent("""\
+ @article{hong2024orpo,
+ title = {{ORPO: Monolithic Preference Optimization without Reference Model}},
+ author = {Jiwoo Hong and Noah Lee and James Thorne},
+ year = 2024,
+ eprint = {arXiv:2403.07691}
+ }"""),
+ }
+
+ def __init__(
+ self,
+ model: PreTrainedModel | nn.Module | str | None = None,
+ args: ORPOConfig | None = None,
+ data_collator: DataCollator | None = None,
+ train_dataset: Dataset | None = None,
+ eval_dataset: Dataset | dict[str, Dataset] | None = None,
+ processing_class: PreTrainedTokenizerBase
+ | BaseImageProcessor
+ | FeatureExtractionMixin
+ | ProcessorMixin
+ | None = None,
+ model_init: Callable[[], PreTrainedModel] | None = None,
+ callbacks: list[TrainerCallback] | None = None,
+ optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None),
+ preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None,
+ peft_config: "PeftConfig | None" = None,
+ compute_metrics: Callable[[EvalLoopOutput], dict] | None = None,
+ ):
+ if train_dataset is None:
+ raise ValueError("`train_dataset` is required")
+
+ if args.model_init_kwargs is None:
+ model_init_kwargs = {}
+ elif not isinstance(model, str):
+ raise ValueError("You passed model_kwargs to the ORPOTrainer. But your model is already instantiated.")
+ else:
+ model_init_kwargs = args.model_init_kwargs
+ dtype = model_init_kwargs.get("dtype", "auto")
+ if dtype is not None:
+ # Convert to `torch.dtype` if an str is passed
+ if isinstance(dtype, str) and dtype != "auto":
+ dtype = getattr(torch, dtype)
+ if dtype != "auto" and not isinstance(dtype, torch.dtype):
+ raise ValueError(
+ f"Invalid `dtype` passed to the ORPOConfig. Expected a string with either `torch.dtype` or 'auto', but got {dtype}."
+ )
+ model_init_kwargs["dtype"] = dtype
+ model_init_kwargs["device_map"] = model_init_kwargs.get("device_map", "auto")
+
+ model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+
+ if isinstance(model, str):
+ model = AutoModelForCausalLM.from_pretrained(model, **model_init_kwargs)
+
+ # PEFT
+ # Initialize this variable to False. This helps tracking the case when `peft_module_casting_to_bf16`
+ # has been called in order to properly call autocast if needed.
+ self._peft_has_been_casted_to_bf16 = False
+ if peft_config is not None:
+ if not is_peft_available():
+ raise ImportError(
+ "You passed `peft_config` but the `peft` library is not installed. "
+ "Install it with `pip install trl[peft]`."
+ )
+ if not isinstance(peft_config, PeftConfig):
+ raise TypeError(
+ f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), "
+ f"got {type(peft_config).__name__}."
+ )
+ if is_peft_model(model):
+ raise ValueError(
+ "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first "
+ "merge and unload the existing adapter, save the resulting base model, and then pass that base "
+ "model along with the new `peft_config` to the trainer."
+ )
+
+ if getattr(model, "is_loaded_in_8bit", False) or getattr(model, "is_loaded_in_4bit", False):
+ _support_gc_kwargs = hasattr(
+ args, "gradient_checkpointing_kwargs"
+ ) and "gradient_checkpointing_kwargs" in list(
+ inspect.signature(prepare_model_for_kbit_training).parameters
+ )
+
+ prepare_model_kwargs = {"use_gradient_checkpointing": args.gradient_checkpointing}
+
+ if _support_gc_kwargs:
+ prepare_model_kwargs["gradient_checkpointing_kwargs"] = args.gradient_checkpointing_kwargs
+
+ model = prepare_model_for_kbit_training(model, **prepare_model_kwargs)
+ elif args.gradient_checkpointing:
+ # For backward compatibility with older versions of transformers
+ if hasattr(model, "enable_input_require_grads"):
+ model.enable_input_require_grads()
+ else:
+
+ def make_inputs_require_grad(module, input, output):
+ output.requires_grad_(True)
+
+ model.get_input_embeddings().register_forward_hook(make_inputs_require_grad)
+
+ # get peft model with the given config
+ model = get_peft_model(model, peft_config)
+ if args.bf16 and getattr(model, "is_loaded_in_4bit", False):
+ peft_module_casting_to_bf16(model)
+ # If args.bf16 we need to explicitly call `generate` with torch amp autocast context manager
+ self._peft_has_been_casted_to_bf16 = True
+
+ # For models that use gradient_checkpointing, we need to attach a hook that enables input
+ # to explicitly have `requires_grad=True`, otherwise training will either silently
+ # fail or completely fail.
+ elif args.gradient_checkpointing:
+ # For backward compatibility with older versions of transformers
+ if hasattr(model, "enable_input_require_grads"):
+ model.enable_input_require_grads()
+ else:
+
+ def make_inputs_require_grad(module, input, output):
+ output.requires_grad_(True)
+
+ model.get_input_embeddings().register_forward_hook(make_inputs_require_grad)
+
+ if args.generate_during_eval and not (is_wandb_available() or is_comet_available()):
+ raise ValueError(
+ "`generate_during_eval=True` requires Weights and Biases or Comet to be installed."
+ " Please install `wandb` or `comet-ml` to resolve."
+ )
+
+ if model is not None:
+ self.is_encoder_decoder = model.config.is_encoder_decoder
+ elif args.is_encoder_decoder is None:
+ raise ValueError("When no model is provided, you need to pass the parameter is_encoder_decoder.")
+ else:
+ self.is_encoder_decoder = args.is_encoder_decoder
+
+ if self.is_encoder_decoder:
+ self.decoder_start_token_id = model.config.decoder_start_token_id
+ self.pad_token_id = model.config.pad_token_id
+
+ if processing_class is None:
+ raise ValueError("processing_class must be specified to tokenize a ORPO dataset.")
+ if args.max_length is None:
+ logger.warning(
+ "`max_length` is not set in the ORPOConfig's init"
+ " it will default to `512` by default, but you should do it yourself in the future.",
+ )
+ max_length = 512
+ else:
+ max_length = args.max_length
+
+ if args.max_completion_length is None and self.is_encoder_decoder:
+ logger.warning(
+ "When using an encoder decoder architecture, you should set `max_completion_length` in the ORPOConfig's init"
+ " it will default to `128` by default, but you should do it yourself in the future.",
+ )
+ self.max_completion_length = 128
+ else:
+ self.max_completion_length = args.max_completion_length
+
+ if data_collator is None:
+ data_collator = DPODataCollatorWithPadding(
+ pad_token_id=processing_class.pad_token_id,
+ is_encoder_decoder=self.is_encoder_decoder,
+ )
+
+ if args.remove_unused_columns:
+ args.remove_unused_columns = False
+ # warn users
+ logger.warning(
+ "When using DPODataCollatorWithPadding, you should set `remove_unused_columns=False` in your TrainingArguments"
+ " we have set it for you, but you should do it yourself in the future.",
+ )
+
+ self.use_dpo_data_collator = True
+ else:
+ self.use_dpo_data_collator = False
+
+ # Disable dropout in the model and reference model
+ if args.disable_dropout:
+ disable_dropout_in_model(model)
+
+ self.max_length = max_length
+ self.generate_during_eval = args.generate_during_eval
+ self.padding_value = args.padding_value if args.padding_value is not None else processing_class.pad_token_id
+ self.processing_class = processing_class
+
+ self.beta = args.beta
+ self.aux_loss_enabled = getattr(model.config, "output_router_logits", False)
+ self.aux_loss_coef = getattr(model.config, "router_aux_loss_coef", 0.0)
+ if self.aux_loss_enabled and self.aux_loss_coef == 0.0:
+ logger.warning(
+ "You set `output_router_logits` to `True` in the model config, but `router_aux_loss_coef` is set to "
+ "`0.0`, meaning the auxiliary loss will not be used. Either set `router_aux_loss_coef` to a value "
+ "greater than `0.0`, or set `output_router_logits` to `False` if you don't want to use the auxiliary "
+ "loss.",
+ )
+
+ self._stored_metrics = defaultdict(lambda: defaultdict(list))
+
+ # Compute that only on the main process for faster data processing.
+ # see: https://github.com/huggingface/trl/pull/1255
+ with PartialState().main_process_first():
+ # Extract the prompt if needed, and apply the chat template if needed
+ train_dataset = train_dataset.map(maybe_extract_prompt, num_proc=args.dataset_num_proc)
+ train_dataset = train_dataset.map(
+ maybe_apply_chat_template,
+ fn_kwargs={"processing_class": processing_class},
+ num_proc=args.dataset_num_proc,
+ )
+ train_dataset = train_dataset.map(self.tokenize_row, num_proc=args.dataset_num_proc)
+ if eval_dataset is not None:
+ eval_dataset = eval_dataset.map(maybe_extract_prompt, num_proc=args.dataset_num_proc)
+ eval_dataset = eval_dataset.map(
+ maybe_apply_chat_template,
+ fn_kwargs={"processing_class": processing_class},
+ num_proc=args.dataset_num_proc,
+ )
+ eval_dataset = eval_dataset.map(self.tokenize_row, num_proc=args.dataset_num_proc)
+
+ # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was
+ # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream
+ # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we
+ # default to the recommended non-reentrant behavior here, while preserving any user-provided value.
+ if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"):
+ args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {}
+ args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False)
+
+ super().__init__(
+ model=model,
+ args=args,
+ data_collator=data_collator,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=processing_class,
+ model_init=model_init,
+ compute_metrics=compute_metrics,
+ callbacks=callbacks,
+ optimizers=optimizers,
+ preprocess_logits_for_metrics=preprocess_logits_for_metrics,
+ )
+
+ # Gradient accumulation requires scaled loss. Normally, loss scaling in the parent class depends on whether the
+ # model accepts loss-related kwargs. Since we compute our own loss, this check is irrelevant. We set
+ # self.model_accepts_loss_kwargs to False to enable scaling.
+ self.model_accepts_loss_kwargs = False
+
+ # Add tags for models that have been loaded with the correct transformers version
+ if hasattr(self.model, "add_model_tags"):
+ self.model.add_model_tags(self._tag_names)
+
+ if not hasattr(self, "accelerator"):
+ raise AttributeError(
+ "Your `Trainer` does not have an `accelerator` object. Consider upgrading `transformers`."
+ )
+
+ def build_tokenized_answer(self, prompt, answer):
+ """
+ Llama tokenizer does satisfy `enc(a + b) = enc(a) + enc(b)`. It does ensure `enc(a + b) = enc(a) + enc(a +
+ b)[len(enc(a)):]`. Reference:
+ https://github.com/EleutherAI/lm-evaluation-harness/pull/531#issuecomment-1595586257
+ """
+
+ full_tokenized = self.processing_class(prompt + answer, add_special_tokens=False)
+ prompt_input_ids = self.processing_class(prompt, add_special_tokens=False)["input_ids"]
+
+ answer_input_ids = full_tokenized["input_ids"][len(prompt_input_ids) :]
+ answer_attention_mask = full_tokenized["attention_mask"][len(prompt_input_ids) :]
+
+ # Concat tokens to form `enc(a) + enc(a + b)[len(enc(a)):]`
+ full_concat_input_ids = np.concatenate([prompt_input_ids, answer_input_ids])
+
+ # Prepare input tokens for token by token comparison
+ full_input_ids = np.array(full_tokenized["input_ids"])
+
+ if len(full_input_ids) != len(full_concat_input_ids):
+ raise ValueError("Prompt input ids and answer input ids should have the same length.")
+
+ # On some tokenizers, like Llama-2 tokenizer, there are occasions where tokens
+ # can be merged together when tokenizing prompt+answer. This could result
+ # on the last token from the prompt being different when tokenized on its own
+ # vs when done as prompt+answer.
+ response_token_ids_start_idx = len(prompt_input_ids)
+
+ # If tokenized prompt is different than both prompt+answer, then it means the
+ # last token has changed due to merging.
+ if prompt_input_ids != full_tokenized["input_ids"][:response_token_ids_start_idx]:
+ response_token_ids_start_idx -= 1
+
+ prompt_input_ids = full_tokenized["input_ids"][:response_token_ids_start_idx]
+ prompt_attention_mask = full_tokenized["attention_mask"][:response_token_ids_start_idx]
+
+ if len(prompt_input_ids) != len(prompt_attention_mask):
+ raise ValueError("Prompt input ids and attention mask should have the same length.")
+
+ answer_input_ids = full_tokenized["input_ids"][response_token_ids_start_idx:]
+ answer_attention_mask = full_tokenized["attention_mask"][response_token_ids_start_idx:]
+
+ return dict(
+ prompt_input_ids=prompt_input_ids,
+ prompt_attention_mask=prompt_attention_mask,
+ input_ids=answer_input_ids,
+ attention_mask=answer_attention_mask,
+ )
+
+ def tokenize_row(self, feature, model: PreTrainedModel | nn.Module | None = None) -> dict:
+ """Tokenize a single row from a ORPO specific dataset.
+
+ At this stage, we don't convert to PyTorch tensors yet; we just handle the truncation in case the prompt +
+ chosen or prompt + rejected responses is/are too long. First we truncate the prompt; if we're still too long,
+ we truncate the chosen/rejected.
+
+ We also create the labels for the chosen/rejected responses, which are of length equal to the sum of the length
+ of the prompt and the chosen/rejected response, with `-100` for the prompt tokens.
+ """
+ batch = {}
+ prompt = feature["prompt"]
+ chosen = feature["chosen"]
+ rejected = feature["rejected"]
+
+ if not self.is_encoder_decoder:
+ # Check issues below for more details
+ # 1. https://github.com/huggingface/trl/issues/907
+ # 2. https://github.com/EleutherAI/lm-evaluation-harness/pull/531#issuecomment-1595586257
+ # 3. https://github.com/LianjiaTech/BELLE/issues/337
+
+ if not isinstance(prompt, str):
+ raise ValueError(f"prompt should be an str but got {type(prompt)}")
+ prompt_tokens = self.processing_class(prompt, add_special_tokens=False)
+ prompt_tokens = {f"prompt_{k}": v for k, v in prompt_tokens.items()}
+
+ if not isinstance(chosen, str):
+ raise ValueError(f"chosen should be an str but got {type(chosen)}")
+ chosen_tokens = self.build_tokenized_answer(prompt, chosen)
+
+ if not isinstance(rejected, str):
+ raise ValueError(f"rejected should be an str but got {type(rejected)}")
+ rejected_tokens = self.build_tokenized_answer(prompt, rejected)
+
+ # Last prompt token might get merged by tokenizer and
+ # it should not be included for generation if that happens
+ prompt_len_input_ids = len(prompt_tokens["prompt_input_ids"])
+
+ chosen_prompt_len_input_ids = len(chosen_tokens["prompt_input_ids"])
+ rejected_prompt_len_input_ids = len(rejected_tokens["prompt_input_ids"])
+ prompt_len_input_ids = min(chosen_prompt_len_input_ids, rejected_prompt_len_input_ids)
+
+ for k, v in prompt_tokens.items():
+ prompt_tokens[k] = v[:prompt_len_input_ids]
+
+ # Make sure prompts only have one different token at most an
+ # and length only differs by 1 at most
+ num_diff_tokens = sum(
+ a != b
+ for a, b in zip(chosen_tokens["prompt_input_ids"], rejected_tokens["prompt_input_ids"], strict=False)
+ )
+ num_diff_len = abs(chosen_prompt_len_input_ids - rejected_prompt_len_input_ids)
+ if num_diff_tokens > 1 or num_diff_len > 1:
+ raise ValueError(
+ "Chosen and rejected prompt_input_ids might only differ on the "
+ "last token due to tokenizer merge ops."
+ )
+
+ # add BOS token to head of prompt. Avoid adding if it's already there
+ prompt_tokens, chosen_tokens, rejected_tokens = add_bos_token_if_needed(
+ self.processing_class.bos_token_id,
+ prompt_len_input_ids,
+ prompt_tokens,
+ chosen_prompt_len_input_ids,
+ chosen_tokens,
+ rejected_prompt_len_input_ids,
+ rejected_tokens,
+ )
+
+ # add EOS token to end of answer. Avoid adding if it's already there
+ chosen_tokens, rejected_tokens = add_eos_token_if_needed(
+ self.processing_class.eos_token_id, chosen_tokens, rejected_tokens
+ )
+
+ longer_response_length = max(len(chosen_tokens["input_ids"]), len(rejected_tokens["input_ids"]))
+
+ # if combined sequence is too long, truncate the response
+ for answer_tokens in [chosen_tokens, rejected_tokens]:
+ if len(answer_tokens["prompt_input_ids"]) + longer_response_length > self.max_length:
+ for k in ["input_ids", "attention_mask"]:
+ answer_tokens[k] = answer_tokens[k][: self.max_length - longer_response_length]
+
+ # Create labels
+ chosen_sequence_tokens = {
+ k: chosen_tokens[f"prompt_{k}"] + chosen_tokens[k] for k in ["input_ids", "attention_mask"]
+ }
+ rejected_sequence_tokens = {
+ k: rejected_tokens[f"prompt_{k}"] + rejected_tokens[k] for k in ["input_ids", "attention_mask"]
+ }
+ chosen_sequence_tokens["labels"] = chosen_sequence_tokens["input_ids"][:]
+ chosen_sequence_tokens["labels"][: len(chosen_tokens["prompt_input_ids"])] = [-100] * len(
+ chosen_tokens["prompt_input_ids"]
+ )
+ rejected_sequence_tokens["labels"] = rejected_sequence_tokens["input_ids"][:]
+ rejected_sequence_tokens["labels"][: len(rejected_tokens["prompt_input_ids"])] = [-100] * len(
+ rejected_tokens["prompt_input_ids"]
+ )
+
+ for k, toks in {
+ "chosen_": chosen_sequence_tokens,
+ "rejected_": rejected_sequence_tokens,
+ "": prompt_tokens,
+ }.items():
+ for type_key, tokens in toks.items():
+ if type_key == "token_type_ids":
+ continue
+ batch[f"{k}{type_key}"] = tokens
+
+ else:
+ chosen_tokens = self.processing_class(
+ chosen, truncation=True, max_length=self.max_completion_length, add_special_tokens=True
+ )
+ rejected_tokens = self.processing_class(
+ rejected, truncation=True, max_length=self.max_completion_length, add_special_tokens=True
+ )
+ prompt_tokens = self.processing_class(prompt, add_special_tokens=True)
+
+ batch["chosen_labels"] = chosen_tokens["input_ids"]
+ batch["rejected_labels"] = rejected_tokens["input_ids"]
+ batch["prompt_input_ids"] = prompt_tokens["input_ids"]
+ batch["prompt_attention_mask"] = prompt_tokens["attention_mask"]
+
+ if model is not None and hasattr(model, "prepare_decoder_input_ids_from_labels"):
+ batch["rejected_decoder_input_ids"] = model.prepare_decoder_input_ids_from_labels(
+ labels=torch.tensor(batch["rejected_labels"])
+ )
+ batch["chosen_decoder_input_ids"] = model.prepare_decoder_input_ids_from_labels(
+ labels=torch.tensor(batch["chosen_labels"])
+ )
+
+ if is_torch_xla_available():
+ # Pad the sequences to global max_length to avoid TorchXLA recompilation
+ for k in batch:
+ if "labels" in k or self.is_encoder_decoder:
+ pad_value = -100
+ elif k.endswith("_input_ids"):
+ pad_value = self.padding_value
+ elif k.endswith("_attention_mask"):
+ pad_value = 0
+ batch[k] = batch[k] + [pad_value] * (self.max_length - len(batch[k]))
+ return batch
+
+ @staticmethod
+ def concatenated_inputs(
+ batch: dict[str, list | torch.LongTensor],
+ is_encoder_decoder: bool = False,
+ padding_value: int = 0,
+ device: torch.device | None = None,
+ ) -> dict[str, torch.LongTensor]:
+ """Concatenate the chosen and rejected inputs into a single tensor.
+
+ Args:
+ batch:
+ A batch of data. Must contain the keys 'chosen_input_ids' and 'rejected_input_ids', which are tensors
+ of shape (batch_size, sequence_length).
+ is_encoder_decoder:
+ Whether the model is an encoder-decoder model.
+ padding_value:
+ The padding value to use for the concatenated inputs_ids.
+ device:
+ The device for the concatenated inputs.
+
+ Returns:
+ A dictionary containing the concatenated inputs under the key 'concatenated_input_ids'.
+ """
+ concatenated_batch = {}
+
+ if is_encoder_decoder:
+ max_length = max(batch["chosen_labels"].shape[1], batch["rejected_labels"].shape[1])
+ else:
+ max_length = max(batch["chosen_input_ids"].shape[1], batch["rejected_input_ids"].shape[1])
+
+ for k in batch:
+ if k.startswith("chosen") and isinstance(batch[k], torch.Tensor):
+ if "labels" in k or is_encoder_decoder:
+ pad_value = -100
+ elif k.endswith("_input_ids"):
+ pad_value = padding_value
+ elif k.endswith("_attention_mask"):
+ pad_value = 0
+ concatenated_key = k.replace("chosen", "concatenated")
+ concatenated_batch[concatenated_key] = pad_to_length(batch[k], max_length, pad_value=pad_value)
+ for k in batch:
+ if k.startswith("rejected") and isinstance(batch[k], torch.Tensor):
+ if "labels" in k or is_encoder_decoder:
+ pad_value = -100
+ elif k.endswith("_input_ids"):
+ pad_value = padding_value
+ elif k.endswith("_attention_mask"):
+ pad_value = 0
+ concatenated_key = k.replace("rejected", "concatenated")
+ concatenated_batch[concatenated_key] = torch.cat(
+ (
+ concatenated_batch[concatenated_key],
+ pad_to_length(batch[k], max_length, pad_value=pad_value),
+ ),
+ dim=0,
+ ).to(device=device)
+
+ if is_encoder_decoder:
+ concatenated_batch["concatenated_input_ids"] = batch["prompt_input_ids"].repeat(2, 1).to(device=device)
+ concatenated_batch["concatenated_attention_mask"] = (
+ batch["prompt_attention_mask"].repeat(2, 1).to(device=device)
+ )
+
+ return concatenated_batch
+
+ def odds_ratio_loss(
+ self,
+ policy_chosen_logps: torch.FloatTensor,
+ policy_rejected_logps: torch.FloatTensor,
+ ) -> tuple[torch.FloatTensor, torch.FloatTensor, torch.FloatTensor, torch.FloatTensor, torch.FloatTensor]:
+ """Compute ORPO's odds ratio (OR) loss for a batch of policy and reference model log probabilities.
+
+ Args:
+ policy_chosen_logps:
+ Log probabilities of the policy model for the chosen responses. Shape: (batch_size,)
+ policy_rejected_logps:
+ Log probabilities of the policy model for the rejected responses. Shape: (batch_size,)
+
+ Returns:
+ A tuple of three tensors: (losses, chosen_rewards, rejected_rewards). The losses tensor contains the ORPO
+ loss for each example in the batch. The chosen_rewards and rejected_rewards tensors contain the rewards for
+ the chosen and rejected responses, respectively. The log odds ratio of the chosen responses over the
+ rejected responses ratio for logging purposes. The `log(sigmoid(log_odds_chosen))` for logging purposes.
+ """
+
+ # Derived from Eqs. (4) and (7) from https://huggingface.co/papers/2403.07691 by using log identities and exp(log(P(y|x)) = P(y|x)
+ policy_chosen_logps = policy_chosen_logps.float()
+ policy_rejected_logps = policy_rejected_logps.float()
+ log_odds = (policy_chosen_logps - policy_rejected_logps) - (
+ log1mexp(policy_chosen_logps) - log1mexp(policy_rejected_logps)
+ )
+ ratio = F.logsigmoid(log_odds)
+ losses = self.beta * ratio
+
+ chosen_rewards = self.beta * (policy_chosen_logps.to(self.accelerator.device)).detach()
+ rejected_rewards = self.beta * (policy_rejected_logps.to(self.accelerator.device)).detach()
+
+ return losses, chosen_rewards, rejected_rewards, torch.mean(ratio), torch.mean(log_odds)
+
+ @staticmethod
+ def get_batch_logps(
+ logits: torch.FloatTensor,
+ labels: torch.LongTensor,
+ average_log_prob: bool = False,
+ is_encoder_decoder: bool = False,
+ ) -> torch.FloatTensor:
+ """Compute the log probabilities of the given labels under the given logits.
+
+ Args:
+ logits: Logits of the model (unnormalized). Shape: (batch_size, sequence_length, vocab_size)
+ labels:
+ Labels for which to compute the log probabilities. Label tokens with a value of `-100` are ignored.
+ Shape: (batch_size, sequence_length)
+ average_log_prob:
+ If True, return the average log probability per (non-masked) token. Otherwise, return the sum of the
+ log probabilities of the (non-masked) tokens.
+ is_encoder_decoder: Whether the model is an encoder-decoder model.
+
+ Returns:
+ A tensor of shape (batch_size,) containing the average/sum log probabilities of the given labels under the
+ given logits.
+ """
+ if logits.shape[:-1] != labels.shape:
+ raise ValueError("Logits (batch and sequence length dim) and labels must have the same shape.")
+
+ if not is_encoder_decoder:
+ labels = labels[:, 1:].clone()
+ logits = logits[:, :-1, :]
+ loss_mask = labels != -100
+
+ # dummy token; we'll ignore the losses on these tokens later
+ labels = torch.where(labels == -100, 0, labels)
+
+ per_token_logps = selective_log_softmax(logits, labels)
+
+ if average_log_prob:
+ return (per_token_logps * loss_mask).sum(-1) / loss_mask.sum(-1)
+ else:
+ return (per_token_logps * loss_mask).sum(-1)
+
+ def concatenated_forward(
+ self, model: nn.Module, batch: dict[str, list | torch.LongTensor]
+ ) -> tuple[torch.FloatTensor, torch.FloatTensor, torch.FloatTensor, torch.FloatTensor]:
+ """Run the given model on the given batch of inputs, concatenating the chosen and rejected inputs together.
+
+ We do this to avoid doing two forward passes, because it's faster for FSDP.
+ """
+ concatenated_batch = self.concatenated_inputs(
+ batch,
+ is_encoder_decoder=self.is_encoder_decoder,
+ padding_value=self.padding_value,
+ device=self.accelerator.device,
+ )
+ len_chosen = batch["chosen_labels"].shape[0]
+
+ model_kwargs = (
+ {
+ "decoder_input_ids": self._shift_right(concatenated_batch["concatenated_labels"]),
+ }
+ if self.is_encoder_decoder
+ else {}
+ )
+
+ if self.aux_loss_enabled:
+ model_kwargs["output_router_logits"] = True
+
+ outputs = model(
+ concatenated_batch["concatenated_input_ids"],
+ attention_mask=concatenated_batch["concatenated_attention_mask"],
+ use_cache=False,
+ **model_kwargs,
+ )
+ all_logits = outputs.logits
+
+ def cross_entropy_loss(logits, labels):
+ if not self.is_encoder_decoder:
+ # Shift so that tokens < n predict n
+ logits = logits[..., :-1, :].contiguous()
+ labels = labels[..., 1:].contiguous()
+ # Flatten the tokens
+ loss_fct = nn.CrossEntropyLoss()
+ logits = logits.view(-1, logits.shape[-1])
+ labels = labels.view(-1)
+ # Enable model parallelism
+ labels = labels.to(logits.device)
+ loss = loss_fct(logits, labels)
+ return loss
+
+ if self.is_encoder_decoder:
+ labels = concatenated_batch["concatenated_labels"].clone()
+ else:
+ labels = concatenated_batch["concatenated_input_ids"].clone()
+ attention_mask = concatenated_batch["concatenated_attention_mask"]
+ labels = torch.where(attention_mask == 1, labels, -100)
+ # orpo chosen nll loss is computed over the full prompt and response
+ chosen_nll_loss = cross_entropy_loss(all_logits[:len_chosen], labels[:len_chosen])
+
+ all_logps = self.get_batch_logps(
+ all_logits,
+ concatenated_batch["concatenated_labels"],
+ average_log_prob=True,
+ is_encoder_decoder=self.is_encoder_decoder,
+ )
+
+ chosen_logps = all_logps[:len_chosen]
+ rejected_logps = all_logps[len_chosen:]
+
+ if not self.is_encoder_decoder:
+ chosen_logits = all_logits[:len_chosen, :-1, :]
+ rejected_logits = all_logits[len_chosen:, :-1, :]
+ else:
+ chosen_logits = all_logits[:len_chosen]
+ rejected_logits = all_logits[len_chosen:]
+
+ if self.aux_loss_enabled:
+ return (chosen_logps, rejected_logps, chosen_logits, rejected_logits, chosen_nll_loss, outputs.aux_loss)
+
+ return (chosen_logps, rejected_logps, chosen_logits, rejected_logits, chosen_nll_loss)
+
+ def get_batch_loss_metrics(
+ self,
+ model,
+ batch: dict[str, list | torch.LongTensor],
+ train_eval: Literal["train", "eval"] = "train",
+ ):
+ """Compute the ORPO loss and other metrics for the given batch of inputs for train or test."""
+ metrics = {}
+
+ forward_output = self.concatenated_forward(model, batch)
+ (
+ policy_chosen_logps,
+ policy_rejected_logps,
+ policy_chosen_logits,
+ policy_rejected_logits,
+ policy_nll_loss,
+ ) = forward_output[:5]
+ if self.aux_loss_enabled:
+ aux_loss = forward_output[5]
+
+ losses, chosen_rewards, rejected_rewards, log_odds_ratio, log_odds_chosen = self.odds_ratio_loss(
+ policy_chosen_logps, policy_rejected_logps
+ )
+ # full ORPO loss
+ loss = policy_nll_loss - losses.mean()
+
+ reward_accuracies = (chosen_rewards > rejected_rewards).float()
+
+ prefix = "eval_" if train_eval == "eval" else ""
+ metrics[f"{prefix}rewards/chosen"] = self.accelerator.gather_for_metrics(chosen_rewards).mean()
+ metrics[f"{prefix}rewards/rejected"] = self.accelerator.gather_for_metrics(rejected_rewards).mean()
+ metrics[f"{prefix}rewards/accuracies"] = self.accelerator.gather_for_metrics(reward_accuracies).mean()
+ metrics[f"{prefix}rewards/margins"] = self.accelerator.gather_for_metrics(
+ chosen_rewards - rejected_rewards
+ ).mean()
+ metrics[f"{prefix}logps/rejected"] = self.accelerator.gather_for_metrics(policy_rejected_logps).detach().mean()
+ metrics[f"{prefix}logps/chosen"] = self.accelerator.gather_for_metrics(policy_chosen_logps).detach().mean()
+ metrics[f"{prefix}logits/rejected"] = self.accelerator.gather_for_metrics(
+ policy_rejected_logits.detach().mean()
+ ).mean()
+ metrics[f"{prefix}logits/chosen"] = self.accelerator.gather_for_metrics(
+ policy_chosen_logits.detach().mean()
+ ).mean()
+ metrics[f"{prefix}nll_loss"] = self.accelerator.gather_for_metrics(policy_nll_loss).detach().mean()
+ metrics[f"{prefix}log_odds_ratio"] = self.accelerator.gather_for_metrics(log_odds_ratio).detach().mean()
+ metrics[f"{prefix}log_odds_chosen"] = self.accelerator.gather_for_metrics(log_odds_chosen).detach().mean()
+ if is_torch_xla_available():
+ xm.mark_step() # needed because .item() calls
+ for k, v in metrics.items():
+ metrics[k] = v.item()
+ if self.aux_loss_enabled:
+ loss += self.aux_loss_coef * aux_loss
+
+ return loss, metrics
+
+ def compute_loss(
+ self,
+ model: PreTrainedModel | nn.Module,
+ inputs: dict[str, torch.Tensor | Any],
+ return_outputs=False,
+ num_items_in_batch=None,
+ ) -> torch.Tensor | tuple[torch.Tensor, dict[str, torch.Tensor]]:
+ compute_loss_context_manager = (
+ autocast(self.accelerator.device.type) if self._peft_has_been_casted_to_bf16 else nullcontext()
+ )
+
+ with compute_loss_context_manager:
+ loss, metrics = self.get_batch_loss_metrics(model, inputs, train_eval="train")
+
+ # Make sure to move the loss to the device the original accumulating loss is at back in the `Trainer` class:
+ loss = loss.to(self.args.device)
+
+ # force log the metrics
+ self.store_metrics(metrics, train_eval="train")
+
+ if return_outputs:
+ return (loss, metrics)
+ return loss
+
+ def generate_from_model(self, model, batch: dict[str, torch.LongTensor]) -> str:
+ """Generate samples from the model and reference model for the given batch of inputs."""
+
+ # If one uses `generate_during_eval` with peft + bf16, we need to explicitly call generate with
+ # the torch amp context manager as some hidden states are silently casted to full precision.
+ generate_context_manager = (
+ autocast(self.accelerator.device.type) if self._peft_has_been_casted_to_bf16 else nullcontext()
+ )
+
+ with generate_context_manager:
+ policy_output = model.generate(
+ input_ids=batch["prompt_input_ids"],
+ attention_mask=batch["prompt_attention_mask"],
+ max_length=self.max_length,
+ do_sample=True,
+ pad_token_id=self.processing_class.pad_token_id,
+ )
+
+ policy_output = pad_to_length(policy_output, self.max_length, self.processing_class.pad_token_id)
+ policy_output_decoded = self.processing_class.batch_decode(policy_output, skip_special_tokens=True)
+
+ return policy_output_decoded
+
+ def prediction_step(
+ self,
+ model: PreTrainedModel | nn.Module,
+ inputs: dict[str, torch.Tensor | Any],
+ prediction_loss_only: bool,
+ ignore_keys: list[str] | None = None,
+ ):
+ if not self.use_dpo_data_collator:
+ logger.warning(
+ "prediction_step is only implemented for DPODataCollatorWithPadding, and you passed a datacollator that is different than "
+ "DPODataCollatorWithPadding - you might see unexpected behavior. Alternatively, you can implement your own prediction_step method if you are using a custom data collator"
+ )
+ if ignore_keys is None:
+ if hasattr(model, "config"):
+ ignore_keys = getattr(model.config, "keys_to_ignore_at_inference", [])
+ else:
+ ignore_keys = []
+
+ prediction_context_manager = (
+ autocast(self.accelerator.device.type) if self._peft_has_been_casted_to_bf16 else nullcontext()
+ )
+
+ with torch.no_grad(), prediction_context_manager:
+ loss, metrics = self.get_batch_loss_metrics(model, inputs, train_eval="eval")
+
+ # force log the metrics
+ self.store_metrics(metrics, train_eval="eval")
+
+ if prediction_loss_only:
+ return (loss.detach(), None, None)
+
+ # logits for the chosen and rejected samples from model
+ logits_dict = {
+ "eval_logits/chosen": metrics["eval_logits/chosen"],
+ "eval_logits/rejected": metrics["eval_logits/rejected"],
+ }
+ logits = [v for k, v in logits_dict.items() if k not in ignore_keys]
+ logits = torch.tensor(logits, device=self.accelerator.device)
+ labels = torch.zeros(logits.shape[0], device=self.accelerator.device)
+
+ return (loss.detach(), logits, labels)
+
+ def store_metrics(self, metrics: dict[str, float], train_eval: Literal["train", "eval"] = "train") -> None:
+ for key, value in metrics.items():
+ self._stored_metrics[train_eval][key].append(value)
+
+ def evaluation_loop(
+ self,
+ dataloader: DataLoader,
+ description: str,
+ prediction_loss_only: bool | None = None,
+ ignore_keys: list[str] | None = None,
+ metric_key_prefix: str = "eval",
+ ) -> EvalLoopOutput:
+ """
+ Overriding built-in evaluation loop to store metrics for each batch. Prediction/evaluation loop, shared by
+ `Trainer.evaluate()` and `Trainer.predict()`.
+
+ Works both with or without labels.
+ """
+
+ # Sample and save to game log if requested (for one batch to save time)
+ if self.generate_during_eval:
+ # Generate random indices within the range of the total number of samples
+ num_samples = len(dataloader.dataset)
+ random_indices = random.sample(range(num_samples), k=self.args.eval_batch_size)
+
+ # Use dataloader.dataset.select to get the random batch without iterating over the DataLoader
+ random_batch_dataset = dataloader.dataset.select(random_indices)
+ random_batch = self.data_collator(random_batch_dataset)
+ random_batch = self._prepare_inputs(random_batch)
+
+ policy_output_decoded = self.generate_from_model(self.model, random_batch)
+
+ table = pd.DataFrame(
+ columns=["Prompt", "Policy"],
+ data=[
+ [prompt, pol[len(prompt) :]]
+ for prompt, pol in zip(random_batch["prompt"], policy_output_decoded, strict=True)
+ ],
+ )
+ if "wandb" in self.args.report_to:
+ wandb.log({"game_log": wandb.Table(data=table)})
+
+ if "comet_ml" in self.args.report_to:
+ log_table_to_comet_experiment(
+ name="game_log.csv",
+ table=table,
+ )
+
+ # Base evaluation
+ initial_output = super().evaluation_loop(
+ dataloader, description, prediction_loss_only, ignore_keys, metric_key_prefix
+ )
+
+ return initial_output
+
+ def log(self, logs: dict[str, float], start_time: float | None = None) -> None:
+ """
+ Log `logs` on the various objects watching training, including stored metrics.
+
+ Args:
+ logs (`dict[str, float]`):
+ The values to log.
+ start_time (`float`, *optional*):
+ Start time of the training.
+ """
+ # logs either has 'loss' or 'eval_loss'
+ train_eval = "train" if "loss" in logs else "eval"
+ # Add averaged stored metrics to logs
+ for key, metrics in self._stored_metrics[train_eval].items():
+ logs[key] = torch.tensor(metrics).mean().item()
+ del self._stored_metrics[train_eval]
+ return super().log(logs, start_time)
+
+ def _shift_right(self, input_ids):
+ if self.decoder_start_token_id is None:
+ raise ValueError(
+ "model.config.decoder_start_token_id has to be defined. It is usually set to the pad_token_id."
+ )
+
+ # shift inputs to the right
+ if is_torch_fx_proxy(input_ids):
+ # Item assignment is not supported natively for proxies.
+ shifted_input_ids = torch.full(input_ids.shape[:-1] + (1,), self.decoder_start_token_id)
+ shifted_input_ids = torch.cat([shifted_input_ids, input_ids[..., :-1]], dim=-1)
+ else:
+ shifted_input_ids = input_ids.new_zeros(input_ids.shape)
+ shifted_input_ids[..., 1:] = input_ids[..., :-1].clone()
+ shifted_input_ids[..., 0] = self.decoder_start_token_id
+
+ if self.pad_token_id is None:
+ raise ValueError("model.config.pad_token_id has to be defined.")
+ # replace possible -100 values in labels by `pad_token_id`
+ shifted_input_ids.masked_fill_(shifted_input_ids == -100, self.pad_token_id)
+
+ return shifted_input_ids
+
+ # Ensure the model card is saved along with the checkpoint
+ def _save_checkpoint(self, model, trial):
+ if self.args.hub_model_id is None:
+ model_name = Path(self.args.output_dir).name
+ else:
+ model_name = self.args.hub_model_id.split("/")[-1]
+ self.create_model_card(model_name=model_name)
+ super()._save_checkpoint(model, trial)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/papo/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/papo/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..62fb8105cb446c197570023e388299e1bd96bbc4
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/papo/__init__.py
@@ -0,0 +1,17 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from .papo_config import PAPOConfig
+from .papo_trainer import PAPOTrainer
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/papo/papo_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/papo/papo_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..e142a94a9cdc3128456b6127436c3befd6bc2a93
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/papo/papo_config.py
@@ -0,0 +1,73 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass
+from typing import Literal
+
+from ...trainer.grpo_config import GRPOConfig
+
+
+@dataclass
+class PAPOConfig(GRPOConfig):
+ """
+ Configuration class for PAPOTrainer.
+
+ PAPO (Perception-Aware Policy Optimization) extends GRPO/DAPO for multimodal reasoning by adding an implicit
+ perception loss and double entropy regularization.
+
+ Args:
+ perception_loss_weight (`float`, *optional*, defaults to `0.1`):
+ gamma Weight coefficient for the perception loss term. This encourages the model to be sensitive to visual
+ changes.
+
+ mask_ratio (`float`, *optional*, defaults to `0.3`):
+ Ratio of the image to mask when computing perception loss.
+
+ mask_type (`Literal["random", "patch", "grid"]`, *optional*, defaults to `"random"`):
+ Type of masking strategy to use.
+
+ der_loss_weight1 (`float`, *optional*, defaults to `0.03`):
+ eta1 Weight coefficient for the Double Entropy Regularization (DER) term. This term encourages confident
+ predictions with original images (low entropy) and uncertain predictions with masked images (high entropy).
+
+ der_loss_weight2 (`float`, *optional*, defaults to `0.03`):
+ eta2 Weight coefficient for the Double Entropy Regularization (DER) term. This term encourages confident
+ predictions with original images (low entropy) and uncertain predictions with masked images (high entropy).
+
+ loss_type (`Literal["grpo", "dapo"]`, inherited from GRPOConfig):
+ Base loss type to use. Set to "grpo" for PAPO-G or "dapo" for PAPO-D.
+ """
+
+ perception_loss_weight: float = 0.1
+ mask_ratio: float = 0.3
+ mask_type: Literal["random", "patch", "grid"] = "random"
+
+ # Added for Double Entropy Regularization
+ der_loss_weight1: float = 0.03
+ der_loss_weight2: float = 0.03
+
+ def __post_init__(self):
+ super().__post_init__()
+
+ # Validation
+ if not 0.0 <= self.mask_ratio <= 1.0:
+ raise ValueError(f"mask_ratio must be between 0 and 1, got {self.mask_ratio}")
+
+ if self.der_loss_weight1 < 0 or self.der_loss_weight2 < 0:
+ raise ValueError(
+ f"der_loss_weight1 and der_loss_weight2 must be non-negative, got {self.der_loss_weight1} and {self.der_loss_weight2}"
+ )
+
+ if self.mask_type not in ["random", "patch", "grid"]:
+ raise ValueError(f"mask_type must be one of ['random', 'patch', 'grid'], got {self.mask_type}")
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/papo/papo_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/papo/papo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..677fe926fd9f47288d217cc20e970b21f3c74b3a
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/papo/papo_trainer.py
@@ -0,0 +1,354 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import random
+import textwrap
+
+import torch
+from datasets import Dataset, IterableDataset
+from transformers import PreTrainedModel, PreTrainedTokenizerBase, ProcessorMixin
+
+from ...trainer.grpo_trainer import GRPOTrainer, RewardFunc
+from ...trainer.utils import nanmax, nanmin
+from .papo_config import PAPOConfig
+
+
+class PAPOTrainer(GRPOTrainer):
+ """
+ Trainer for Perception-Aware Policy Optimization (PAPO).
+
+ PAPO extends GRPO/DAPO for multimodal reasoning by adding an implicit perception loss that encourages the model to
+ better utilize visual information. The key innovation is computing KL divergence between model outputs on original
+ vs. corrupted (masked) images.
+
+ Two variants are supported:
+ - PAPO-G: PAPO + GRPO (use loss_type="grpo")
+ - PAPO-D: PAPO + DAPO (use loss_type="dapo")
+
+ Example:
+
+ ```python
+ from datasets import load_dataset
+ from trl.experimental.papo import PAPOTrainer, PAPOConfig
+
+ dataset = load_dataset("your-vlm-dataset", split="train")
+
+
+ def reward_func(completions, **kwargs):
+ # Your reward function for multimodal reasoning
+ return [compute_reward(c) for c in completions]
+
+
+ # PAPO-G
+ config = PAPOConfig(
+ loss_type="grpo", # Use GRPO as base
+ perception_loss_weight=0.1,
+ mask_ratio=0.3,
+ )
+
+ # PAPO-G
+ config = PAPOConfig(
+ loss_type="dapo", # Use DAPO as base
+ perception_loss_weight=0.1,
+ mask_ratio=0.3,
+ )
+
+ trainer = PAPOTrainer(
+ model="Qwen/Qwen2-VL-2B-Instruct",
+ reward_funcs=reward_func,
+ args=config,
+ train_dataset=dataset,
+ )
+
+ trainer.train()
+ ```
+
+ Args:
+ model (`Union[str, PreTrainedModel]`):
+ Model to be trained (must be a vision-language model).
+ reward_funcs (`Union[RewardFunc, list[RewardFunc]]`):
+ Reward functions for computing rewards (same as GRPO).
+ args ([`PAPOConfig`], *optional*, defaults to `None`):
+ Configuration for this trainer. If `None`, a default configuration is used.
+ train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]):
+ Dataset to use for training. Must include "prompt" and "image" columns.
+ eval_dataset: Same requirements as train_dataset.
+ processing_class: Processing class (tokenizer/processor) for the model.
+ reward_processing_classes: Processing classes for reward models.
+ callbacks: Training callbacks.
+ optimizers: Optimizer and scheduler tuple.
+ peft_config: PEFT configuration if using parameter-efficient fine-tuning.
+ """
+
+ _tag_names = ["trl", "papo"]
+ _name = "PAPO"
+ _paper = {
+ "title": "Perception-Aware Policy Optimization for Multimodal Reasoning",
+ "id": "2507.06448",
+ # docstyle-ignore
+ "citation": textwrap.dedent(
+ """\
+ @misc{wang2025perceptionawarepolicyoptimizationmultimodal,
+ title = {{Perception-Aware Policy Optimization for Multimodal Reasoning}},
+ author = {Zhenhailong Wang and Xuehang Guo and Sofia Stoica and Haiyang Xu and Hongru Wang and Hyeonjeong Ha and Xiusi Chen and Yangyi Chen and Ming Yan and Fei Huang and Heng Ji},
+ year = 2025,
+ url = {https://arxiv.org/abs/2507.06448},
+ archivePrefix= {arXiv},
+ eprint = {2507.06448},
+ primaryClass = {cs.CL}
+ }"""
+ ),
+ }
+
+ def __init__(
+ self,
+ model: str | PreTrainedModel,
+ reward_funcs: RewardFunc | list[RewardFunc],
+ args: PAPOConfig | None = None,
+ train_dataset: Dataset | IterableDataset | None = None,
+ eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None,
+ processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None,
+ reward_processing_classes: PreTrainedTokenizerBase | list[PreTrainedTokenizerBase] | None = None,
+ callbacks=None,
+ optimizers=(None, None),
+ peft_config=None,
+ ):
+ # Initialize with default PAPO config if not provided
+ if args is None:
+ model_name = model if isinstance(model, str) else model.config._name_or_path
+ model_name = model_name.split("/")[-1]
+ args = PAPOConfig(f"{model_name}-PAPO")
+
+ # Store PAPO-specific parameters
+ self.perception_loss_weight = args.perception_loss_weight
+ self.mask_ratio = args.mask_ratio
+ self.mask_type = args.mask_type
+ self.der_loss_weight1 = args.der_loss_weight1
+ self.der_loss_weight2 = args.der_loss_weight2
+
+ # Initialize parent GRPO trainer
+ super().__init__(
+ model=model,
+ reward_funcs=reward_funcs,
+ args=args,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=processing_class,
+ reward_processing_classes=reward_processing_classes,
+ callbacks=callbacks,
+ optimizers=optimizers,
+ peft_config=peft_config,
+ )
+
+ def _mask_image(self, pixel_values: torch.Tensor, mask_ratio: float = None) -> torch.Tensor:
+ """
+ Apply masking to image pixel values.
+
+ Args:
+ pixel_values: Image tensor of shape (B, C, H, W) or (B, N, C, H, W) for multi-image
+ mask_ratio: Ratio of image to mask (defaults to self.mask_ratio)
+
+ Returns:
+ Masked pixel values tensor
+ """
+ if mask_ratio is None:
+ mask_ratio = self.mask_ratio
+
+ masked_pixel_values = pixel_values.clone()
+
+ if self.mask_type == "random":
+ # Random pixel masking
+ mask = torch.rand_like(pixel_values) > mask_ratio
+ masked_pixel_values = masked_pixel_values * mask
+
+ elif self.mask_type == "patch":
+ # Patch-based masking (mask contiguous regions)
+ B = pixel_values.shape[0]
+ if pixel_values.ndim == 4: # (B, C, H, W)
+ C, H, W = pixel_values.shape[1:]
+ for i in range(B):
+ # Calculate patch size to mask
+ patch_h = int(H * mask_ratio**0.5)
+ patch_w = int(W * mask_ratio**0.5)
+ # Random starting position
+ start_h = random.randint(0, max(0, H - patch_h))
+ start_w = random.randint(0, max(0, W - patch_w))
+ # Apply mask
+ masked_pixel_values[i, :, start_h : start_h + patch_h, start_w : start_w + patch_w] = 0
+
+ elif pixel_values.ndim == 5: # (B, N, C, H, W) for multi-image
+ N, C, H, W = pixel_values.shape[1:]
+ for i in range(B):
+ for n in range(N):
+ patch_h = int(H * mask_ratio**0.5)
+ patch_w = int(W * mask_ratio**0.5)
+ start_h = random.randint(0, max(0, H - patch_h))
+ start_w = random.randint(0, max(0, W - patch_w))
+ masked_pixel_values[i, n, :, start_h : start_h + patch_h, start_w : start_w + patch_w] = 0
+
+ elif self.mask_type == "grid":
+ # Grid-based masking (mask regular grid cells)
+ if pixel_values.ndim == 4:
+ C, H, W = pixel_values.shape[1:]
+ grid_size = int((1 / mask_ratio) ** 0.5)
+ cell_h, cell_w = H // grid_size, W // grid_size
+
+ for i in range(grid_size):
+ for j in range(grid_size):
+ if random.random() < mask_ratio:
+ masked_pixel_values[:, :, i * cell_h : (i + 1) * cell_h, j * cell_w : (j + 1) * cell_w] = 0
+
+ return masked_pixel_values
+
+ def _compute_loss(self, model, inputs):
+ # >>> 1. GRPO loss
+ # Compute the per-token log probabilities for the model
+ prompt_ids, prompt_mask = inputs["prompt_ids"], inputs["prompt_mask"]
+ completion_ids, completion_mask = inputs["completion_ids"], inputs["completion_mask"]
+ input_ids = torch.cat([prompt_ids, completion_ids], dim=1)
+ attention_mask = torch.cat([prompt_mask, completion_mask], dim=1)
+ logits_to_keep = completion_ids.size(1) # we only need to compute the logits for the completion tokens
+
+ # Compute the per_token_logps and the entropy at each position in the completion
+ per_token_logps, entropies, _ = self._get_per_token_logps_and_entropies(
+ model,
+ input_ids,
+ attention_mask,
+ logits_to_keep,
+ compute_entropy=True,
+ pixel_values=inputs.get("pixel_values"),
+ image_grid_thw=inputs.get("image_grid_thw"),
+ num_images=inputs.get("num_images"),
+ pixel_attention_mask=inputs.get("pixel_attention_mask"),
+ image_sizes=inputs.get("image_sizes"),
+ )
+
+ if self.top_entropy_quantile < 1.0:
+ entropy_mask = self.get_high_entropy_mask(entropies, completion_mask, 1 - self.top_entropy_quantile)
+ else:
+ entropy_mask = None
+
+ # Compute the KL divergence between the model and the reference model
+ if self.beta != 0.0:
+ ref_per_token_logps = inputs["ref_per_token_logps"]
+ per_token_kl = (
+ torch.exp(ref_per_token_logps - per_token_logps) - (ref_per_token_logps - per_token_logps) - 1
+ )
+
+ # Compute the loss
+ advantages = inputs["advantages"]
+ # When using num_iterations == 1 and steps_per_generation <= gradient_accumulation_steps
+ # old_per_token_logps == per_token_logps, so we can skip it's computation
+ # (see _generate_and_score_completions) and use per_token_logps.detach() instead.
+ old_per_token_logps = inputs.get("old_per_token_logps")
+ old_per_token_logps = per_token_logps.detach() if old_per_token_logps is None else old_per_token_logps
+
+ log_ratio = per_token_logps - old_per_token_logps
+ if self.importance_sampling_level == "token":
+ log_importance_weights = log_ratio
+ elif self.importance_sampling_level == "sequence":
+ log_importance_weights = (log_ratio * completion_mask).sum(-1) / completion_mask.sum(-1).clamp(min=1.0)
+ log_importance_weights = log_importance_weights.unsqueeze(-1)
+ else:
+ raise ValueError(
+ f"Unknown importance sampling level: {self.importance_sampling_level}. Possible values are 'token' "
+ "and 'sequence'."
+ )
+ # From here, log_importance_weights (and all subsequent tensors, coef_1, coef_2, etc.) shape depends on
+ # importance_sampling_level: "token" level: (B, T); "sequence" level: (B, 1)
+
+ coef_1 = torch.exp(log_importance_weights)
+ coef_2 = torch.clamp(coef_1, 1 - self.epsilon_low, 1 + self.epsilon_high)
+
+ # Two-sided clipping
+ if self.args.delta is not None:
+ coef_1 = torch.clamp(coef_1, max=self.args.delta)
+
+ per_token_loss1 = coef_1 * advantages.unsqueeze(1)
+ per_token_loss2 = coef_2 * advantages.unsqueeze(1)
+ per_token_loss = -torch.min(per_token_loss1, per_token_loss2)
+ if entropy_mask is not None:
+ per_token_loss = per_token_loss * entropy_mask
+ if self.beta != 0.0:
+ per_token_loss = per_token_loss + self.beta * per_token_kl
+
+ if self.loss_type == "grpo":
+ loss = ((per_token_loss * completion_mask).sum(-1) / completion_mask.sum(-1).clamp(min=1.0)).mean()
+ loss = loss / self.current_gradient_accumulation_steps
+ elif self.loss_type == "dapo":
+ normalizer = inputs["num_items_in_batch"] / self.accelerator.num_processes
+ loss = (per_token_loss * completion_mask).sum() / normalizer
+ else:
+ raise ValueError(f"Unknown loss type: {self.loss_type}")
+ # >>> 2. Implicit Perception Loss
+ inputs["pixel_values"] = self._mask_image(inputs["pixel_values"], self.mask_ratio)
+ mask_img_per_token_logps, mask_img_entropies, _ = self._get_per_token_logps_and_entropies(
+ model,
+ input_ids,
+ attention_mask,
+ logits_to_keep,
+ compute_entropy=True,
+ pixel_values=inputs.get("pixel_values"),
+ image_grid_thw=inputs.get("image_grid_thw"),
+ num_images=inputs.get("num_images"),
+ pixel_attention_mask=inputs.get("pixel_attention_mask"),
+ image_sizes=inputs.get("image_sizes"),
+ )
+ perception_kl = (
+ torch.exp(mask_img_per_token_logps - per_token_logps) - (mask_img_per_token_logps - per_token_logps) - 1
+ )
+ perception_kl = torch.clamp(perception_kl, min=0.0, max=0.2)
+ perception_loss = self.perception_loss_weight * perception_kl
+
+ # >>> 3. Double Entropy Loss
+ der_loss = self.der_loss_weight1 * entropies + self.der_loss_weight2 * mask_img_entropies
+
+ # PAPO Loss
+ loss = (loss - perception_loss + der_loss).mean()
+ # Log the metrics
+ mode = "train" if self.model.training else "eval"
+
+ completion_token_count = completion_mask.sum().clamp(min=1.0)
+
+ def masked_batch_mean(x):
+ if x.shape[1] == 1: # when importance_sampling_level == "sequence"
+ return x.mean()
+ else:
+ return (x * completion_mask).sum() / completion_token_count
+
+ if self.beta != 0.0:
+ mean_kl = masked_batch_mean(per_token_kl)
+ self._metrics[mode]["kl"].append(self.accelerator.gather(mean_kl).nanmean().item())
+
+ mean_entropy = masked_batch_mean(entropies)
+ self._metrics[mode]["entropy"].append(self.accelerator.gather(mean_entropy).nanmean().item())
+
+ # Compute the clipped probability ratios
+ is_low_clipped = (coef_1 < 1 - self.epsilon_low) & (advantages.unsqueeze(1) < 0)
+ is_high_clipped = (coef_1 > 1 + self.epsilon_high) & (advantages.unsqueeze(1) > 0)
+ is_region_clipped = is_low_clipped | is_high_clipped
+
+ low_clip = masked_batch_mean(is_low_clipped.float())
+ high_clip = masked_batch_mean(is_high_clipped.float())
+ clip_ratio = masked_batch_mean(is_region_clipped.float())
+
+ gathered_low_clip = self.accelerator.gather(low_clip)
+ self._metrics[mode]["clip_ratio/low_mean"].append(gathered_low_clip.nanmean().item())
+ self._metrics[mode]["clip_ratio/low_min"].append(nanmin(gathered_low_clip).item())
+ gathered_high_clip = self.accelerator.gather(high_clip)
+ self._metrics[mode]["clip_ratio/high_mean"].append(gathered_high_clip.nanmean().item())
+ self._metrics[mode]["clip_ratio/high_max"].append(nanmax(gathered_high_clip).item())
+ gathered_clip_ratio = self.accelerator.gather(clip_ratio)
+ self._metrics[mode]["clip_ratio/region_mean"].append(gathered_clip_ratio.nanmean().item())
+ return loss
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ppo/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ppo/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..09451e973bea4ae1432fe16276907644cd67466c
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ppo/__init__.py
@@ -0,0 +1,30 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .modeling_value_head import (
+ AutoModelForCausalLMWithValueHead,
+ AutoModelForSeq2SeqLMWithValueHead,
+ PreTrainedModelWrapper,
+)
+from .ppo_config import PPOConfig
+from .ppo_trainer import PPOTrainer
+
+
+__all__ = [
+ "AutoModelForCausalLMWithValueHead",
+ "AutoModelForSeq2SeqLMWithValueHead",
+ "PreTrainedModelWrapper",
+ "PPOConfig",
+ "PPOTrainer",
+]
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ppo/modeling_value_head.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ppo/modeling_value_head.py
new file mode 100644
index 0000000000000000000000000000000000000000..eacd2045b1910b98107929842098725b7f73aab4
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ppo/modeling_value_head.py
@@ -0,0 +1,1020 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import logging
+import os
+
+import torch
+import torch.nn as nn
+from accelerate import PartialState
+from huggingface_hub import hf_hub_download
+from huggingface_hub.utils import (
+ EntryNotFoundError,
+ HFValidationError,
+ LocalEntryNotFoundError,
+ RepositoryNotFoundError,
+)
+from safetensors.torch import load_file as safe_load_file
+from transformers import (
+ AutoModelForCausalLM,
+ AutoModelForSeq2SeqLM,
+ PreTrainedModel,
+ is_torch_npu_available,
+ is_torch_xpu_available,
+)
+from transformers.utils import is_peft_available
+
+
+if is_peft_available():
+ from peft import (
+ PeftConfig,
+ PeftModel,
+ PeftModelForCausalLM,
+ PeftModelForSeq2SeqLM,
+ PromptLearningConfig,
+ get_peft_model,
+ prepare_model_for_kbit_training,
+ )
+
+
+class PreTrainedModelWrapper(nn.Module):
+ """
+ Wrapper for a [`~transformers.PreTrainedModel`] implemented as a standard PyTorch [`torch.nn.Module`].
+
+ This class provides a compatibility layer that preserves the key attributes and methods of the original
+ [`~transformers.PreTrainedModel`], while exposing a uniform interface consistent with PyTorch modules. It enables
+ seamless integration of pretrained Transformer models into custom training, evaluation, or inference workflows.
+
+ Attributes:
+ pretrained_model ([`~transformers.PreTrainedModel`]):
+ The model to be wrapped.
+ parent_class ([`~transformers.PreTrainedModel`]):
+ The parent class of the model to be wrapped.
+ supported_args (`list`):
+ The list of arguments that are supported by the wrapper class.
+ """
+
+ transformers_parent_class = None
+ supported_args = None
+ supported_modules = ("v_head",)
+ supported_rm_modules = ("score",)
+ supported_pretrained_model_architectures = (
+ (PreTrainedModel)
+ if not is_peft_available()
+ else (PreTrainedModel, PeftModelForCausalLM, PeftModelForSeq2SeqLM)
+ )
+
+ def __init__(
+ self, pretrained_model=None, score_module=None, supports_rm_adapter=False, rm_adapter_name=None, **kwargs
+ ):
+ super().__init__()
+ self.pretrained_model = pretrained_model
+
+ self.config = pretrained_model.config
+ self.prepare_inputs_for_generation = pretrained_model.prepare_inputs_for_generation
+ self.is_loaded_in_8bit = getattr(pretrained_model, "is_loaded_in_8bit", False)
+ self.is_loaded_in_4bit = getattr(pretrained_model, "is_loaded_in_4bit", False)
+ self.is_sequential_parallel = False
+
+ if hasattr(pretrained_model, "gradient_checkpointing_disable"):
+ self.gradient_checkpointing_disable = pretrained_model.gradient_checkpointing_disable
+
+ if hasattr(pretrained_model, "gradient_checkpointing_enable"):
+ self.gradient_checkpointing_enable = pretrained_model.gradient_checkpointing_enable
+
+ if hasattr(pretrained_model, "enable_input_require_grads"):
+ self.enable_input_require_grads = pretrained_model.enable_input_require_grads
+
+ self.supports_rm_adapter = supports_rm_adapter
+ self.rm_adapter_name = rm_adapter_name
+ self.policy_adapter_name = "default"
+ if score_module is not None:
+ self.score = score_module
+
+ @classmethod
+ def from_pretrained(cls, pretrained_model_name_or_path, *model_args, **kwargs):
+ r"""
+ Instantiates a new model from a pretrained model from `transformers`. The pretrained model is loaded using the
+ `from_pretrained` method of the [`~transformers.PreTrainedModel`] class. The arguments that are specific to the
+ [`~transformers.PreTrainedModel`] class are passed along this method and filtered out from the `kwargs`
+ argument.
+
+ Args:
+ pretrained_model_name_or_path (`str` or [`~transformers.PreTrainedModel`]):
+ The path to the pretrained model or its name.
+ *model_args (`list`, *optional*):
+ Additional positional arguments passed along to the underlying model's `from_pretrained` method.
+ **kwargs (`dict`, *optional*):
+ Additional keyword arguments passed along to the underlying model's `from_pretrained` method. We also
+ pre-process the kwargs to extract the arguments that are specific to the
+ [`~transformers.PreTrainedModel`] class and the arguments that are specific to trl models. The kwargs
+ also support `prepare_model_for_kbit_training` arguments from `peft` library.
+ """
+ if kwargs is not None:
+ peft_config = kwargs.pop("peft_config", None)
+ reward_adapter = kwargs.pop("reward_adapter", None)
+ reward_adapter_name = kwargs.pop("reward_adapter_name", "reward_adapter")
+ is_trainable = kwargs.pop("is_trainable", False)
+ trl_model_args, pretrained_kwargs, peft_quantization_kwargs = cls._split_kwargs(kwargs)
+ token = pretrained_kwargs.get("token", None)
+ else:
+ peft_config = None
+ is_trainable = False
+ trl_model_args = {}
+ pretrained_kwargs = {}
+ peft_quantization_kwargs = {}
+ token = None
+
+ if reward_adapter is not None and not isinstance(reward_adapter, str):
+ raise ValueError(
+ "The `reward_adapter` argument should be a string representing the name of local path or the Hub id to the Reward Modeling adapter."
+ )
+
+ is_peft_model = False
+
+ current_device = cls._get_current_device()
+ if isinstance(pretrained_model_name_or_path, str):
+ quantization_config = pretrained_kwargs.get("quantization_config", None)
+ if quantization_config is not None:
+ is_loaded_in_8bit = getattr(quantization_config, "load_in_8bit", False)
+ is_loaded_in_4bit = getattr(quantization_config, "load_in_4bit", False)
+ else:
+ is_loaded_in_8bit = pretrained_kwargs["load_in_8bit"] if "load_in_8bit" in pretrained_kwargs else False
+ is_loaded_in_4bit = pretrained_kwargs["load_in_4bit"] if "load_in_4bit" in pretrained_kwargs else False
+ else:
+ is_loaded_in_8bit = getattr(pretrained_model_name_or_path, "is_loaded_in_8bit", False)
+ is_loaded_in_4bit = getattr(pretrained_model_name_or_path, "is_loaded_in_4bit", False)
+
+ if (is_loaded_in_8bit or is_loaded_in_4bit) and "device_map" not in pretrained_kwargs:
+ # warn users
+ logging.warning(
+ "The `device_map` argument is not provided. We will override the device_map argument."
+ " to set the entire"
+ " model on the current device. If you want to set the model on multiple devices, please provide"
+ " a custom `device_map` argument."
+ )
+ pretrained_kwargs["device_map"] = {"": current_device}
+
+ if is_peft_available() and peft_config is not None and not isinstance(peft_config, PeftConfig):
+ raise ValueError("The `peft_config` argument should be an instance of `peft.PeftConfig` class.")
+
+ # First, load the pre-trained model using the parent-class
+ # either `AutoModelForCausalLM` or `AutoModelForSeq2SeqLM`
+ if isinstance(pretrained_model_name_or_path, str):
+ if is_peft_available():
+ try:
+ # If there is a trained peft adapter in the hub, load its config.
+ remote_adapter_config = hf_hub_download(
+ pretrained_model_name_or_path,
+ "adapter_config.json",
+ token=token,
+ )
+ except (EntryNotFoundError, LocalEntryNotFoundError, HFValidationError, RepositoryNotFoundError):
+ remote_adapter_config = None
+ else:
+ remote_adapter_config = None
+
+ local_adapter_present = os.path.exists(os.path.join(pretrained_model_name_or_path, "adapter_config.json"))
+
+ if (local_adapter_present or remote_adapter_config is not None) and is_peft_available():
+ if peft_config is not None:
+ logging.warning(
+ "`peft_config` argument ignored since a peft config file was found in "
+ f"{pretrained_model_name_or_path}"
+ )
+
+ # Load the trained peft adapter config
+ if local_adapter_present:
+ trained_adapter_config = PeftConfig.from_pretrained(pretrained_model_name_or_path)
+ else:
+ remote_adapter_dir = os.path.dirname(remote_adapter_config)
+ trained_adapter_config = PeftConfig.from_pretrained(remote_adapter_dir)
+
+ # Load the pretrained base model
+ pretrained_model = cls.transformers_parent_class.from_pretrained(
+ trained_adapter_config.base_model_name_or_path, *model_args, **pretrained_kwargs
+ )
+
+ # Wrap the pretrained model with the trained peft adapter
+ pretrained_model = PeftModel.from_pretrained(
+ pretrained_model, pretrained_model_name_or_path, is_trainable=is_trainable, token=token
+ )
+ logging.info("Trained peft adapter loaded")
+ else:
+ pretrained_model = cls.transformers_parent_class.from_pretrained(
+ pretrained_model_name_or_path, *model_args, **pretrained_kwargs
+ )
+
+ if peft_config is not None:
+ # Initialize a new peft adapter with the given config
+ if is_loaded_in_8bit or is_loaded_in_4bit:
+ pretrained_model = prepare_model_for_kbit_training(
+ pretrained_model,
+ **peft_quantization_kwargs,
+ )
+ pretrained_model = get_peft_model(pretrained_model, peft_config)
+ logging.info("peft adapter initialised")
+
+ elif isinstance(pretrained_model_name_or_path, cls.supported_pretrained_model_architectures):
+ pretrained_model = pretrained_model_name_or_path
+
+ if peft_config is not None and isinstance(pretrained_model, PreTrainedModel):
+ # Initialize a new peft adapter with the given config
+ if is_loaded_in_8bit or is_loaded_in_4bit:
+ pretrained_model = prepare_model_for_kbit_training(
+ pretrained_model,
+ **peft_quantization_kwargs,
+ )
+ pretrained_model = get_peft_model(pretrained_model, peft_config)
+ logging.info("peft adapter initialised")
+ else:
+ raise ValueError(
+ "pretrained_model_name_or_path should be a string or a PreTrainedModel, "
+ f"but is {type(pretrained_model_name_or_path)}"
+ )
+
+ if is_peft_available():
+ if isinstance(pretrained_model, PeftModel):
+ is_peft_model = True
+ # for backward compatibility
+ if hasattr(pretrained_model, "active_peft_config") and isinstance(
+ pretrained_model.active_peft_config, PromptLearningConfig
+ ):
+ raise ValueError("PromptLearningConfig is not supported for PPO training.")
+
+ # Add reward modeling adapter if specified
+ if not is_peft_model and reward_adapter is not None:
+ raise ValueError("reward_adapter can only be used with a PeftModel. ")
+ elif is_peft_model and reward_adapter is not None:
+ score_module = cls.add_and_load_reward_modeling_adapter(
+ pretrained_model, reward_adapter, reward_adapter_name, token=token
+ )
+ multi_adapter_args = {
+ "score_module": score_module,
+ "supports_rm_adapter": True,
+ "rm_adapter_name": reward_adapter_name,
+ }
+ else:
+ multi_adapter_args = {"supports_rm_adapter": False}
+
+ # Then, create the full model by instantiating the wrapper class
+ model = cls(pretrained_model, **multi_adapter_args, **trl_model_args)
+
+ # if resume_training, load the state_dict again - this is ok since the
+ # state_dict is removed from the model after loading it.
+ is_resuming_training = True
+ if isinstance(pretrained_model_name_or_path, str):
+ safe_filename = os.path.join(pretrained_model_name_or_path, "model.safetensors")
+ filename = os.path.join(pretrained_model_name_or_path, "pytorch_model.bin")
+
+ sharded_index_filename = os.path.join(pretrained_model_name_or_path, "pytorch_model.bin.index.json")
+ safe_sharded_index_filename = os.path.join(pretrained_model_name_or_path, "model.safetensors.index.json")
+ is_sharded = False
+ use_safe = os.path.exists(safe_filename)
+
+ if not (os.path.exists(filename) or os.path.exists(safe_filename)):
+ # Try with `pytorch_model.bin`
+ filename, files_to_download, is_sharded, is_resuming_training = cls._get_checkpoint_from_hub(
+ pretrained_model,
+ pretrained_model_name_or_path,
+ sharded_index_filename,
+ token=token,
+ )
+ # Try with safetensors
+ if filename is None and files_to_download is None:
+ safe_filename, files_to_download, is_sharded, is_resuming_training = cls._get_checkpoint_from_hub(
+ pretrained_model,
+ pretrained_model_name_or_path,
+ safe_sharded_index_filename,
+ token=token,
+ model_name="model.safetensors",
+ model_index_name="model.safetensors.index.json",
+ )
+ use_safe = True
+ else:
+ use_safe = False
+
+ loading_func = safe_load_file if use_safe else torch.load
+ load_kwargs = {} if use_safe else {"map_location": "cpu", "weights_only": True}
+
+ if is_resuming_training:
+ if is_sharded:
+ # download each file and add it to the state_dict
+ state_dict = {}
+
+ for shard_file in files_to_download:
+ filename = hf_hub_download(
+ pretrained_model_name_or_path,
+ shard_file,
+ token=token,
+ )
+ state_dict.update(loading_func(filename, **load_kwargs))
+ else:
+ state_dict = loading_func(filename if not use_safe else safe_filename, **load_kwargs)
+
+ else:
+ state_dict = pretrained_model_name_or_path.state_dict()
+
+ model.is_peft_model = is_peft_model
+ model.current_device = current_device
+
+ if is_resuming_training:
+ model.post_init(state_dict=state_dict)
+
+ return model
+
+ @classmethod
+ def _get_checkpoint_from_hub(
+ cls,
+ pretrained_model,
+ pretrained_model_name_or_path,
+ index_filename,
+ token=None,
+ model_name="pytorch_model.bin",
+ model_index_name="pytorch_model.bin.index.json",
+ ):
+ files_to_download = None
+ filename = None
+ is_resuming_training = True
+ is_sharded = False
+
+ try:
+ filename = hf_hub_download(
+ pretrained_model_name_or_path,
+ model_name,
+ token=token,
+ )
+ # sharded
+ except (EntryNotFoundError, LocalEntryNotFoundError, HFValidationError, RepositoryNotFoundError):
+ if os.path.exists(index_filename):
+ index_file_name = index_filename
+ else:
+ try:
+ index_file_name = hf_hub_download(
+ pretrained_model_name_or_path,
+ model_index_name,
+ token=token,
+ )
+ except (EntryNotFoundError, LocalEntryNotFoundError, HFValidationError, RepositoryNotFoundError):
+ # not continue training, do not have v_head weight
+ is_resuming_training = False
+ logging.warning(
+ f"A {type(pretrained_model)} model is loaded from '{pretrained_model_name_or_path}', "
+ f"and no v_head weight is found. This IS expected if you are not resuming PPO training."
+ )
+ # load json
+ if is_resuming_training:
+ with open(index_file_name) as f:
+ index = json.load(f)
+ # check filename with `v_head` or any known extra module:
+ files_to_download = set()
+ for k, v in index["weight_map"].items():
+ if any(module in k for module in cls.supported_modules):
+ files_to_download.add(v)
+ is_sharded = True
+
+ return filename, files_to_download, is_sharded, is_resuming_training
+
+ @classmethod
+ def _get_current_device(cls):
+ r"""
+ Get the current device. For GPU & XPU, we return the local process index using the `accelerate.PartialState`
+ object to handle corner cases when running scripts in distributed environments.
+
+ Returns:
+ current_device (`int | str`):
+ The current device.
+ """
+ state = PartialState()
+ if torch.cuda.is_available() or is_torch_xpu_available():
+ return state.local_process_index
+ elif is_torch_npu_available():
+ return f"npu:{state.local_process_index}"
+ else:
+ return "cpu"
+
+ @classmethod
+ def _split_kwargs(cls, kwargs):
+ """
+ Separate the kwargs from the arguments that we support inside `supported_args` and the ones that we don't.
+ """
+ check_peft_kwargs = False
+
+ if is_peft_available():
+ from peft import prepare_model_for_kbit_training
+
+ check_peft_kwargs = True
+
+ supported_kwargs = {}
+ unsupported_kwargs = {}
+ peft_kwargs = {}
+
+ for key, value in kwargs.items():
+ if key in cls.supported_args:
+ supported_kwargs[key] = value
+ else:
+ unsupported_kwargs[key] = value
+
+ if check_peft_kwargs:
+ if key in prepare_model_for_kbit_training.__code__.co_varnames:
+ peft_kwargs[key] = value
+ if key in unsupported_kwargs:
+ unsupported_kwargs.pop(key)
+
+ return supported_kwargs, unsupported_kwargs, peft_kwargs
+
+ @classmethod
+ def add_and_load_reward_modeling_adapter(
+ cls, pretrained_model, adapter_model_id, adapter_name="reward_model_adapter", token=None
+ ):
+ r"""
+ Add and load a reward modeling adapter. This method can only be used if the model is a `PeftModel` and if you
+ have initialized the model with the `reward_modeling_adapter_id` argument, pointing to the id of the reward
+ modeling adapter. The latest needs also to contain the score head in order to produce the reward.
+ """
+ pretrained_model.load_adapter(adapter_model_id, adapter_name, is_trainable=False)
+ pretrained_model.train()
+
+ filename = os.path.join(adapter_model_id, "adapter_model.bin")
+ safe_loading = False
+ if not os.path.exists(filename):
+ try:
+ local_filename = hf_hub_download(
+ adapter_model_id,
+ "adapter_model.bin",
+ token=token,
+ )
+ except Exception:
+ filename = os.path.join(adapter_model_id, "adapter_model.safetensors")
+ safe_loading = True
+ if not os.path.exists(filename):
+ try:
+ local_filename = hf_hub_download(
+ adapter_model_id,
+ "adapter_model.safetensors",
+ token=token,
+ )
+ except Exception as exc:
+ raise ValueError(
+ "Could not find adapter model in the Hub, make sure you have the correct adapter model id."
+ ) from exc
+ else:
+ local_filename = filename
+ else:
+ local_filename = filename
+
+ loading_func = safe_load_file if safe_loading else torch.load
+ load_kwargs = {} if safe_loading else {"map_location": "cpu", "weights_only": True}
+
+ adapter_state_dict = loading_func(local_filename, **load_kwargs)
+
+ for score_name_candidate in cls.supported_rm_modules:
+ if any(score_name_candidate in name for name in adapter_state_dict.keys()):
+ score_name = score_name_candidate
+ # we have found the correct head name and can break
+ break
+
+ score_dict = {}
+
+ for name, param in adapter_state_dict.items():
+ if score_name in name:
+ key_name = ".".join(name.split(".")[-1:])
+ score_dict[key_name] = param.to(cls._get_current_device())
+
+ num_labels, hidden_dim = score_dict["weight"].shape
+ has_bias = any("bias" in name for name in adapter_state_dict.keys())
+
+ score = nn.Linear(hidden_dim, num_labels, bias=has_bias).to(
+ device=cls._get_current_device(),
+ dtype=pretrained_model.dtype,
+ )
+ score.load_state_dict(score_dict)
+ for param in score.parameters():
+ param.requires_grad = False
+
+ return score
+
+ def push_to_hub(self, *args, **kwargs):
+ r"""
+ Push the pretrained model to the hub. This method is a wrapper around
+ [`~transformers.PreTrainedModel.push_to_hub`]. Please refer to the documentation of
+ [`~transformers.PreTrainedModel.push_to_hub`] for more information.
+
+ Args:
+ *args (`list`, *optional*):
+ Positional arguments passed along to the underlying model's `push_to_hub` method.
+ **kwargs (`dict`, *optional*):
+ Keyword arguments passed along to the underlying model's `push_to_hub` method.
+ """
+ raise NotImplementedError
+
+ def save_pretrained(self, *args, **kwargs):
+ r"""
+ Save the pretrained model to a directory. This method is a wrapper around
+ [`~transformers.PreTrainedModel.save_pretrained`]. Please refer to the documentation of
+ [`~transformers.PreTrainedModel.save_pretrained`] for more information.
+
+ Args:
+ *args (`list`, *optional*):
+ Positional arguments passed along to the underlying model's `save_pretrained` method.
+ **kwargs (`dict`, *optional*):
+ Keyword arguments passed along to the underlying model's `save_pretrained` method.
+ """
+ state_dict = kwargs.get("state_dict")
+ if state_dict is None:
+ state_dict = self.state_dict()
+ kwargs["state_dict"] = state_dict
+
+ # if it is a peft model only save the `v_head` state_dict and
+ # pop the `state_dict` from the kwargs to avoid silent bugs with `peft`
+ if self.is_peft_model:
+ save_path = args[0]
+ save_path = os.path.join(save_path, "pytorch_model.bin")
+ torch.save(state_dict, save_path)
+ _ = kwargs.pop("state_dict", None)
+
+ return self.pretrained_model.save_pretrained(*args, **kwargs)
+
+ def state_dict(self, *args, **kwargs):
+ r"""
+ Return the state_dict of the pretrained model.
+ """
+ raise NotImplementedError
+
+ def post_init(self, *args, **kwargs):
+ r"""
+ Post initialization method. This method is called after the model is instantiated and loaded from a checkpoint.
+ It can be used to perform additional operations such as loading the state_dict.
+ """
+ raise NotImplementedError
+
+ def compute_reward_score(self, input_ids, attention_mask=None, **kwargs):
+ r"""
+ Computes the reward score for a given input. The method has first to enable the adapter and then compute the
+ reward score. After that the model disables the reward modeling adapter and enables the default ppo adapter
+ again.
+ """
+ if not self.supports_rm_adapter:
+ raise ValueError("This model does not support reward modeling adapter.")
+
+ # enable rm adapter
+ self.pretrained_model.set_adapter(self.rm_adapter_name)
+ self.pretrained_model.eval()
+
+ with torch.no_grad():
+ base_model_output = self.pretrained_model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ output_hidden_states=True,
+ return_dict=True,
+ **kwargs,
+ )
+
+ last_hidden_states = base_model_output.hidden_states[-1]
+ scores = self.score(last_hidden_states)
+
+ self.pretrained_model.set_adapter(self.policy_adapter_name)
+ self.pretrained_model.eval()
+
+ return scores
+
+
+class ValueHead(nn.Module):
+ r"""
+ The ValueHead class implements a head for GPT2 that returns a scalar for each output token.
+ """
+
+ def __init__(self, config, **kwargs):
+ super().__init__()
+ if not hasattr(config, "summary_dropout_prob"):
+ summary_dropout_prob = kwargs.pop("summary_dropout_prob", 0.1)
+ else:
+ summary_dropout_prob = config.summary_dropout_prob
+
+ self.dropout = nn.Dropout(summary_dropout_prob) if summary_dropout_prob else nn.Identity()
+
+ # Determine hidden_size in priority order:
+ # 1. word_embed_proj_dim (OPT-350m): output projection dim, != internal hidden_size
+ # 2. hidden_size: standard attribute for most decoder-only and seq2seq models
+ # 3. text_config.hidden_size: multimodal configs (Gemma3, LLaVA,...) with no top-level hidden_size
+ # 4. decoder.hidden_size: EncoderDecoder compositions (e.g. BERT encoder + BERT decoder)
+ if hasattr(config, "word_embed_proj_dim"):
+ hidden_size = config.word_embed_proj_dim
+ elif hasattr(config, "hidden_size"):
+ hidden_size = config.hidden_size
+ elif hasattr(config, "text_config") and hasattr(config.text_config, "hidden_size"):
+ hidden_size = config.text_config.hidden_size
+ elif (
+ getattr(config, "is_encoder_decoder", False)
+ and hasattr(config, "decoder")
+ and hasattr(config.decoder, "hidden_size")
+ ):
+ hidden_size = config.decoder.hidden_size
+ else:
+ raise ValueError(
+ "Cannot determine `hidden_size` from model config. "
+ "Please open an issue or pass a model whose config exposes one of: "
+ "`hidden_size`, `word_embed_proj_dim`, `text_config.hidden_size`, or `decoder.hidden_size`."
+ )
+ self.summary = nn.Linear(hidden_size, 1)
+
+ self.flatten = nn.Flatten()
+
+ def forward(self, hidden_states):
+ output = self.dropout(hidden_states)
+
+ # For now force upcast in fp32 if needed. Let's keep the
+ # output in fp32 for numerical stability.
+ if output.dtype != self.summary.weight.dtype:
+ output = output.to(self.summary.weight.dtype)
+
+ output = self.summary(output)
+ return output
+
+
+class AutoModelForCausalLMWithValueHead(PreTrainedModelWrapper):
+ """
+ An autoregressive model with a value head in addition to the language model head. This class inherits from
+ [`experimental.ppo.PreTrainedModelWrapper`] and wraps a [`~transformers.PreTrainedModel`] class. The wrapper class
+ supports classic functions such as `from_pretrained`, `push_to_hub` and `generate`. To call a method of the wrapped
+ model, simply manipulate the `pretrained_model` attribute of this class.
+
+ Class attributes:
+ - **transformers_parent_class** ([`~transformers.PreTrainedModel`]) -- The parent class of the wrapped model.
+ This
+ should be set to `transformers.AutoModelForCausalLM` for this class.
+ - **supported_args** (`tuple`) -- A tuple of strings that are used to identify the arguments that are supported
+ by the [`ValueHead`] class. Currently, the supported args are:
+ - **summary_dropout_prob** (`float`, `optional`, defaults to `None`) -- The dropout probability for the
+ [`ValueHead`] class.
+ - **v_head_initializer_range** (`float`, `optional`, defaults to `0.2`) -- The initializer range for the
+ [`ValueHead`] if a specific initialization strategy is selected.
+ - **v_head_init_strategy** (`str`, `optional`, defaults to `None`) -- The initialization strategy for the
+ [`ValueHead`]. Currently, the supported strategies are:
+ - **`None`** -- Initializes the weights of the [`ValueHead`] with a random distribution. This is the
+ default strategy.
+ - **"normal"** -- Initializes the weights of the [`ValueHead`] with a normal distribution.
+ """
+
+ transformers_parent_class = AutoModelForCausalLM
+ supported_args = (
+ "summary_dropout_prob",
+ "v_head_initializer_range",
+ "v_head_init_strategy",
+ )
+
+ def __init__(self, pretrained_model, **kwargs):
+ """
+ Initializes the model.
+
+ Args:
+ pretrained_model ([`~transformers.PreTrainedModel`]):
+ The model to wrap. It should be a causal language model such as GPT2. or any model mapped inside the
+ `AutoModelForCausalLM` class.
+ kwargs (`dict`, `optional`):
+ Additional keyword arguments, that are passed to the [`ValueHead`] class.
+ """
+ super().__init__(pretrained_model, **kwargs)
+ v_head_kwargs, _, _ = self._split_kwargs(kwargs)
+ self.v_head = ValueHead(self.pretrained_model.config, **v_head_kwargs)
+ self._init_weights(**v_head_kwargs)
+
+ def _init_weights(self, **kwargs):
+ r"""
+ Initializes the weights of the value head. The default initialization strategy is random. Users can pass a
+ different initialization strategy by passing the `v_head_init_strategy` argument when calling
+ `.from_pretrained`. Supported strategies are:
+ - `normal`: initializes the weights with a normal distribution.
+
+ Args:
+ **kwargs (`dict`, `optional`):
+ Additional keyword arguments, that are passed to the [`ValueHead`] class. These arguments can contain
+ the `v_head_init_strategy` argument as well as the `v_head_initializer_range` argument.
+ """
+ initializer_range = kwargs.pop("v_head_initializer_range", 0.2)
+ # random init by default
+ init_strategy = kwargs.pop("v_head_init_strategy", None)
+ if init_strategy is None:
+ # do nothing
+ pass
+ elif init_strategy == "normal":
+ self.v_head.summary.weight.data.normal_(mean=0.0, std=initializer_range)
+ self.v_head.summary.bias.data.zero_()
+
+ def forward(
+ self,
+ input_ids=None,
+ past_key_values=None,
+ attention_mask=None,
+ return_past_key_values=False,
+ **kwargs,
+ ):
+ r"""
+ Applies a forward pass to the wrapped model and returns the logits of the value head.
+
+ Args:
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary.
+ past_key_values (`tuple(tuple(torch.FloatTensor))`, `optional`):
+ Contains pre-computed hidden-states (key and values in the attention blocks) as computed by the model
+ (see `past_key_values` input) to speed up sequential decoding.
+ attention_mask (`torch.FloatTensor` of shape `(batch_size, sequence_length)`, `optional`):
+ Mask to avoid performing attention on padding token indices. Mask values selected in ``[0, 1]``:
+ - 1 for tokens that are **not masked**,
+ - 0 for tokens that are **masked**.
+ return_past_key_values (bool): A flag indicating if the computed hidden-states should be returned.
+ kwargs (`dict`, `optional`):
+ Additional keyword arguments, that are passed to the wrapped model.
+ """
+ kwargs["output_hidden_states"] = True # this had already been set in the LORA / PEFT examples
+ kwargs["past_key_values"] = past_key_values
+
+ if self.is_peft_model and self.pretrained_model.active_peft_config.peft_type == "PREFIX_TUNING":
+ kwargs.pop("past_key_values")
+
+ base_model_output = self.pretrained_model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ **kwargs,
+ )
+
+ last_hidden_state = base_model_output.hidden_states[-1]
+ lm_logits = base_model_output.logits
+ loss = base_model_output.loss
+
+ if last_hidden_state.device != self.v_head.summary.weight.device:
+ last_hidden_state = last_hidden_state.to(self.v_head.summary.weight.device)
+
+ value = self.v_head(last_hidden_state).squeeze(-1)
+
+ # force upcast in fp32 if logits are in half-precision
+ if lm_logits.dtype != torch.float32:
+ lm_logits = lm_logits.float()
+
+ if return_past_key_values:
+ return (lm_logits, loss, value, base_model_output.past_key_values)
+ else:
+ return (lm_logits, loss, value)
+
+ def generate(self, *args, **kwargs):
+ r"""
+ A simple wrapper around the `generate` method of the wrapped model. Please refer to the
+ [`generate`](https://huggingface.co/docs/transformers/internal/generation_utils) method of the wrapped model
+ for more information about the supported arguments.
+
+ Args:
+ *args (`list`, *optional*):
+ Positional arguments passed to the `generate` method of the wrapped model.
+ **kwargs (`dict`, *optional*):
+ Keyword arguments passed to the `generate` method of the wrapped model.
+ """
+ return self.pretrained_model.generate(*args, **kwargs)
+
+ def state_dict(self, *args, **kwargs):
+ r"""
+ Returns the state dictionary of the model. We add the state dictionary of the value head to the state
+ dictionary of the wrapped model by prepending the key with `v_head.`.
+ """
+ if not self.is_peft_model:
+ pretrained_model_state_dict = self.pretrained_model.state_dict(*args, **kwargs)
+ else:
+ # if it is a peft model, only save the v_head
+ pretrained_model_state_dict = {}
+
+ v_head_state_dict = self.v_head.state_dict(*args, **kwargs)
+ for k, v in v_head_state_dict.items():
+ pretrained_model_state_dict[f"v_head.{k}"] = v
+ return pretrained_model_state_dict
+
+ def push_to_hub(self, *args, **kwargs):
+ self.pretrained_model.v_head = self.v_head
+
+ return self.pretrained_model.push_to_hub(*args, **kwargs)
+
+ def post_init(self, state_dict):
+ r"""
+ We add the state dictionary of the value head to the state dictionary of the wrapped model by prepending the
+ key with `v_head.`. This function removes the `v_head.` prefix from the keys of the value head state
+ dictionary.
+ """
+ for k in list(state_dict.keys()):
+ if "v_head." in k:
+ state_dict[k.replace("v_head.", "")] = state_dict.pop(k)
+ self.v_head.load_state_dict(state_dict, strict=False)
+ del state_dict
+
+ if hasattr(self.pretrained_model, "hf_device_map"):
+ if (
+ "cpu" in self.pretrained_model.hf_device_map.values()
+ or "disk" in self.pretrained_model.hf_device_map.values()
+ ):
+ raise ValueError(
+ "The model is offloaded on CPU or disk - CPU & disk offloading is not supported for ValueHead models."
+ )
+
+ first_device = list(set(self.pretrained_model.hf_device_map.values()))[0]
+ if isinstance(first_device, int):
+ if is_torch_npu_available():
+ first_device = f"npu:{first_device}"
+ elif is_torch_xpu_available():
+ first_device = f"xpu:{first_device}"
+ else:
+ first_device = f"cuda:{first_device}"
+ self.v_head = self.v_head.to(first_device)
+
+ def set_device_hook(module, input, outputs):
+ new_output = ()
+ for output in outputs:
+ if isinstance(output, torch.Tensor):
+ new_output += (output.to(first_device),)
+ else:
+ new_output += (output,)
+ return new_output
+
+ self.register_forward_hook(set_device_hook)
+
+ self.is_sequential_parallel = True
+
+
+class AutoModelForSeq2SeqLMWithValueHead(PreTrainedModelWrapper):
+ """
+ A seq2seq model with a value head in addition to the language model head. This class inherits from
+ [`experimental.ppo.PreTrainedModelWrapper`] and wraps a [`~transformers.PreTrainedModel`] class. The wrapper class
+ supports classic functions such as `from_pretrained` and `push_to_hub` and also provides some additional
+ functionalities such as `generate`.
+
+ Args:
+ pretrained_model ([`~transformers.PreTrainedModel`]):
+ The model to wrap. It should be a causal language model such as GPT2. or any model mapped inside the
+ [`~transformers.AutoModelForSeq2SeqLM`] class.
+ kwargs:
+ Additional keyword arguments passed along to the [`ValueHead`] class.
+ """
+
+ transformers_parent_class = AutoModelForSeq2SeqLM
+ lm_head_namings = ["lm_head", "embed_out", "output_projection"]
+ supported_args = (
+ "summary_dropout_prob",
+ "v_head_initializer_range",
+ "v_head_init_strategy",
+ )
+
+ def __init__(self, pretrained_model, **kwargs):
+ super().__init__(pretrained_model, **kwargs)
+ v_head_kwargs, _, _ = self._split_kwargs(kwargs)
+ self.is_encoder_decoder = True
+
+ if not self._has_lm_head():
+ raise ValueError("The model does not have a language model head, please use a model that has one.")
+
+ self.v_head = ValueHead(self.pretrained_model.config, **v_head_kwargs)
+
+ self._init_weights(**v_head_kwargs)
+
+ def _has_lm_head(self):
+ # check module names of all modules inside `pretrained_model` to find the language model head
+ for name, _module in self.pretrained_model.named_modules():
+ if any(attribute in name for attribute in self.lm_head_namings):
+ return True
+ return False
+
+ def post_init(self, state_dict):
+ r"""
+ We add the state dictionary of the value head to the state dictionary of the wrapped model by prepending the
+ key with `v_head.`. This function removes the `v_head.` prefix from the keys of the value head state
+ dictionary.
+ """
+ for k in list(state_dict.keys()):
+ if "v_head." in k:
+ state_dict[k.replace("v_head.", "")] = state_dict.pop(k)
+ self.v_head.load_state_dict(state_dict, strict=False)
+ del state_dict
+
+ if hasattr(self.pretrained_model, "hf_device_map"):
+ if (
+ "cpu" in self.pretrained_model.hf_device_map.values()
+ or "disk" in self.pretrained_model.hf_device_map.values()
+ ):
+ raise ValueError(
+ "The model is offloaded on CPU or disk - CPU & disk offloading is not supported for ValueHead models."
+ )
+
+ # get the lm_head device
+ for name, module in self.pretrained_model.named_modules():
+ if any(attribute in name for attribute in self.lm_head_namings):
+ lm_head_device = module.weight.device
+ break
+
+ # put v_head on the same device as the lm_head to avoid issues
+ self.v_head = self.v_head.to(lm_head_device)
+
+ def set_device_hook(module, input, outputs):
+ r"""
+ A hook that sets the device of the output of the model to the device of the first parameter of the
+ model.
+
+ Args:
+ module (`nn.Module`):
+ The module to which the hook is attached.
+ input (`tuple`):
+ The input to the module.
+ outputs (`tuple`):
+ The output of the module.
+ """
+ new_output = ()
+ for output in outputs:
+ if isinstance(output, torch.Tensor):
+ new_output += (output.to(lm_head_device),)
+ else:
+ new_output += (output,)
+ return new_output
+
+ self.register_forward_hook(set_device_hook)
+ self.is_sequential_parallel = True
+
+ def state_dict(self, *args, **kwargs):
+ r"""
+ Returns the state dictionary of the model. We add the state dictionary of the value head to the state
+ dictionary of the wrapped model by prepending the key with `v_head.`.
+ """
+ if not self.is_peft_model:
+ pretrained_model_state_dict = self.pretrained_model.state_dict(*args, **kwargs)
+ else:
+ # if it is a peft model, only save the v_head
+ pretrained_model_state_dict = {}
+
+ v_head_state_dict = self.v_head.state_dict(*args, **kwargs)
+ for k, v in v_head_state_dict.items():
+ pretrained_model_state_dict[f"v_head.{k}"] = v
+ return pretrained_model_state_dict
+
+ def push_to_hub(self, *args, **kwargs):
+ self.pretrained_model.v_head = self.v_head
+
+ return self.pretrained_model.push_to_hub(*args, **kwargs)
+
+ def _init_weights(self, **kwargs):
+ r"""
+ We initialize the weights of the value head.
+ """
+ initializer_range = kwargs.pop("v_head_initializer_range", 0.2)
+ # random init by default
+ init_strategy = kwargs.pop("v_head_init_strategy", None)
+ if init_strategy is None:
+ # do nothing
+ pass
+ elif init_strategy == "normal":
+ self.v_head.summary.weight.data.normal_(mean=0.0, std=initializer_range)
+ self.v_head.summary.bias.data.zero_()
+
+ def forward(
+ self,
+ input_ids=None,
+ past_key_values=None,
+ attention_mask=None,
+ return_past_key_values=False,
+ **kwargs,
+ ):
+ kwargs["past_key_values"] = past_key_values
+ if self.is_peft_model and self.pretrained_model.active_peft_config.peft_type == "PREFIX_TUNING":
+ kwargs.pop("past_key_values")
+
+ base_model_output = self.pretrained_model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ output_hidden_states=True, # We force the model to output hidden states
+ **kwargs,
+ )
+
+ last_hidden_state = base_model_output.decoder_hidden_states[-1]
+ lm_logits = base_model_output.logits
+ loss = base_model_output.loss
+
+ value = self.v_head(last_hidden_state).squeeze(-1)
+
+ # force upcast in fp32 if logits are in half-precision
+ if lm_logits.dtype != torch.float32:
+ lm_logits = lm_logits.float()
+
+ if return_past_key_values:
+ return (lm_logits, loss, value, base_model_output.past_key_values)
+ else:
+ return (lm_logits, loss, value)
+
+ def generate(self, *args, **kwargs):
+ r"""
+ We call `generate` on the wrapped model.
+ """
+ return self.pretrained_model.generate(*args, **kwargs)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ppo/ppo_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ppo/ppo_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..b96ee394734982fd82cf6ba2ae87bc6ca7be206f
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ppo/ppo_config.py
@@ -0,0 +1,280 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+from ...trainer.base_config import _BaseConfig
+
+
+@dataclass
+class PPOConfig(_BaseConfig):
+ # docstyle-ignore
+ r"""
+ Configuration class for the [`experimental.ppo.PPOTrainer`].
+
+ This class includes only the parameters that are specific to PPO training. For a full list of training arguments,
+ please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may
+ differ from those in [`~transformers.TrainingArguments`].
+
+ Using [`~transformers.HfArgumentParser`] we can turn this class into
+ [argparse](https://docs.python.org/3/library/argparse#module-argparse) arguments that can be specified on the
+ command line.
+
+ Parameters:
+ dataset_num_proc (`int`, *optional*):
+ Number of processes to use for processing the dataset.
+ num_mini_batches (`int`, *optional*, defaults to `1`):
+ Number of minibatches to split a batch into.
+ total_episodes (`int`, *optional*):
+ Total number of episodes in the dataset.
+ local_rollout_forward_batch_size (`int`, *optional*, defaults to `64`):
+ Per rank no grad forward pass in the rollout phase.
+ num_sample_generations (`int`, *optional*, defaults to `10`):
+ Number of debugging samples generations (i.e., `generate_completions` calls) throughout training.
+ response_length (`int`, *optional*, defaults to `53`):
+ Length of the response.
+ stop_token (`str`, *optional*):
+ Specifies the stop token to use for text generation. This parameter is mutually exclusive with
+ `stop_token_id`.
+
+ - `None`: No stop token is applied, unless `stop_token_id` is specified.
+ - `'eos'`: Uses the tokenizer's `eos_token`.
+
+ stop_token_id (`int`, *optional*):
+ Specifies the ID of the stop token to use for text generation. If `None`, no stop token ID is applied,
+ unless `stop_token` is specified. This parameter is mutually exclusive with `stop_token`.
+ temperature (`float`, *optional*, defaults to `0.7`):
+ Sampling temperature.
+ missing_eos_penalty (`float`, *optional*):
+ Penalty applied to the score when the model fails to generate an EOS token. This is useful to encourage to
+ generate completions shorter than the maximum length (`max_new_tokens`). The penalty must be a positive
+ value.
+ sft_model_path (`str`, *optional*, defaults to `"EleutherAI/pythia-160m"`):
+ Path to the SFT model.
+ world_size (`int`, *optional*):
+ Number of processes (GPUs) to use for the training.
+ num_total_batches (`int`, *optional*):
+ Number of total batches to train.
+ micro_batch_size (`int`, *optional*):
+ Micro batch size across devices (HF's `per_device_train_batch_size` * `world_size`).
+ local_batch_size (`int`, *optional*):
+ Batch size per GPU (HF's `per_device_train_batch_size` * `gradient_accumulation_steps`).
+ batch_size (`int`, *optional*):
+ Batch size across devices (HF's `per_device_train_batch_size` * `world_size` *
+ `gradient_accumulation_steps`).
+ local_mini_batch_size (`int`, *optional*):
+ Mini batch size per GPU.
+ mini_batch_size (`int`, *optional*):
+ Mini batch size across GPUs.
+ push_to_hub (`bool`, *optional*, defaults to `False`):
+ Whether to push the model to the Hub after training.
+ reward_model_path (`str`, *optional*, defaults to `"EleutherAI/pythia-160m"`):
+ Path to the reward model.
+ model_adapter_name (`str`, *optional*):
+ Name of the train target PEFT adapter, when using LoRA with multiple adapters.
+ ref_adapter_name (`str`, *optional*):
+ Name of the reference PEFT adapter, when using LoRA with multiple adapters.
+ num_ppo_epochs (`int`, *optional*, defaults to `4`):
+ Number of epochs to train.
+ whiten_rewards (`bool`, *optional*, defaults to `False`):
+ Whether to whiten the rewards.
+ kl_coef (`float`, *optional*, defaults to `0.05`):
+ KL coefficient.
+ kl_estimator (`Literal["k1", "k3"]`, *optional*, defaults to `"k1"`):
+ Which estimator for KL-Divergence to use from [Approximating KL
+ Divergence](http://joschu.net/blog/kl-approx.html). Defaults to "k1", a straightforward, unbiased
+ estimator. Can be set to "k3", an unbiased estimator with lower variance which "appears to be a strictly
+ better estimator". Cannot be set to "k2", as it is used for logging purposes.
+ cliprange (`float`, *optional*, defaults to `0.2`):
+ Clip range.
+ vf_coef (`float`, *optional*, defaults to `0.1`):
+ Value function coefficient.
+ cliprange_value (`float`, *optional*, defaults to `0.2`):
+ Clip range for the value function.
+ gamma (`float`, *optional*, defaults to `1.0`):
+ Discount factor.
+ lam (`float`, *optional*, defaults to `0.95`):
+ Lambda value for GAE.
+ ds3_gather_for_generation (`bool`, *optional*, defaults to `True`):
+ This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for generation,
+ improving generation speed. However, disabling this option allows training models that exceed the VRAM
+ capacity of a single GPU, albeit at the cost of slower generation.
+
+ > [!NOTE]
+ > These parameters have default values different from [`~transformers.TrainingArguments`]:
+ > - `logging_steps`: Defaults to `10` instead of `500`.
+ > - `gradient_checkpointing`: Defaults to `True` instead of `False`.
+ > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`.
+ > - `learning_rate`: Defaults to `3e-6` instead of `5e-5`.
+ """
+
+ # Parameters whose default values are overridden from TrainingArguments
+ learning_rate: float = field(
+ default=3e-6,
+ metadata={"help": "The initial learning rate for AdamW."},
+ )
+
+ dataset_num_proc: int | None = field(
+ default=None,
+ metadata={"help": "Number of processes to use for processing the dataset."},
+ )
+ num_mini_batches: int = field(
+ default=1,
+ metadata={"help": "Number of minibatches to split a batch into."},
+ )
+ total_episodes: int | None = field(
+ default=None,
+ metadata={"help": "Total number of episodes in the dataset."},
+ )
+ local_rollout_forward_batch_size: int = field(
+ default=64,
+ metadata={"help": "Per rank no grad forward pass in the rollout phase."},
+ )
+ num_sample_generations: int = field(
+ default=10,
+ metadata={
+ "help": "Number of debugging samples generations (i.e., `generate_completions` calls) throughout training."
+ },
+ )
+ response_length: int = field(
+ default=53,
+ metadata={"help": "Length of the response."},
+ )
+ stop_token: Literal["eos"] | None = field(
+ default=None,
+ metadata={
+ "help": "Specifies the stop token to use for text generation. This parameter is mutually exclusive with "
+ "`stop_token_id`."
+ },
+ )
+ stop_token_id: int | None = field(
+ default=None,
+ metadata={
+ "help": "Specifies the ID of the stop token to use for text generation. If `None`, no stop token ID is "
+ "applied, unless `stop_token` is specified. This parameter is mutually exclusive with `stop_token`."
+ },
+ )
+ temperature: float = field(
+ default=0.7,
+ metadata={"help": "Sampling temperature."},
+ )
+ missing_eos_penalty: float | None = field(
+ default=None,
+ metadata={
+ "help": "Penalty applied to the score when the model fails to generate an EOS token. This is useful to "
+ "encourage to generate completions shorter than the maximum length (`max_new_tokens`). The penalty must be "
+ "a positive value."
+ },
+ )
+ sft_model_path: str = field(
+ default="EleutherAI/pythia-160m",
+ metadata={"help": "Path to the SFT model."},
+ )
+ world_size: int | None = field(
+ default=None,
+ metadata={"help": "Number of processes (GPUs) to use for the training."},
+ )
+ num_total_batches: int | None = field(
+ default=None,
+ metadata={"help": "Number of total batches to train."},
+ )
+ micro_batch_size: int | None = field(
+ default=None,
+ metadata={"help": "Micro batch size across devices (HF's `per_device_train_batch_size` * `world_size`)."},
+ )
+ local_batch_size: int | None = field(
+ default=None,
+ metadata={"help": "Batch size per GPU (HF's `per_device_train_batch_size` * `gradient_accumulation_steps`)."},
+ )
+ batch_size: int | None = field(
+ default=None,
+ metadata={
+ "help": "Batch size across devices (HF's `per_device_train_batch_size` * `world_size` * "
+ "`gradient_accumulation_steps`)."
+ },
+ )
+ local_mini_batch_size: int | None = field(
+ default=None,
+ metadata={"help": "Mini batch size per GPU."},
+ )
+ mini_batch_size: int | None = field(
+ default=None,
+ metadata={"help": "Mini batch size across GPUs."},
+ )
+ push_to_hub: bool = field(
+ default=False,
+ metadata={"help": "Whether to push the model to the Hub after training."},
+ )
+ reward_model_path: str = field(
+ default="EleutherAI/pythia-160m",
+ metadata={"help": "Path to the reward model."},
+ )
+ model_adapter_name: str | None = field(
+ default=None,
+ metadata={"help": "Name of the train target PEFT adapter, when using LoRA with multiple adapters."},
+ )
+ ref_adapter_name: str | None = field(
+ default=None,
+ metadata={"help": "Name of the reference PEFT adapter, when using LoRA with multiple adapters."},
+ )
+ num_ppo_epochs: int = field(
+ default=4,
+ metadata={"help": "Number of epochs to train."},
+ )
+ whiten_rewards: bool = field(
+ default=False,
+ metadata={"help": "Whether to whiten the rewards."},
+ )
+ kl_coef: float = field(
+ default=0.05,
+ metadata={"help": "KL coefficient."},
+ )
+ kl_estimator: Literal["k1", "k3"] = field(
+ default="k1",
+ metadata={
+ "help": "Which estimator for KL-Divergence to use from Approximating KL Divergence "
+ "(http://joschu.net/blog/kl-approx.html). Defaults to 'k1', a straightforward, unbiased estimator. Can be "
+ "set to 'k3', an unbiased estimator with lower variance which 'appears to be a strictly better "
+ "estimator'. Cannot be set to 'k2', as it is used for logging purposes."
+ },
+ )
+ cliprange: float = field(
+ default=0.2,
+ metadata={"help": "Clip range."},
+ )
+ vf_coef: float = field(
+ default=0.1,
+ metadata={"help": "Value function coefficient."},
+ )
+ cliprange_value: float = field(
+ default=0.2,
+ metadata={"help": "Clip range for the value function."},
+ )
+ gamma: float = field(
+ default=1.0,
+ metadata={"help": "Discount factor."},
+ )
+ lam: float = field(
+ default=0.95,
+ metadata={"help": "Lambda value for GAE."},
+ )
+ ds3_gather_for_generation: bool = field(
+ default=True,
+ metadata={
+ "help": "This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for "
+ "generation, improving generation speed. However, disabling this option allows training models that "
+ "exceed the VRAM capacity of a single GPU, albeit at the cost of slower generation."
+ },
+ )
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ppo/ppo_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ppo/ppo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..f982932a2990fe2ffa994d2816d3b9532e86d970
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ppo/ppo_trainer.py
@@ -0,0 +1,1038 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import gc
+import math
+import os
+import textwrap
+import time
+from collections import defaultdict
+from contextlib import contextmanager, nullcontext
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+import transformers
+from accelerate import Accelerator
+from accelerate.logging import get_logger
+from accelerate.utils import gather_object
+from datasets import Dataset
+from packaging.version import Version
+from torch.utils.data import DataLoader
+from transformers import (
+ BaseImageProcessor,
+ DataCollatorWithPadding,
+ FeatureExtractionMixin,
+ GenerationConfig,
+ PreTrainedTokenizerBase,
+ ProcessorMixin,
+ TrainerCallback,
+ TrainerControl,
+ TrainerState,
+)
+from transformers.integrations import get_reporting_integration_callbacks
+from transformers.trainer import DEFAULT_CALLBACKS, DEFAULT_PROGRESS_CALLBACK
+from transformers.trainer_callback import CallbackHandler, ExportableState, PrinterCallback
+from transformers.utils import ModelOutput, is_peft_available, is_rich_available
+
+from ...models.utils import prepare_deepspeed, unwrap_model_for_generation
+from ...trainer.base_trainer import _BaseTrainer
+from ...trainer.utils import (
+ disable_dropout_in_model,
+ log_table_to_comet_experiment,
+ pad,
+ selective_log_softmax,
+)
+from ..utils import (
+ create_reference_model,
+ empty_cache,
+ first_true_indices,
+ get_reward,
+ peft_module_casting_to_bf16,
+)
+from .ppo_config import PPOConfig
+
+
+if is_rich_available():
+ from rich.console import Console
+ from rich.table import Table
+
+
+logger = get_logger(__name__)
+
+if is_peft_available():
+ from peft import PeftConfig, PeftModel, get_peft_model
+
+
+INVALID_LOGPROB = 1.0
+
+
+def generate(
+ lm_backbone: torch.nn.Module, queries: torch.Tensor, pad_token_id: int, generation_config: GenerationConfig
+) -> tuple[torch.Tensor, torch.Tensor]:
+ """
+ Generates sequences from the language model backbone in a way that does not affect padding tokens.
+
+ Args:
+ lm_backbone (`torch.nn.Module`):
+ The language model backbone used for generation.
+ queries (`torch.Tensor`):
+ The tensor containing the input queries.
+ pad_token_id (`int`):
+ The token ID representing the pad token.
+ generation_config ([`~transformers.GenerationConfig`]):
+ The configuration for the generation process.
+
+ Returns:
+ tuple:
+ - `generated_sequences` (`torch.Tensor`):
+ The concatenated tensor of input queries and generated sequences.
+ - `logits` (`torch.Tensor`):
+ The logits output from the generation process.
+ """
+ context_length = queries.shape[1]
+ attention_mask = queries != pad_token_id
+ input_ids = torch.masked_fill(queries, ~attention_mask, 0)
+ output = lm_backbone.generate(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ # position_ids=attention_mask.cumsum(1) - attention_mask.long(), # not needed: already adjusted in generations
+ # https://github.com/huggingface/transformers/blob/ac33aeeeee2a7a89b89c93c2962e6feb90daef0a/src/transformers/models/gpt2/modeling_gpt2.py#L1227-L1250
+ generation_config=generation_config,
+ return_dict_in_generate=True,
+ output_scores=True,
+ )
+ logits = torch.stack(output.scores, 1)
+ return torch.cat((queries, output.sequences[:, context_length:]), dim=1), logits
+
+
+@torch.no_grad()
+def batch_generation(
+ model: torch.nn.Module,
+ queries: torch.Tensor,
+ local_rollout_forward_batch_size: int,
+ pad_token_id: int,
+ generation_config: GenerationConfig,
+):
+ query_responses = []
+ logitss = []
+ batch_size = queries.shape[0]
+ for i in range(0, batch_size, local_rollout_forward_batch_size):
+ query = queries[i : i + local_rollout_forward_batch_size]
+ query_response, logits = generate(
+ model,
+ query,
+ pad_token_id,
+ generation_config,
+ )
+ query_responses.append(query_response)
+ logitss.append(logits)
+
+ # padding tensors
+ padded_query_responses = pad(query_responses, padding_value=pad_token_id, padding_side="right")
+ padded_logitss = pad(logitss, padding_value=0, padding_side="right")
+
+ # reshaping
+ padded_query_responses = padded_query_responses.view(-1, padded_query_responses.shape[-1])[:batch_size]
+ padded_logitss = padded_logitss.view(-1, *padded_logitss.shape[2:])[:batch_size]
+
+ return padded_query_responses, padded_logitss
+
+
+def exact_div(a, b, custom_error_message=""):
+ q = a // b
+ if a != q * b:
+ raise ValueError(f"{custom_error_message}, inexact division: {a} / {b} = {a / b}")
+ return q
+
+
+def print_rich_table(df: pd.DataFrame) -> None:
+ if not is_rich_available():
+ raise ImportError(
+ "The function `print_rich_table` requires the `rich` library. Please install it with `pip install rich`."
+ )
+ console = Console()
+ table = Table(show_lines=True)
+ for column in df.columns:
+ table.add_column(column)
+ for _, row in df.iterrows():
+ table.add_row(*row.astype(str).tolist())
+ console.print(table)
+
+
+def truncate_response(stop_token_id: int, pad_token_id: int, responses: torch.Tensor) -> torch.Tensor:
+ """
+ Truncates the responses at the first occurrence of the stop token, filling the rest with pad tokens.
+
+ Args:
+ stop_token_id (`int`):
+ The token ID representing the stop token where truncation occurs.
+ pad_token_id (`int`):
+ The token ID representing the pad token used to fill the truncated responses.
+ responses (`torch.Tensor`):
+ The tensor containing the responses to be truncated.
+
+ Returns:
+ `torch.Tensor`:
+ The truncated responses tensor with pad tokens filled after the stop token.
+ """
+ trunc_idxs = first_true_indices(responses == stop_token_id).unsqueeze(-1)
+ new_size = [1] * (len(responses.size()) - 1) + [responses.shape[1]]
+ idxs = torch.arange(responses.shape[1], device=responses.device).view(*new_size)
+ postprocessed_responses = torch.masked_fill(responses, idxs > trunc_idxs, pad_token_id)
+ return postprocessed_responses
+
+
+def forward(
+ model: torch.nn.Module,
+ query_responses: torch.Tensor,
+ pad_token_id: int,
+) -> ModelOutput:
+ """
+ Performs a forward pass through the model with the given query responses and pad token ID.
+
+ Args:
+ model (`torch.nn.Module`):
+ The model to perform the forward pass.
+ query_responses (`torch.Tensor`):
+ The tensor containing the query responses.
+ pad_token_id (`int`):
+ The token ID representing the pad token.
+
+ Returns:
+ `ModelOutput`:
+ The output of the model, including hidden states.
+ """
+ attention_mask = query_responses != pad_token_id
+ position_ids = attention_mask.cumsum(1) - attention_mask.long()
+ input_ids = torch.masked_fill(query_responses, ~attention_mask, 0)
+ return model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ return_dict=True,
+ output_hidden_states=True,
+ )
+
+
+@dataclass
+class OnlineTrainerState(TrainerState):
+ """
+ Training state for online/on-policy trainers.
+
+ Extends [`~transformers.TrainerState`] with an `episode` counter to track the current rollout/episode.
+
+ Args:
+ episode (`int`, defaults to 0): Zero-based episode index.
+ """
+
+ episode: int = 0
+
+
+def masked_mean(values: torch.Tensor, mask: torch.Tensor, axis: bool | None = None) -> torch.Tensor:
+ """Compute mean of tensor with a masked values."""
+ if axis is not None:
+ return (values * mask).sum(axis=axis) / mask.sum(axis=axis)
+ else:
+ return (values * mask).sum() / mask.sum()
+
+
+def masked_var(values: torch.Tensor, mask: torch.Tensor, unbiased: bool = True) -> torch.Tensor:
+ """Compute variance of tensor with masked values."""
+ mean = masked_mean(values, mask)
+ centered_values = values - mean
+ variance = masked_mean(centered_values**2, mask)
+ if unbiased:
+ mask_sum = mask.sum()
+ if mask_sum == 0:
+ raise ValueError(
+ "The sum of the mask is zero, which can happen when `mini_batch_size=1`;"
+ "try increase the `mini_batch_size` or `gradient_accumulation_steps`"
+ )
+ # note that if mask_sum == 1, then there is a division by zero issue
+ # to avoid it you just need to use a larger minibatch_size
+ bessel_correction = mask_sum / (mask_sum - 1)
+ variance = variance * bessel_correction
+ return variance
+
+
+def masked_whiten(values: torch.Tensor, mask: torch.Tensor, shift_mean: bool = True) -> torch.Tensor:
+ """Whiten values with masked values."""
+ mean, var = masked_mean(values, mask), masked_var(values, mask)
+ whitened = (values - mean) * torch.rsqrt(var + 1e-8)
+ if not shift_mean:
+ whitened += mean
+ return whitened
+
+
+# taken from https://github.com/OpenLMLab/MOSS-RLHF/blob/40b91eb2f2b71b16919addede0341d2bef70825d/ppo/ppo_trainer.py#L29
+# we did this we can do a single `model = accelerator.prepare(model)`
+class PolicyAndValueWrapper(nn.Module):
+ def __init__(self, policy, value_model) -> None:
+ super().__init__()
+ self.policy = policy
+ self.value_model = value_model
+ self.critic_backbone = getattr(value_model, value_model.base_model_prefix)
+ self.is_gradient_checkpointing = policy.is_gradient_checkpointing
+
+ def gradient_checkpointing_enable(self, **kwargs):
+ self.policy.gradient_checkpointing_enable(**kwargs)
+ self.is_gradient_checkpointing = True
+
+ def gradient_checkpointing_disable(self):
+ self.policy.gradient_checkpointing_disable()
+ self.is_gradient_checkpointing = False
+
+ def forward(self, **kwargs):
+ output = self.critic_backbone(**kwargs)
+ logits = self.value_model.score(output.hidden_states[-1])
+ return self.policy(**kwargs), logits
+
+
+class PPOTrainer(_BaseTrainer):
+ """Trainer for Proximal Policy Optimization (PPO).
+
+ For details on PPO, see the paper: [Proximal Policy Optimization
+ Algorithms](https://huggingface.co/papers/1707.06347).
+
+ Args:
+ args ([`experimental.ppo.PPOConfig`]):
+ Training arguments.
+ processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.BaseImageProcessor`], [`~transformers.FeatureExtractionMixin`] or [`~transformers.ProcessorMixin`]):
+ Class to process the data.
+ model (`torch.nn.Module`):
+ Model to be trained. This is the policy model.
+ ref_model (`torch.nn.Module`, *optional*):
+ Reference model used to compute the KL divergence. If `None`, a copy of the policy model is created.
+ reward_model (`torch.nn.Module`):
+ Reward model used to compute the rewards.
+ train_dataset ([`~datasets.Dataset`]):
+ Dataset for training.
+ value_model (`torch.nn.Module`):
+ Value model used to predict the value of a state.
+ data_collator ([`~transformers.DataCollatorWithPadding`], *optional*):
+ Data collator to batch and pad samples from the dataset. If `None`, a default data collator is created
+ using the `processing_class`.
+ eval_dataset ([`~datasets.Dataset`] or `dict` of [`~datasets.Dataset`], *optional*):
+ Dataset for evaluation.
+ optimizers (`tuple` of `torch.optim.Optimizer` and `torch.optim.lr_scheduler.LambdaLR`, *optional*, defaults to `(None, None)`):
+ Tuple containing the optimizer and the learning rate scheduler to use for training. If `None`, the
+ optimizer and the learning rate scheduler are created using the
+ [`~transformers.Trainer.create_optimizer_and_scheduler`] method.
+ callbacks (`list` of [`~transformers.TrainerCallback`], *optional*):
+ Callbacks to use during training.
+ peft_config ([`~peft.PeftConfig`], *optional*):
+ PEFT configuration to use PEFT for training. If `None`, PEFT is not used. If provided, the policy `model`
+ will be wrapped with the specified PEFT adapter.
+ """
+
+ _tag_names = ["trl", "ppo"]
+ _name = "PPO"
+ _paper = {
+ "title": "Fine-Tuning Language Models from Human Preferences",
+ "id": "1909.08593",
+ # docstyle-ignore
+ "citation": textwrap.dedent("""\
+ @article{mziegler2019fine-tuning,
+ title = {{Fine-Tuning Language Models from Human Preferences}},
+ author = {Daniel M. Ziegler and Nisan Stiennon and Jeffrey Wu and Tom B. Brown and Alec Radford and Dario Amodei and Paul F. Christiano and Geoffrey Irving},
+ year = 2019,
+ eprint = {arXiv:1909.08593}
+ }"""),
+ }
+
+ def __init__(
+ self,
+ args: PPOConfig,
+ processing_class: PreTrainedTokenizerBase | BaseImageProcessor | FeatureExtractionMixin | ProcessorMixin,
+ model: nn.Module,
+ ref_model: nn.Module | None,
+ reward_model: nn.Module,
+ train_dataset: Dataset,
+ value_model: nn.Module,
+ data_collator: DataCollatorWithPadding | None = None,
+ eval_dataset: Dataset | dict[str, Dataset] | None = None,
+ # less commonly used
+ optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None),
+ callbacks: list[TrainerCallback] | None = None,
+ peft_config: "PeftConfig | None" = None,
+ ) -> None:
+ if train_dataset is None:
+ raise ValueError("`train_dataset` is required")
+
+ if ref_model is model:
+ raise ValueError(
+ "`model` and `ref_model` cannot be the same object. If you want `ref_model` to be the "
+ "same as `model`, you must make a copy of it, or `None` if you use peft."
+ )
+
+ self.args = args
+ self.processing_class = processing_class
+ self.policy_model = model
+
+ # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was
+ # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream
+ # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we
+ # default to the recommended non-reentrant behavior here, while preserving any user-provided value.
+ if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"):
+ args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {}
+ args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False)
+
+ # Define the collator if not provided
+ if data_collator is None:
+ data_collator = DataCollatorWithPadding(self.processing_class)
+
+ # Handle stop token settings: update policy model's generation_config to use provided stop token
+ if args.stop_token and args.stop_token_id:
+ raise ValueError("You cannot set both `stop_token` and `stop_token_id`.")
+ elif args.stop_token:
+ if args.stop_token == "eos":
+ self.policy_model.generation_config.eos_token_id = self.stop_token_id = processing_class.eos_token_id
+ else:
+ raise ValueError(
+ f"Unknown `stop_token` {args.stop_token}. Allowed values are: `'eos'` and `None` (no stop token)."
+ )
+ else:
+ self.policy_model.generation_config.eos_token_id = self.stop_token_id = args.stop_token_id # None or int
+
+ # Check that the kl estimator is valid
+ if self.args.kl_estimator not in {"k1", "k3"}:
+ raise ValueError(
+ "kl_estimator must be either 'k1' (straightforward, unbiased) or 'k3' (lower variance, unbiased, "
+ "appears to be a strictly better estimator). See "
+ "[Approximating KL Divergence](http://joschu.net/blog/kl-approx.html) for details."
+ )
+
+ # PEFT
+ if peft_config is not None:
+ if not is_peft_available():
+ raise ImportError(
+ "You passed `peft_config` but the `peft` library is not installed. "
+ "Install it with `pip install trl[peft]`."
+ )
+ if not isinstance(peft_config, PeftConfig):
+ raise TypeError(
+ f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), "
+ f"got {type(peft_config).__name__}."
+ )
+ if isinstance(self.policy_model, PeftModel):
+ raise ValueError(
+ "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first "
+ "merge and unload the existing adapter, save the resulting base model, and then pass that base "
+ "model along with the new `peft_config` to the trainer."
+ )
+
+ # get peft model with the given config
+ self.policy_model = get_peft_model(self.policy_model, peft_config)
+ if args.bf16 and getattr(self.policy_model, "is_loaded_in_4bit", False):
+ peft_module_casting_to_bf16(self.policy_model)
+
+ self.is_peft_model = is_peft_available() and isinstance(self.policy_model, PeftModel)
+ self.model_adapter_name = args.model_adapter_name
+ self.ref_adapter_name = args.ref_adapter_name
+
+ if ref_model:
+ self.ref_model = ref_model
+ elif self.is_peft_model:
+ self.ref_model = None
+ else:
+ self.ref_model = create_reference_model(self.policy_model)
+
+ self.reward_model = reward_model
+ self.train_dataset = train_dataset
+ self.train_dataset_len = len(train_dataset)
+ self.value_model = value_model
+ self.data_collator = data_collator
+ self.eval_dataset = eval_dataset
+ self.optimizer, self.lr_scheduler = optimizers
+ self.optimizer_cls_and_kwargs = None # needed for transformers >= 4.47
+
+ #########
+ # calculate various batch sizes
+ #########
+ if args.total_episodes is None: # allow the users to define episodes in terms of epochs.
+ args.total_episodes = int(args.num_train_epochs * self.train_dataset_len)
+ accelerator = Accelerator(gradient_accumulation_steps=args.gradient_accumulation_steps)
+ self.accelerator = accelerator
+ args.world_size = accelerator.num_processes
+ args.local_batch_size = args.per_device_train_batch_size * args.gradient_accumulation_steps
+ args.micro_batch_size = int(args.per_device_train_batch_size * args.world_size)
+ args.batch_size = int(args.local_batch_size * args.world_size)
+ args.mini_batch_size = exact_div(
+ args.batch_size, args.num_mini_batches, "`batch_size` must be a multiple of `num_mini_batches`"
+ )
+ args.local_mini_batch_size = exact_div(
+ args.local_batch_size, args.num_mini_batches, "`local_batch_size` must be a multiple of `num_mini_batches`"
+ )
+ if args.whiten_rewards:
+ assert args.local_mini_batch_size >= 8, (
+ f"Per-rank minibatch size {args.local_mini_batch_size} is insufficient for whitening"
+ )
+ # `per_rank_rollout_batch_size` is our `args.local_batch_size`
+ # `per_rank_minibatch_size` is our `args.local_mini_batch_size`
+ args.num_total_batches = math.ceil(
+ args.total_episodes / args.batch_size
+ ) # we may train for more than `total_episodes`
+ self.local_seed = args.seed + accelerator.process_index * 100003 # Prime
+ if args.num_sample_generations > 0:
+ self.sample_generations_freq = max(1, args.num_total_batches // args.num_sample_generations)
+ self.local_dataloader_batch_size = args.local_batch_size
+
+ #########
+ # setup model, optimizer, and others
+ #########
+ for module in [self.policy_model, self.ref_model, self.value_model, self.reward_model]:
+ if module is not None:
+ disable_dropout_in_model(module)
+ self.model = PolicyAndValueWrapper(self.policy_model, self.value_model)
+ self.model.config = self.policy_model.config # needed for pushing to hub
+ self.create_optimizer_and_scheduler(
+ num_training_steps=args.num_total_batches
+ ) # note that we are calling `self.lr_scheduler.step()` manually only at the batch level
+
+ #########
+ # trainer specifics
+ #########
+ default_callbacks = DEFAULT_CALLBACKS + get_reporting_integration_callbacks(self.args.report_to)
+ self.callbacks = default_callbacks if callbacks is None else default_callbacks + callbacks
+ self.callback_handler = CallbackHandler(
+ self.callbacks, self.model, self.processing_class, self.optimizer, self.lr_scheduler
+ )
+ self.add_callback(PrinterCallback if self.args.disable_tqdm else DEFAULT_PROGRESS_CALLBACK)
+ self.control = TrainerControl()
+ self.state = OnlineTrainerState(
+ is_local_process_zero=self.is_local_process_zero(),
+ is_world_process_zero=self.is_world_process_zero(),
+ stateful_callbacks=[
+ cb for cb in self.callback_handler.callbacks + [self.control] if isinstance(cb, ExportableState)
+ ],
+ )
+ self.current_flos = 0
+ self.hp_search_backend = None
+ self.is_deepspeed_enabled = getattr(self.accelerator.state, "deepspeed_plugin", None) is not None
+ self.is_fsdp_enabled = getattr(self.accelerator.state, "fsdp_plugin", None) is not None
+ # Create distant repo and output directory if needed
+ self.hub_model_id = None
+ if self.args.push_to_hub:
+ self.init_hf_repo()
+ if self.args.should_save:
+ os.makedirs(self.args.output_dir, exist_ok=True)
+
+ # Add tags for models that have been loaded with the correct transformers version
+ if hasattr(self.model, "add_model_tags"):
+ self.model.add_model_tags(self._tag_names)
+
+ #########
+ # setup dataloader
+ #########
+ self.dataloader = DataLoader(
+ self.train_dataset,
+ batch_size=self.local_dataloader_batch_size,
+ shuffle=True,
+ collate_fn=self.data_collator,
+ drop_last=True, # needed; otherwise the last batch will be of ragged shape
+ )
+ # sync random states for DataLoader(shuffle=True) before `accelerator.prepare`
+ # see https://gist.github.com/vwxyzjn/2581bff1e48e185e0b85b6dfe1def79c
+ torch.manual_seed(args.seed)
+ self.model, self.optimizer, self.dataloader = accelerator.prepare(self.model, self.optimizer, self.dataloader)
+ torch.manual_seed(self.local_seed) # reset the local seed again
+
+ self.eval_dataloader = DataLoader(
+ self.eval_dataset,
+ batch_size=args.per_device_eval_batch_size,
+ collate_fn=self.data_collator,
+ drop_last=True,
+ ) # no need to shuffle eval dataset
+ self.eval_dataloader = accelerator.prepare(self.eval_dataloader)
+
+ if self.is_deepspeed_enabled:
+ self.reward_model = prepare_deepspeed(self.reward_model, accelerator)
+
+ if self.ref_model is None:
+ if not self.is_peft_model:
+ raise ValueError("No reference model and model is not a Peft model.")
+ else:
+ self.ref_model = prepare_deepspeed(self.ref_model, accelerator)
+ else:
+ if self.ref_model is None:
+ if not self.is_peft_model:
+ raise ValueError("No reference model and model is not a Peft model.")
+ else:
+ self.ref_model = self.ref_model.to(self.accelerator.device)
+ self.reward_model = self.reward_model.to(self.accelerator.device)
+
+ def get_train_dataloader(self) -> DataLoader:
+ return self.dataloader
+
+ def get_eval_dataloader(self) -> DataLoader:
+ return self.eval_dataloader
+
+ @contextmanager
+ def null_ref_context(self):
+ """Context manager for handling null reference model (that is, peft adapter manipulation)."""
+ with (
+ self.accelerator.unwrap_model(self.model.policy).disable_adapter()
+ if self.is_peft_model and not self.ref_adapter_name
+ else nullcontext()
+ ):
+ if self.ref_adapter_name:
+ self.model.policy.set_adapter(self.ref_adapter_name)
+ yield
+ if self.ref_adapter_name:
+ self.model.policy.set_adapter(self.model_adapter_name or "default")
+
+ def save_model(self, output_dir: str | None = None, _internal_call: bool = False):
+ backup_model = self.model
+ if hasattr(self.model, "policy"):
+ self.model = self.model.policy # save only the policy for inference
+ if self.is_deepspeed_enabled:
+ backup_deepspeed = self.deepspeed
+ self.deepspeed = self.model
+
+ super().save_model(output_dir, _internal_call)
+
+ self.model = backup_model
+ if self.is_deepspeed_enabled:
+ self.deepspeed = backup_deepspeed
+
+ def train(self):
+ args = self.args
+ accelerator = self.accelerator
+ optimizer = self.optimizer
+ model = self.model
+ ref_policy = self.ref_model
+ reward_model = self.reward_model
+ processing_class = self.processing_class
+ dataloader = self.dataloader
+ device = accelerator.device
+
+ def repeat_generator():
+ while True:
+ yield from dataloader
+
+ iter_dataloader = iter(repeat_generator())
+ generation_kwargs = {
+ "max_new_tokens": args.response_length,
+ "temperature": (args.temperature + 1e-7),
+ "top_k": 0.0,
+ "top_p": 1.0,
+ "do_sample": True,
+ }
+ generation_config = GenerationConfig(**generation_kwargs)
+
+ accelerator.print("===training policy===")
+ start_time = time.time()
+ stats_shape = (args.num_ppo_epochs, args.num_mini_batches, args.gradient_accumulation_steps)
+ approxkl_stats = torch.zeros(stats_shape, device=device)
+ pg_clipfrac_stats = torch.zeros(stats_shape, device=device)
+ pg_loss_stats = torch.zeros(stats_shape, device=device)
+ vf_loss_stats = torch.zeros(stats_shape, device=device)
+ vf_clipfrac_stats = torch.zeros(stats_shape, device=device)
+ entropy_stats = torch.zeros(stats_shape, device=device)
+ ratio_stats = torch.zeros(stats_shape, device=device)
+ model.train()
+
+ # trainer state initialization
+ self.state.global_step = 0
+ self.state.episode = 0
+ self.state.max_steps = args.num_total_batches
+ self.state.num_train_epochs = args.total_episodes / self.train_dataset_len
+ # Compute absolute values for logging, eval, and save if given as ratio
+ if args.logging_steps is not None:
+ if args.logging_steps < 1:
+ self.state.logging_steps = math.ceil(self.state.max_steps * args.logging_steps)
+ else:
+ self.state.logging_steps = args.logging_steps
+ if args.eval_steps is not None:
+ if args.eval_steps < 1:
+ self.state.eval_steps = math.ceil(self.state.max_steps * args.eval_steps)
+ else:
+ self.state.eval_steps = args.eval_steps
+ if args.save_steps is not None:
+ if args.save_steps < 1:
+ self.state.save_steps = math.ceil(self.state.max_steps * args.save_steps)
+ else:
+ self.state.save_steps = args.save_steps
+ self.control = self.callback_handler.on_train_begin(args, self.state, self.control)
+
+ # backward compatibility
+ if self.is_deepspeed_enabled:
+ self.deepspeed = self.model
+ self.model_wrapped = self.model
+
+ for update in range(1, args.num_total_batches + 1):
+ self.state.episode += 1 * args.batch_size
+ data = next(iter_dataloader)
+ with torch.no_grad():
+ queries = data["input_ids"].to(device)
+ context_length = queries.shape[1]
+ responses = []
+ postprocessed_responses = []
+ logprobs = []
+ ref_logprobs = []
+ scores = []
+ sequence_lengths = []
+ values = []
+ with (
+ unwrap_model_for_generation(
+ self.model,
+ self.accelerator,
+ gather_deepspeed3_params=self.args.ds3_gather_for_generation,
+ generation_kwargs=generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762
+ ) as unwrapped_model
+ ):
+ query_responses, logitss = batch_generation(
+ unwrapped_model.policy,
+ queries,
+ args.local_rollout_forward_batch_size,
+ processing_class.pad_token_id,
+ generation_config,
+ )
+
+ for i in range(0, queries.shape[0], args.local_rollout_forward_batch_size):
+ query = queries[i : i + args.local_rollout_forward_batch_size]
+ query_response = query_responses[i : i + args.local_rollout_forward_batch_size]
+ response = query_response[:, context_length:]
+ logits = logitss[i : i + args.local_rollout_forward_batch_size]
+ logprob = selective_log_softmax(logits, response)
+ del logits
+ empty_cache()
+
+ if ref_policy is None:
+ with self.null_ref_context():
+ ref_output = forward(model.policy, query_response, processing_class.pad_token_id)
+ else:
+ ref_output = forward(ref_policy, query_response, processing_class.pad_token_id)
+ ref_logits = ref_output.logits[:, context_length - 1 : -1]
+ ref_logits /= args.temperature + 1e-7
+ ref_logprob = selective_log_softmax(ref_logits, response)
+ del ref_output, ref_logits
+ empty_cache()
+
+ # Response Processing 1. truncate response after the first occurrence of `stop_token_id`
+ postprocessed_response = response
+ if self.stop_token_id is not None: # handle the edge case when stop_token_id exists but is 0
+ postprocessed_response = truncate_response(
+ self.stop_token_id, processing_class.pad_token_id, response
+ )
+
+ # Response Processing 2. run reward model on the truncated responses
+ postprocessed_query_response = torch.cat((query, postprocessed_response), 1)
+ sequence_length = first_true_indices(postprocessed_response == processing_class.pad_token_id) - 1
+ unwrapped_value_model = accelerator.unwrap_model(model).value_model
+ full_value, _, _ = get_reward(
+ unwrapped_value_model, query_response, processing_class.pad_token_id, context_length
+ )
+ value = full_value[:, context_length - 1 : -1].squeeze(-1)
+ _, score, _ = get_reward(
+ reward_model, postprocessed_query_response, processing_class.pad_token_id, context_length
+ )
+
+ responses.append(response)
+ postprocessed_responses.append(postprocessed_response)
+ logprobs.append(logprob)
+ ref_logprobs.append(ref_logprob)
+ sequence_lengths.append(sequence_length)
+ scores.append(score)
+ values.append(value)
+ responses = torch.cat(responses, 0)
+ postprocessed_responses = torch.cat(postprocessed_responses, 0)
+ logprobs = torch.cat(logprobs, 0)
+ ref_logprobs = torch.cat(ref_logprobs, 0)
+ sequence_lengths = torch.cat(sequence_lengths, 0)
+ scores = torch.cat(scores, 0)
+ values = torch.cat(values, 0)
+ del (logprob, ref_logprob, full_value, value, score, unwrapped_model)
+ empty_cache()
+ gc.collect()
+
+ # Response Processing 3. Filter completion. Ensure that the sample contains stop_token_id
+ # Completions not passing that filter will receive a lower score.
+ contain_eos_token = torch.any(postprocessed_responses == self.processing_class.eos_token_id, dim=-1)
+ if self.args.missing_eos_penalty is not None:
+ scores[~contain_eos_token] -= self.args.missing_eos_penalty
+ # accelerator.print(f"{scores=}, {(contain_eos_token.sum() / len(contain_eos_token))=}")
+
+ # be very careful with `padding_mask_p1`; see https://excalidraw.com/#json=LWnzG4w2k5DjF_EOL_xPt,e2w3a-hFJ_gX5vOfeyXGTw
+ response_idxs = torch.arange(responses.shape[1], device=responses.device).repeat(responses.shape[0], 1)
+ padding_mask = response_idxs > sequence_lengths.unsqueeze(1)
+ logprobs = torch.masked_fill(logprobs, padding_mask, INVALID_LOGPROB)
+ ref_logprobs = torch.masked_fill(ref_logprobs, padding_mask, INVALID_LOGPROB)
+ sequence_lengths_p1 = sequence_lengths + 1
+ padding_mask_p1 = response_idxs > (sequence_lengths_p1.unsqueeze(1))
+ values = torch.masked_fill(values, padding_mask_p1, 0)
+
+ # 4. compute rewards
+ # Formula used by http://joschu.net/blog/kl-approx.html for the k1 and k3 estimators
+ logr = ref_logprobs - logprobs
+ kl = -logr if args.kl_estimator == "k1" else (logr.exp() - 1) - logr # Else statement is k3
+ non_score_reward = -args.kl_coef * kl
+ rewards = non_score_reward.clone()
+ actual_start = torch.arange(rewards.size(0), device=rewards.device)
+ actual_end = torch.where(sequence_lengths_p1 < rewards.size(1), sequence_lengths_p1, sequence_lengths)
+ rewards[actual_start, actual_end] += scores
+
+ # 5. whiten rewards
+ if args.whiten_rewards:
+ rewards = masked_whiten(rewards, mask=~padding_mask_p1, shift_mean=False)
+ rewards = torch.masked_fill(rewards, padding_mask_p1, 0)
+
+ # 6. compute advantages and returns
+ lastgaelam = 0
+ advantages_reversed = []
+ gen_length = responses.shape[1]
+ for t in reversed(range(gen_length)):
+ nextvalues = values[:, t + 1] if t < gen_length - 1 else 0.0
+ delta = rewards[:, t] + args.gamma * nextvalues - values[:, t]
+ lastgaelam = delta + args.gamma * args.lam * lastgaelam
+ advantages_reversed.append(lastgaelam)
+ advantages = torch.stack(advantages_reversed[::-1], axis=1)
+ returns = advantages + values
+ advantages = masked_whiten(advantages, ~padding_mask)
+ advantages = torch.masked_fill(advantages, padding_mask, 0)
+ empty_cache()
+
+ # Do multiple epochs of PPO training, with a fresh random shuffle in each epoch
+ for ppo_epoch_idx in range(args.num_ppo_epochs):
+ b_inds = np.random.permutation(args.local_batch_size)
+ minibatch_idx = 0
+ for mini_batch_start in range(0, args.local_batch_size, args.local_mini_batch_size):
+ mini_batch_end = mini_batch_start + args.local_mini_batch_size
+ mini_batch_inds = b_inds[mini_batch_start:mini_batch_end]
+ gradient_accumulation_idx = 0
+ for micro_batch_start in range(0, args.local_mini_batch_size, args.per_device_train_batch_size):
+ with accelerator.accumulate(model):
+ micro_batch_end = micro_batch_start + args.per_device_train_batch_size
+ micro_batch_inds = mini_batch_inds[micro_batch_start:micro_batch_end]
+ mb_advantage = advantages[micro_batch_inds]
+ mb_responses = responses[micro_batch_inds]
+ mb_query_responses = query_responses[micro_batch_inds]
+ mb_logprobs = logprobs[micro_batch_inds]
+ mb_return = returns[micro_batch_inds]
+ mb_values = values[micro_batch_inds]
+
+ output, vpred_temp = forward(model, mb_query_responses, processing_class.pad_token_id)
+ logits = output.logits[:, context_length - 1 : -1]
+ logits /= args.temperature + 1e-7
+ new_logprobs = selective_log_softmax(logits, mb_responses)
+ new_logprobs = torch.masked_fill(
+ new_logprobs, padding_mask[micro_batch_inds], INVALID_LOGPROB
+ )
+ vpred = vpred_temp[:, context_length - 1 : -1].squeeze(-1)
+ vpred = torch.masked_fill(vpred, padding_mask_p1[micro_batch_inds], 0)
+ vpredclipped = torch.clamp(
+ vpred,
+ mb_values - args.cliprange_value,
+ mb_values + args.cliprange_value,
+ )
+ vf_losses1 = torch.square(vpred - mb_return)
+ vf_losses2 = torch.square(vpredclipped - mb_return)
+ vf_loss_max = torch.max(vf_losses1, vf_losses2)
+ vf_loss = 0.5 * masked_mean(vf_loss_max, ~padding_mask_p1[micro_batch_inds])
+ vf_clipfrac = masked_mean(
+ (vf_losses2 > vf_losses1).float(), ~padding_mask_p1[micro_batch_inds]
+ )
+ logprobs_diff = new_logprobs - mb_logprobs
+ ratio = torch.exp(logprobs_diff)
+ pg_losses = -mb_advantage * ratio
+ pg_losses2 = -mb_advantage * torch.clamp(ratio, 1.0 - args.cliprange, 1.0 + args.cliprange)
+ pg_loss_max = torch.max(pg_losses, pg_losses2)
+ pg_loss = masked_mean(pg_loss_max, ~padding_mask[micro_batch_inds])
+ loss = pg_loss + args.vf_coef * vf_loss
+ accelerator.backward(loss)
+ optimizer.step()
+ optimizer.zero_grad()
+ with torch.no_grad():
+ pg_clipfrac = masked_mean(
+ (pg_losses2 > pg_losses).float(), ~padding_mask[micro_batch_inds]
+ )
+ prob_dist = torch.nn.functional.softmax(logits, dim=-1)
+ entropy = torch.logsumexp(logits, dim=-1) - torch.sum(prob_dist * logits, dim=-1)
+ approxkl = 0.5 * (logprobs_diff**2).mean()
+ approxkl_stats[ppo_epoch_idx, minibatch_idx, gradient_accumulation_idx] = approxkl
+ pg_clipfrac_stats[ppo_epoch_idx, minibatch_idx, gradient_accumulation_idx] = (
+ pg_clipfrac
+ )
+ pg_loss_stats[ppo_epoch_idx, minibatch_idx, gradient_accumulation_idx] = pg_loss
+ vf_loss_stats[ppo_epoch_idx, minibatch_idx, gradient_accumulation_idx] = vf_loss
+ vf_clipfrac_stats[ppo_epoch_idx, minibatch_idx, gradient_accumulation_idx] = (
+ vf_clipfrac
+ )
+ entropy_stats[ppo_epoch_idx, minibatch_idx, gradient_accumulation_idx] = entropy.mean()
+ ratio_stats[ppo_epoch_idx, minibatch_idx, gradient_accumulation_idx] = ratio.mean()
+ gradient_accumulation_idx += 1
+ minibatch_idx += 1
+ # del everything and empty cache
+ # fmt: off
+ del (
+ output, vpred_temp, logits, new_logprobs, vpred, vpredclipped,
+ vf_losses1, vf_losses2, vf_loss, vf_clipfrac, logprobs_diff, ratio, pg_losses, pg_losses2, pg_loss_max,
+ pg_loss, loss, pg_clipfrac, prob_dist, entropy, approxkl, mb_return,
+ mb_advantage, mb_values, mb_responses, mb_query_responses, mb_logprobs,
+ )
+ # fmt: on
+ empty_cache()
+ with torch.no_grad():
+ mean_kl = kl.sum(1).mean()
+ mean_entropy = (-logprobs).sum(1).mean()
+ mean_non_score_reward = non_score_reward.sum(1).mean()
+ rlhf_reward = mean_non_score_reward + scores.mean()
+ eps = int(self.state.episode / (time.time() - start_time))
+ metrics = {}
+ metrics["eps"] = eps
+ metrics["objective/kl"] = self.accelerator.gather_for_metrics(mean_kl).mean().item()
+ metrics["objective/entropy"] = self.accelerator.gather_for_metrics(mean_entropy).mean().item()
+ metrics["objective/non_score_reward"] = (
+ self.accelerator.gather_for_metrics(mean_non_score_reward).mean().item()
+ )
+ metrics["objective/rlhf_reward"] = self.accelerator.gather_for_metrics(rlhf_reward).mean().item()
+ metrics["objective/scores"] = self.accelerator.gather_for_metrics(scores.mean()).mean().item()
+ metrics["policy/approxkl_avg"] = self.accelerator.gather_for_metrics(approxkl_stats).mean().item()
+ metrics["policy/clipfrac_avg"] = self.accelerator.gather_for_metrics(pg_clipfrac_stats).mean().item()
+ metrics["loss/policy_avg"] = self.accelerator.gather_for_metrics(pg_loss_stats).mean().item()
+ metrics["loss/value_avg"] = self.accelerator.gather_for_metrics(vf_loss_stats).mean().item()
+ metrics["val/clipfrac_avg"] = self.accelerator.gather_for_metrics(vf_clipfrac_stats).mean().item()
+ metrics["policy/entropy_avg"] = self.accelerator.gather_for_metrics(entropy_stats).mean().item()
+ metrics["val/ratio"] = self.accelerator.gather_for_metrics(ratio_stats).mean().item()
+ metrics["val/ratio_var"] = self.accelerator.gather_for_metrics(ratio_stats).var().item()
+ metrics["val/num_eos_tokens"] = (responses == processing_class.eos_token_id).sum().item()
+ metrics["lr"] = self.lr_scheduler.get_last_lr()[0]
+ metrics["episode"] = self.state.episode
+ self.state.epoch = self.state.episode / self.train_dataset_len # used by self.log
+ self.state.global_step += 1
+ self.log(metrics)
+
+ self.lr_scheduler.step()
+ self.control = self.callback_handler.on_step_end(args, self.state, self.control)
+ if self.control.should_save:
+ self._save_checkpoint(model, trial=None)
+ self.control = self.callback_handler.on_save(self.args, self.state, self.control)
+ del kl, mean_kl, mean_entropy, mean_non_score_reward, scores, metrics, non_score_reward
+ empty_cache()
+ gc.collect()
+
+ if args.num_sample_generations > 0 and (update - 1) % self.sample_generations_freq == 0:
+ self.generate_completions(sampling=True)
+ empty_cache()
+ del (
+ query_responses,
+ responses,
+ postprocessed_responses,
+ logprobs,
+ ref_logprobs,
+ values,
+ sequence_lengths,
+ contain_eos_token,
+ sequence_lengths_p1,
+ response_idxs,
+ padding_mask,
+ padding_mask_p1,
+ rewards,
+ actual_start,
+ actual_end,
+ advantages,
+ returns,
+ )
+ empty_cache()
+
+ # HF trainer specifics
+ self.control = self.callback_handler.on_train_end(args, self.state, self.control)
+ if self.control.should_save:
+ self._save_checkpoint(model, trial=None)
+ self.control = self.callback_handler.on_save(self.args, self.state, self.control)
+
+ def generate_completions(self, sampling: bool = False):
+ if self.eval_dataset is None:
+ return # no eval set to sample from (pass eval_dataset and eval_strategy != "no" for sample generations)
+ args = self.args
+ processing_class = self.processing_class
+ generation_kwargs = {
+ "max_new_tokens": args.response_length,
+ "temperature": (0.01 + 1e-7),
+ "top_k": 0.0,
+ "top_p": 1.0,
+ "do_sample": True,
+ }
+ generation_config = GenerationConfig(**generation_kwargs)
+
+ table = defaultdict(list)
+ with (
+ unwrap_model_for_generation(
+ self.model,
+ self.accelerator,
+ gather_deepspeed3_params=self.args.ds3_gather_for_generation,
+ generation_kwargs=generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762
+ ) as unwrapped_model
+ ):
+ for batch in self.eval_dataloader:
+ query = batch["input_ids"]
+ with torch.no_grad():
+ context_length = query.shape[1]
+ query_response, _ = batch_generation(
+ unwrapped_model.policy,
+ query,
+ query.shape[0],
+ processing_class.pad_token_id,
+ generation_config,
+ )
+ response = query_response[:, context_length:]
+ postprocessed_response = response
+ if self.stop_token_id is not None: # handle the edge case when stop_token_id exists but is 0
+ postprocessed_response = truncate_response(
+ self.stop_token_id, processing_class.pad_token_id, response
+ )
+ table["query"].extend(
+ gather_object(processing_class.batch_decode(query, skip_special_tokens=True))
+ )
+ table["model response"].extend(
+ gather_object(processing_class.batch_decode(postprocessed_response))
+ )
+
+ postprocessed_query_response = torch.cat((query, postprocessed_response), 1)
+ _, score, _ = get_reward(
+ self.reward_model, postprocessed_query_response, processing_class.pad_token_id, context_length
+ )
+ table["score"].extend(self.accelerator.gather_for_metrics(score).float().cpu().numpy())
+
+ if sampling:
+ break
+ df = pd.DataFrame(table)
+
+ if self.accelerator.is_main_process:
+ if is_rich_available():
+ print_rich_table(df.iloc[0 : 0 + 5])
+ if "wandb" in args.report_to:
+ import wandb
+
+ if wandb.run is not None:
+ wandb.log({"completions": wandb.Table(dataframe=df)})
+
+ if "comet_ml" in args.report_to:
+ log_table_to_comet_experiment(
+ name="completions.csv",
+ table=df,
+ )
+
+ # Ensure the model card is saved along with the checkpoint
+ def _save_checkpoint(self, model, trial):
+ if self.args.hub_model_id is None:
+ model_name = Path(self.args.output_dir).name
+ else:
+ model_name = self.args.hub_model_id.split("/")[-1]
+ self.create_model_card(model_name=model_name)
+ super()._save_checkpoint(model, trial)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/prm/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/prm/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..210c474aa459261c71906d4e1b11994a08dddd4c
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/prm/__init__.py
@@ -0,0 +1,19 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .prm_config import PRMConfig
+from .prm_trainer import PRMTrainer
+
+
+__all__ = ["PRMConfig", "PRMTrainer"]
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/prm/prm_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/prm/prm_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..b6150c01b2e4739e027ee3072080c5f057478841
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/prm/prm_config.py
@@ -0,0 +1,88 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+
+from ...trainer.base_config import _BaseConfig
+
+
+@dataclass
+class PRMConfig(_BaseConfig):
+ # docstyle-ignore
+ r"""
+ Configuration class for the [`experimental.prm.PRMTrainer`].
+
+ This class includes only the parameters that are specific to PRM training. For a full list of training arguments,
+ please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may
+ differ from those in [`~transformers.TrainingArguments`].
+
+ Using [`~transformers.HfArgumentParser`] we can turn this class into
+ [argparse](https://docs.python.org/3/library/argparse#module-argparse) arguments that can be specified on the
+ command line.
+
+ Parameters:
+ max_length (`int` or `None`, *optional*, defaults to `1024`):
+ Maximum length of the sequences (prompt + completion) used for truncation.
+ max_completion_length (`int`, *optional*):
+ Maximum length of the completion used for truncation. The completion is the concatenation of the steps.
+ disable_dropout (`bool`, *optional*, defaults to `True`):
+ Whether to disable dropout in the model.
+ step_separator (`str`, *optional*, defaults to `"\n"`):
+ Separator used to separate each step of the reasoning process.
+ train_on_last_step_only (`bool`, *optional*, defaults to `False`):
+ Whether to train only on the last step.
+ dataset_num_proc (`int`, *optional*):
+ Number of processes to use for processing the dataset.
+
+ > [!NOTE]
+ > These parameters have default values different from [`~transformers.TrainingArguments`]:
+ > - `logging_steps`: Defaults to `10` instead of `500`.
+ > - `gradient_checkpointing`: Defaults to `True` instead of `False`.
+ > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`.
+ > - `learning_rate`: Defaults to `1e-5` instead of `5e-5`.
+ """
+
+ # Parameters whose default values are overridden from TrainingArguments
+ learning_rate: float = field(
+ default=1e-5,
+ metadata={"help": "The initial learning rate for AdamW."},
+ )
+
+ max_length: int | None = field(
+ default=1024,
+ metadata={"help": "Maximum length of the sequences (prompt + completion) used for truncation."},
+ )
+ max_completion_length: int | None = field(
+ default=None,
+ metadata={
+ "help": "Maximum length of the completion used for truncation. The completion is the concatenation of the "
+ "steps."
+ },
+ )
+ disable_dropout: bool = field(
+ default=True,
+ metadata={"help": "Whether to disable dropout in the model and reference model."},
+ )
+ step_separator: str = field(
+ default="\n",
+ metadata={"help": "Separator used to separate each step of the reasoning process."},
+ )
+ train_on_last_step_only: bool = field(
+ default=False,
+ metadata={"help": "Whether to train only on the last step."},
+ )
+ dataset_num_proc: int | None = field(
+ default=None,
+ metadata={"help": "Number of processes to use for processing the dataset."},
+ )
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/prm/prm_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/prm/prm_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..43ad64b849956c1fb48bec9e7d372fcbe560fa1b
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/prm/prm_trainer.py
@@ -0,0 +1,371 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import textwrap
+from collections.abc import Callable
+from itertools import chain
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn as nn
+import transformers
+from accelerate import PartialState
+from accelerate.logging import get_logger
+from accelerate.utils import is_peft_model
+from datasets import Dataset, features
+from packaging.version import Version
+from transformers import (
+ BaseImageProcessor,
+ DataCollator,
+ DataCollatorForTokenClassification,
+ FeatureExtractionMixin,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+ ProcessorMixin,
+ TrainerCallback,
+)
+from transformers.trainer_utils import EvalPrediction
+from transformers.utils import is_peft_available
+
+from ...trainer.base_trainer import _BaseTrainer
+from ...trainer.utils import disable_dropout_in_model
+from ..utils import prepare_peft_model
+from .prm_config import PRMConfig
+
+
+if is_peft_available():
+ from peft import PeftConfig
+
+logger = get_logger(__name__)
+
+
+def compute_accuracy(eval_pred: EvalPrediction) -> dict[str, float]:
+ predictions, labels = eval_pred
+ if predictions.ndim == 3:
+ # Token classification task. Shapes are (batch_size, seq_len, num_labels) and (batch_size, seq_len)
+ # Used to compute the accuracy in the prm_trainer.
+ predictions = np.argmax(predictions, axis=2)
+
+ # Flatten the predictions and labels to remove the ignored tokens.
+ predictions = np.array(
+ [
+ p
+ for prediction, label in zip(predictions, labels, strict=True)
+ for (p, lbl) in zip(prediction, label, strict=True)
+ if lbl != -100
+ ]
+ )
+ labels = np.array([lbl for label in labels for lbl in label if lbl != -100])
+
+ else:
+ # Here, predictions is rewards_chosen and rewards_rejected. Shapes are (batch_size, 2) and (batch_size,)
+ # We want to see how much of the time rewards_chosen > rewards_rejected.
+ equal_mask = predictions[:, 0] == predictions[:, 1]
+ equal_predictions_count = int(equal_mask.sum())
+
+ if equal_predictions_count > 0:
+ # Before using the logger, the accelerate state must be initialized. It'susually the case when using this
+ # function inside a Trainer, but it may not be the case otherwise, in particular when unit testing.
+ PartialState()
+
+ logger.warning(
+ f"There are {equal_predictions_count} out of {len(predictions[:, 0])} instances where the predictions "
+ "for both options are equal. These instances are ignored in the accuracy computation.",
+ )
+
+ # Filter out equal predictions
+ predictions = predictions[~equal_mask]
+ labels = labels[~equal_mask]
+
+ # Use the remaining predictions for accuracy calculation
+ predictions = np.argmax(predictions, axis=1)
+
+ accuracy = np.array(predictions == labels, dtype=float).mean().item()
+ return {"accuracy": accuracy}
+
+
+class PRMTrainer(_BaseTrainer):
+ """
+ Initialize PRMTrainer.
+
+ Args:
+ model ([`~transformers.PreTrainedModel`]):
+ The model to train, preferably an `AutoModelForTokenClassification`.
+ args ([`experimental.prm.PRMConfig`]):
+ The arguments to use for training.
+ data_collator ([`~transformers.DataCollator`]):
+ The data collator to use for training. If None is specified, the default data collator
+ ([`~transformers.DataCollatorForTokenClassification`]) will be used which will pad the sequences to the
+ maximum length of the sequences in the batch, given a dataset of paired sequences.
+ train_dataset ([`~datasets.Dataset`]):
+ The dataset to use for training.
+ eval_dataset ([`~datasets.Dataset`]):
+ The dataset to use for evaluation.
+ processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.BaseImageProcessor`], [`~transformers.FeatureExtractionMixin`] or [`~transformers.ProcessorMixin`], *optional*):
+ Processing class used to process the data. If provided, will be used to automatically process the inputs
+ for the model, and it will be saved along the model to make it easier to rerun an interrupted training or
+ reuse the fine-tuned model.
+ model_init (`Callable[[], transformers.PreTrainedModel]`):
+ The model initializer to use for training. If None is specified, the default model initializer will be
+ used.
+ compute_metrics (`Callable[[transformers.EvalPrediction], dict]`, *optional* defaults to `compute_accuracy`):
+ The metrics to use for evaluation. If no metrics are specified, the default metric (`compute_accuracy`)
+ will be used.
+ callbacks (`list[transformers.TrainerCallback]`):
+ The callbacks to use for training.
+ optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`):
+ The optimizer and scheduler to use for training.
+ preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`):
+ The function to use to preprocess the logits before computing the metrics.
+ peft_config ([`~peft.PeftConfig`], *optional*):
+ The PEFT configuration to use for training. If you pass a PEFT configuration, the model will be wrapped in
+ a PEFT model.
+ """
+
+ _tag_names = ["trl", "prm"]
+ _name = "PRM"
+ _paper = {
+ "title": "Solving math word problems with process-and outcome-based feedback",
+ "id": "2211.14275",
+ # docstyle-ignore
+ "citation": textwrap.dedent("""\
+ @article{uesato2022solving,
+ title = {{Solving Math Word Problems With Process- and Outcome-Based Feedback}},
+ author = {Uesato, Jonathan and Kushman, Nate and Kumar, Ramana and Song, Francis and Siegel, Noah and Wang, Lisa and Creswell, Antonia and Irving, Geoffrey and Higgins, Irina},
+ year = 2022,
+ journal = {arXiv preprint arXiv:2211.14275}
+ }"""),
+ }
+
+ def __init__(
+ self,
+ model: PreTrainedModel | nn.Module | None = None,
+ args: PRMConfig | None = None,
+ data_collator: DataCollator | None = None,
+ train_dataset: Dataset | None = None,
+ eval_dataset: Dataset | dict[str, Dataset] | None = None,
+ processing_class: PreTrainedTokenizerBase
+ | BaseImageProcessor
+ | FeatureExtractionMixin
+ | ProcessorMixin
+ | None = None,
+ model_init: Callable[[], PreTrainedModel] | None = None,
+ compute_metrics: Callable[[EvalPrediction], dict] | None = None,
+ callbacks: list[TrainerCallback] | None = None,
+ optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (
+ None,
+ None,
+ ),
+ preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None,
+ peft_config: "PeftConfig | None" = None,
+ ):
+ if train_dataset is None:
+ raise ValueError("`train_dataset` is required")
+
+ # PEFT
+ if peft_config is not None:
+ if not is_peft_available():
+ raise ImportError(
+ "You passed `peft_config` but the `peft` library is not installed. "
+ "Install it with `pip install trl[peft]`."
+ )
+ if not isinstance(peft_config, PeftConfig):
+ raise TypeError(
+ f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), "
+ f"got {type(peft_config).__name__}."
+ )
+ if peft_config is not None or is_peft_model(model):
+ model = prepare_peft_model(model, peft_config, args)
+
+ # Disable dropout in the model
+ if args.disable_dropout:
+ disable_dropout_in_model(model)
+
+ if compute_metrics is None:
+ compute_metrics = compute_accuracy
+
+ if data_collator is None:
+ if processing_class is None:
+ raise ValueError(
+ "A processing_class must be specified when using the default DataCollatorForTokenClassification"
+ )
+ data_collator = DataCollatorForTokenClassification(processing_class)
+
+ if "input_ids" not in train_dataset.column_names:
+ with PartialState().main_process_first():
+ fn_kwargs = {
+ "tokenizer": processing_class,
+ "step_separator": args.step_separator,
+ "max_length": args.max_length,
+ "max_completion_length": args.max_completion_length,
+ "train_on_last_step_only": args.train_on_last_step_only,
+ }
+ train_fn_kwargs = {**fn_kwargs, "is_eval": False}
+ train_dataset = train_dataset.map(
+ self.tokenize_row,
+ fn_kwargs=train_fn_kwargs,
+ num_proc=args.dataset_num_proc,
+ remove_columns=train_dataset.features,
+ desc="Tokenizing train dataset",
+ features=features.Features( # needed to avoid map to cast labels to bool
+ {
+ "labels": features.Sequence(features.Value("int64")),
+ "input_ids": features.Sequence(features.Value("int64")),
+ }
+ ),
+ )
+
+ eval_fn_kwargs = {**fn_kwargs, "is_eval": True}
+ if eval_dataset is not None:
+ eval_dataset = eval_dataset.map(
+ self.tokenize_row,
+ fn_kwargs=eval_fn_kwargs,
+ num_proc=args.dataset_num_proc,
+ remove_columns=eval_dataset.features,
+ desc="Tokenizing eval dataset",
+ features=features.Features( # needed to avoid map to cast labels to bool
+ {
+ "labels": features.Sequence(features.Value("int64")),
+ "input_ids": features.Sequence(features.Value("int64")),
+ }
+ ),
+ )
+
+ # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was
+ # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream
+ # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we
+ # default to the recommended non-reentrant behavior here, while preserving any user-provided value.
+ if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"):
+ args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {}
+ args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False)
+
+ super().__init__(
+ model=model,
+ args=args,
+ data_collator=data_collator,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=processing_class,
+ model_init=model_init,
+ compute_metrics=compute_metrics,
+ callbacks=callbacks,
+ optimizers=optimizers,
+ preprocess_logits_for_metrics=preprocess_logits_for_metrics,
+ )
+
+ # Add tags for models that have been loaded with the correct transformers version
+ if hasattr(self.model, "add_model_tags"):
+ self.model.add_model_tags(self._tag_names)
+
+ @staticmethod
+ def tokenize_row(
+ features,
+ tokenizer,
+ step_separator,
+ max_length,
+ max_completion_length,
+ train_on_last_step_only,
+ is_eval,
+ ):
+ r"""
+ Tokenize a row of the dataset.
+
+ Args:
+ features (`dict[str, str]`):
+ Row of the dataset, should contain the keys `"prompt"`, `"completions"`, and `"labels"`.
+ tokenizer ([`~transformers.PreTrainedTokenizerBase`]):
+ Tokenizer used to process the data.
+ step_separator (`str`):
+ Separator between steps in the completion.
+ max_length (`int` or `None`):
+ Maximum length of the sequences (prompt + completion). If `None`, the sequences are not truncated.
+ max_completion_length (`int` or `None`):
+ Maximum length of the completion sequences. If `None`, the completion sequences are not truncated.
+ train_on_last_step_only (`bool`):
+ Whether to train only on the last step. If `True`, the labels are `-100` for all tokens except the last
+ token of the completion.
+ is_eval (`bool`):
+ Whether the function is used to tokenize samples from a training or an evaluation dataset. Used only if
+ `train_on_last_step_only` is set to `True`.
+
+ Returns:
+ `dict[str, list[int]]`:
+ Tokenized sequences with the keys `"input_ids"`, and `"labels".
+
+ Example:
+ ```python
+ >>> from transformers import AutoTokenizer
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B")
+ >>> features = {
+ ... "prompt": "Which number is larger, 9.8 or 9.11?",
+ ... "completions": ["11 is greater than 8.", "Hence, 9.11 > 9.8."],
+ ... "labels": [True, False],
+ ... }
+ >>> PRMTrainer.tokenize_row(
+ ... features, tokenizer, "\n", max_completion_length=None, train_on_last_step_only=False, is_eval=False
+ ... )
+ {'input_ids': [23085, 1372, 374, 8131, 11, 220, 24, 13, 23, 476, 220, 24, 13, 16, 16, 30, 16, 16, 374, 7046, 1091, 220, 23, 13, 198, 39, 763, 11, 220, 24, 13, 16, 16, 861, 220, 24, 13, 23, 13, 198],
+ 'labels': [-100, -100, -100, -100, -100, -100, -100, -100, 1, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, 0]}
+ ```
+ """
+ # Tokenize the prompt and completions
+ prompt_ids = tokenizer(features["prompt"], add_special_tokens=False)["input_ids"]
+ completions_ids = [
+ tokenizer(completion, add_special_tokens=False)["input_ids"] for completion in features["completions"]
+ ]
+ if train_on_last_step_only and not is_eval:
+ labels = [-100] * (len(features["labels"]) - 1) + [int(features["labels"][-1])]
+ else:
+ labels = [int(label) for label in features["labels"]]
+
+ # Get the ID of the separator token and add it to the completions
+ separator_ids = tokenizer.encode(step_separator, add_special_tokens=False)
+ completions_ids = [completion + separator_ids for completion in completions_ids]
+
+ # Create the label
+ labels = [
+ [-100] * (len(completion) - 1) + [label] for completion, label in zip(completions_ids, labels, strict=True)
+ ]
+
+ # Join the completions and labels steps
+ completion_ids = list(chain(*completions_ids))
+ labels = list(chain(*labels))
+
+ if tokenizer.bos_token_id is not None:
+ prompt_ids = [tokenizer.bos_token_id] + prompt_ids
+
+ # Truncate completion sequences
+ if max_completion_length is not None:
+ completion_ids = completion_ids[:max_completion_length]
+ labels = labels[:max_completion_length]
+
+ input_ids = prompt_ids + completion_ids
+ labels = [-100] * len(prompt_ids) + labels
+
+ if max_length is not None:
+ input_ids = input_ids[:max_length]
+ labels = labels[:max_length]
+
+ return {"input_ids": input_ids, "labels": labels}
+
+ # Ensure the model card is saved along with the checkpoint
+ def _save_checkpoint(self, model, trial):
+ if self.args.hub_model_id is None:
+ model_name = Path(self.args.output_dir).name
+ else:
+ model_name = self.args.hub_model_id.split("/")[-1]
+ self.create_model_card(model_name=model_name)
+ super()._save_checkpoint(model, trial)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdft/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdft/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..85a7818ae5c8b83264ffec56a58c52f344fa5c26
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdft/__init__.py
@@ -0,0 +1,19 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .sdft_config import SDFTConfig
+from .sdft_trainer import SDFTTrainer
+
+
+__all__ = ["SDFTConfig", "SDFTTrainer"]
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdft/loss_utils.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdft/loss_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..5caa8c88713d2088c9c4c728dcea3e62236cf4e4
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdft/loss_utils.py
@@ -0,0 +1,135 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Pure helper functions for self-distillation loss computation."""
+
+import torch
+import torch.nn.functional as F
+
+from ...trainer.utils import selective_log_softmax
+
+
+def compute_divergence(
+ student_log_probs: torch.Tensor,
+ teacher_log_probs: torch.Tensor,
+ alpha: float,
+) -> torch.Tensor:
+ if alpha == 0.0:
+ kl = F.kl_div(student_log_probs, teacher_log_probs, reduction="none", log_target=True)
+ elif alpha == 1.0:
+ kl = F.kl_div(teacher_log_probs, student_log_probs, reduction="none", log_target=True)
+ else:
+ alpha_t = torch.tensor(alpha, dtype=student_log_probs.dtype, device=student_log_probs.device)
+ mixture = torch.logsumexp(
+ torch.stack([student_log_probs + torch.log(1 - alpha_t), teacher_log_probs + torch.log(alpha_t)]),
+ dim=0,
+ )
+ kl_teacher = F.kl_div(mixture, teacher_log_probs, reduction="none", log_target=True)
+ kl_student = F.kl_div(mixture, student_log_probs, reduction="none", log_target=True)
+ kl = torch.lerp(kl_student, kl_teacher, alpha)
+ return kl.sum(-1)
+
+
+def add_tail_bucket(log_probs: torch.Tensor) -> torch.Tensor:
+ """Append a bucket holding the leftover probability mass to a top-k log-prob support.
+
+ `log_probs` are true log-probabilities over a top-k subset, so they sum to the captured mass `P_topk <= 1`. This
+ appends one extra category equal to the tail mass `1 - P_topk`, yielding a distribution that sums to exactly 1.
+ """
+ log_s = torch.logsumexp(log_probs, dim=-1, keepdim=True)
+ log_s = torch.clamp(log_s, max=-1e-7)
+ tail_log = torch.log(-torch.expm1(log_s))
+ return torch.cat([log_probs, tail_log], dim=-1)
+
+
+def apply_importance_sampling_clipping(
+ per_token_loss: torch.Tensor,
+ student_log_probs: torch.Tensor,
+ old_log_probs: torch.Tensor,
+ clip_coeff: float,
+) -> torch.Tensor:
+ negative_approx_kl = (student_log_probs - old_log_probs).detach()
+ negative_approx_kl = torch.clamp(negative_approx_kl, min=-20.0, max=20.0)
+ ratio = torch.exp(negative_approx_kl).clamp(max=clip_coeff)
+ return per_token_loss * ratio
+
+
+def compute_topk_self_distillation_loss(
+ student_logits: torch.Tensor,
+ teacher_logits: torch.Tensor,
+ *,
+ distillation_topk: int,
+ distillation_alpha: float,
+ distillation_add_tail: bool,
+) -> torch.Tensor:
+ """Compute distillation loss on the student's top-k token support.
+
+ The student's top-k logits define the support. The teacher distribution is projected onto the same token indices.
+ The selected support is then either renormalized or augmented with a tail bucket before the divergence is computed.
+ """
+ student_logsumexp = torch.logsumexp(student_logits, dim=-1, keepdim=True)
+ topk_student_logits, topk_indices = torch.topk(student_logits, k=distillation_topk, dim=-1)
+ topk_student_log_probs = topk_student_logits - student_logsumexp
+
+ teacher_logsumexp = torch.logsumexp(teacher_logits, dim=-1, keepdim=True)
+ topk_teacher_logits = torch.gather(teacher_logits, dim=-1, index=topk_indices)
+ topk_teacher_log_probs = topk_teacher_logits - teacher_logsumexp
+
+ # Top-k log-probs sum to the captured mass P_topk <= 1; the rest (1 - P_topk) is the "tail".
+ if distillation_add_tail:
+ # Lump the tail into one bucket so the divergence approximates the full-vocab divergence.
+ topk_student_log_probs = add_tail_bucket(topk_student_log_probs)
+ topk_teacher_log_probs = add_tail_bucket(topk_teacher_log_probs)
+ else:
+ # Drop the tail and renormalize the top-k to sum to 1: divergence over the top-k conditional only.
+ topk_student_log_probs = topk_student_log_probs - torch.logsumexp(topk_student_log_probs, dim=-1, keepdim=True)
+ topk_teacher_log_probs = topk_teacher_log_probs - torch.logsumexp(topk_teacher_log_probs, dim=-1, keepdim=True)
+
+ return compute_divergence(topk_student_log_probs, topk_teacher_log_probs, distillation_alpha)
+
+
+def compute_full_logit_self_distillation_loss(
+ student_logits: torch.Tensor,
+ teacher_logits: torch.Tensor,
+ *,
+ distillation_alpha: float,
+) -> torch.Tensor:
+ """Compute full-vocabulary self-distillation loss between student and teacher logits."""
+ student_log_probs = torch.log_softmax(student_logits, dim=-1)
+ teacher_log_probs = torch.log_softmax(teacher_logits, dim=-1)
+ return compute_divergence(student_log_probs, teacher_log_probs, distillation_alpha)
+
+
+def compute_sampled_token_self_distillation_loss(
+ student_logits: torch.Tensor,
+ teacher_logits: torch.Tensor,
+ completion_ids: torch.Tensor,
+ *,
+ distillation_alpha: float,
+) -> torch.Tensor:
+ """Compute token-level self-distillation loss only on the sampled completion tokens.
+
+ This path compares student and teacher log-probabilities on the realized completion tokens rather than over a
+ larger token support.
+ """
+ if distillation_alpha != 1.0:
+ raise ValueError(
+ "Only reverse KL (alpha=1.0) is supported for token-level distillation when "
+ f"`distillation_mode='sampled_token'`, got alpha={distillation_alpha}"
+ )
+
+ student_per_token_logps = selective_log_softmax(student_logits, completion_ids)
+ teacher_per_token_logps = selective_log_softmax(teacher_logits, completion_ids)
+ log_ratio = student_per_token_logps - teacher_per_token_logps
+ return log_ratio.detach() * student_per_token_logps
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdft/sdft_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdft/sdft_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..b21e3dbc60c782e385bdac882913691285ee19d8
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdft/sdft_config.py
@@ -0,0 +1,472 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+from transformers import TrainingArguments
+
+from ...trainer.base_config import _BaseConfig
+
+
+@dataclass
+class SDFTConfig(_BaseConfig):
+ r"""
+ Configuration class for the [`SDFTTrainer`].
+
+ Parameters:
+ > Parameters that control the SDFT loss
+
+ distillation_alpha (`float`, *optional*, defaults to `0.5`):
+ Divergence interpolation coefficient for SDFT top-k logit distillation.
+ distillation_mode (`Literal["sampled_token", "full_logits", "topk_logits"]`, *optional*, defaults to `"topk_logits"`):
+ Distillation objective mode. SDFT defaults to top-k logit distillation.
+ distillation_topk (`int`, *optional*, defaults to `100`):
+ Number of top tokens used by the default SDFT top-k logit objective.
+ distillation_is_clip (`float`, *optional*, defaults to `2.0`):
+ Clipping coefficient for importance sampling in self-distillation. `None` disables clipping.
+ distillation_add_tail (`bool`, *optional*, defaults to `False`):
+ Whether to add a tail bucket for non-top-k probability mass.
+ num_loss_tokens_to_skip (`int`, *optional*, defaults to `0`):
+ Number of initial completion tokens to exclude from the distillation loss.
+
+ > Parameters that control the teacher
+
+ teacher_model_kind (`str`, *optional*, defaults to `"base"`):
+ Semantic teacher choice for SDFT. `base` uses the initial student, `live` uses the current student, and
+ `ema` uses an exponentially averaged teacher.
+ teacher_update_rate (`float`, *optional*, defaults to `0.05`):
+ EMA update rate used when `teacher_model_kind="ema"`. A value of `1.0` reduces the update to a hard
+ overwrite, periodically resyncing the teacher to the current student weights.
+ teacher_sync_steps (`int`, *optional*, defaults to `1`):
+ Number of optimizer steps between teacher updates.
+
+ > Parameters that control teacher-conditioned generation
+
+ generate_from_teacher (`bool`, *optional*, defaults to `False`):
+ Whether on-policy generation should use the teacher-conditioned prompt instead of the student prompt.
+ teacher_prompt_template (`str`, *optional*, defaults to `"{prompt}\n\n{privileged_context}"`):
+ Template used to combine the student prompt and privileged context into the teacher prompt.
+
+ > Parameters that control the model
+
+ model_init_kwargs (`dict[str, Any]`, *optional*):
+ Keyword arguments for `transformers.AutoModelForCausalLM.from_pretrained`, used when the `model` argument
+ of the `SDFTTrainer` is provided as a string.
+ trust_remote_code (`bool`, *optional*, defaults to `False`):
+ Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to
+ [`~transformers.AutoModelForCausalLM.from_pretrained`] and [`~transformers.AutoProcessor.from_pretrained`],
+ for both the student and teacher.
+ disable_dropout (`bool`, *optional*, defaults to `True`):
+ Whether to disable dropout in the student and teacher models.
+
+ > Parameters that control data preprocessing
+
+ remove_unused_columns (`bool`, *optional*, defaults to `False`):
+ Whether to only keep the columns required by the trainer in the dataset. Keep this to `False` if you
+ provide extra columns (such as `privileged_context`) that the trainer needs.
+ max_prompt_length (`int`, *optional*, defaults to `512`):
+ Maximum prompt length. Longer prompts are truncated from the left.
+ shuffle_dataset (`bool`, *optional*, defaults to `True`):
+ Whether to shuffle the training dataset.
+
+ > Parameters that control generation
+
+ num_generations (`int`, *optional*, defaults to `8`):
+ Number of generations to sample. The effective batch size (num_processes * per_device_batch_size *
+ gradient_accumulation_steps) must be evenly divisible by this value.
+ num_generations_eval (`int`, *optional*):
+ Number of generations to sample during evaluation. This allows using fewer generations during evaluation to
+ save computation. If `None`, uses the value of `num_generations`.
+ max_completion_length (`int`, *optional*, defaults to `256`):
+ Maximum length of the generated completion.
+ temperature (`float`, *optional*, defaults to `1.0`):
+ Temperature for sampling. The higher the temperature, the more random the completions.
+ top_p (`float`, *optional*, defaults to `1.0`):
+ Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. Set to 1.0
+ to consider all tokens.
+ top_k (`int`, *optional*, defaults to `0`):
+ Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, top-k-filtering is
+ disabled and all tokens are considered.
+ min_p (`float`, *optional*):
+ Minimum token probability, which will be scaled by the probability of the most likely token. It must be a
+ value between 0.0 and 1.0. Typical values are in the 0.01-0.2 range.
+ repetition_penalty (`float`, *optional*, defaults to `1.0`):
+ Float that penalizes new tokens based on whether they appear in the prompt and the generated text so far.
+ Values > 1.0 encourage the model to use new tokens, while values < 1.0 encourage the model to repeat
+ tokens.
+ cache_implementation (`str`, *optional*):
+ Implementation of the cache method for faster generation when use_vllm is set to False.
+ generation_kwargs (`dict[str, Any]`, *optional*):
+ Additional keyword arguments to pass to `GenerationConfig` (if using transformers) or `SamplingParams` (if
+ using vLLM) when sampling completions. This can be used to further customize the generation behavior, such
+ as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that conflict with the other generation
+ parameters (like `min_p`, `top_p`, etc.), they will override them.
+ chat_template_kwargs (`dict[str, Any]`, *optional*):
+ Additional keyword arguments to pass to the `apply_chat_template` function when generating completions.
+ ds3_gather_for_generation (`bool`, *optional*, defaults to `True`):
+ This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for generation,
+ improving generation speed. However, disabling this option allows training models that exceed the VRAM
+ capacity of a single GPU, albeit at the cost of slower generation. Disabling this option is not compatible
+ with vLLM generation.
+
+ > Parameters that control generation acceleration powered by vLLM
+
+ use_vllm (`bool`, *optional*, defaults to `False`):
+ Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for generation
+ instead of the default model.generate(). Requires `vllm` to be installed.
+ use_teacher_server (`bool`, *optional*, defaults to `False`):
+ Compute teacher logprobs from the running vLLM generation server instead of a local teacher forward. Only
+ supported for `teacher_model_kind='live'` with `use_vllm=True` and `vllm_mode='server'`, and
+ `distillation_mode` in {'sampled_token', 'topk_logits'} (the server returns the teacher's top-k logprobs,
+ not the full vocabulary; `topk_logits` distills over the teacher's own top-k support).
+ vllm_mode (`str`, *optional*, defaults to `"colocate"`):
+ Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `'server'` or
+ `'colocate'`. `'server'`: The trainer will send generation requests to a separate vLLM server. Make sure a
+ TRL vLLM server is running (start with `trl vllm-serve`). `'colocate'`: vLLM will run in the same process
+ and share the training GPUs. This avoids the need for a separate server but may cause resource contention
+ with training.
+ vllm_model_impl (`str`, *optional*, defaults to `"vllm"`):
+ Model implementation to use for vLLM. Must be one of `transformers` or `vllm`. `transformers`: Use the
+ `transformers` backend for model implementation. `vllm`: Use the `vllm` library for model implementation.
+ vllm_enable_sleep_mode (`bool`, *optional*, defaults to `False`):
+ Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory usage low, but
+ waking the engine adds host–device transfer latency.
+ vllm_server_base_url (`str`, *optional*):
+ Base URL for the vLLM server (e.g., 'http://localhost:8000'). If provided, `vllm_server_host` and
+ `vllm_server_port` are ignored.
+ vllm_server_host (`str`, *optional*, defaults to `"0.0.0.0"`):
+ Host of the vLLM server to connect to. Ignored if vllm_server_base_url is provided.
+ vllm_server_port (`int`, *optional*, defaults to `8000`):
+ Port of the vLLM server to connect to. Ignored if vllm_server_base_url is provided.
+ vllm_group_port (`int`, *optional*, defaults to `51216`):
+ Port number for the weight update group. This is used to communicate with the vLLM server. Unless the port
+ is occupied, there is no need to change it.
+ vllm_server_timeout (`float`, *optional*, defaults to `240.0`):
+ Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up after the
+ timeout, a `ConnectionError` is raised.
+ vllm_tensor_parallel_size (`int`, *optional*, defaults to `1`):
+ Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set to
+ `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when
+ launching the vLLM server via the `--vllm_tensor_parallel_size` flag.
+ vllm_gpu_memory_utilization (`float`, *optional*, defaults to `0.3`):
+ Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set to
+ `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when
+ launching the vLLM server via the `--vllm_gpu_memory_utilization` flag.
+ vllm_max_model_length (`int`, *optional*):
+ Context window for vLLM. Set it to at least the maximum prompt length in the dataset plus
+ `max_completion_length`; if omitted, it is inferred from the model config.
+
+ > Parameters that control the training
+
+ num_iterations (`int`, *optional*, defaults to `1`):
+ Number of iterations per batch (denoted as μ in the algorithm).
+ generation_batch_size (`int`, *optional*):
+ Batch size to use for generation. If `None`, it defaults to the effective training batch size:
+ `per_device_train_batch_size * num_processes * steps_per_generation`.
+ steps_per_generation (`int`, *optional*):
+ Number of steps per generation. If `None`, it defaults to `gradient_accumulation_steps`.
+ """
+
+ _VALID_DICT_FIELDS = TrainingArguments._VALID_DICT_FIELDS + ["model_init_kwargs"]
+
+ model_init_kwargs: dict[str, Any] | None = field(
+ default=None,
+ metadata={
+ "help": "Keyword arguments for `transformers.AutoModelForCausalLM.from_pretrained`, used when the `model` argument of the `SDFTTrainer` is provided as a string."
+ },
+ )
+ trust_remote_code: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. "
+ "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoProcessor.from_pretrained`, for both the "
+ "student and teacher."
+ },
+ )
+ disable_dropout: bool = field(
+ default=True,
+ metadata={"help": "Whether to disable dropout in the student and teacher models."},
+ )
+ remove_unused_columns: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to only keep the columns required by the trainer in the dataset. Keep this to `False` if you provide extra columns (such as `privileged_context`) that the trainer needs."
+ },
+ )
+ max_prompt_length: int | None = field(
+ default=512,
+ metadata={"help": "Maximum prompt length. Longer prompts are truncated from the left."},
+ )
+ num_generations: int = field(
+ default=8,
+ metadata={
+ "help": "Number of generations to sample. The effective batch size (num_processes * per_device_batch_size * gradient_accumulation_steps) must be evenly divisible by this value."
+ },
+ )
+ num_generations_eval: int | None = field(
+ default=None,
+ metadata={
+ "help": "Number of generations to sample during evaluation. This allows using fewer generations during evaluation to save computation. If `None`, uses the value of `num_generations`."
+ },
+ )
+ max_completion_length: int | None = field(
+ default=256,
+ metadata={"help": "Maximum length of the generated completion."},
+ )
+ ds3_gather_for_generation: bool = field(
+ default=True,
+ metadata={
+ "help": "This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for generation, improving generation speed. However, disabling this option allows training models that exceed the VRAM capacity of a single GPU, albeit at the cost of slower generation. Disabling this option is not compatible with vLLM generation."
+ },
+ )
+ shuffle_dataset: bool = field(
+ default=True,
+ metadata={"help": "Whether to shuffle the training dataset."},
+ )
+ generation_batch_size: int | None = field(
+ default=None,
+ metadata={
+ "help": "Batch size to use for generation. If `None`, it defaults to the effective training batch size: `per_device_train_batch_size * num_processes * steps_per_generation`."
+ },
+ )
+ steps_per_generation: int | None = field(
+ default=None,
+ metadata={"help": "Number of steps per generation. If `None`, it defaults to `gradient_accumulation_steps`."},
+ )
+ temperature: float = field(
+ default=1.0,
+ metadata={"help": "Temperature for sampling. The higher the temperature, the more random the completions."},
+ )
+ top_p: float = field(
+ default=1.0,
+ metadata={
+ "help": "Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. Set to 1.0 to consider all tokens."
+ },
+ )
+ top_k: int = field(
+ default=0,
+ metadata={
+ "help": "Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, top-k-filtering is disabled and all tokens are considered."
+ },
+ )
+ min_p: float | None = field(
+ default=None,
+ metadata={
+ "help": "Minimum token probability, which will be scaled by the probability of the most likely token. It must be a value between 0.0 and 1.0. Typical values are in the 0.01-0.2 range."
+ },
+ )
+ generation_kwargs: dict[str, Any] | None = field(
+ default=None,
+ metadata={
+ "help": "Additional keyword arguments to pass to `GenerationConfig` (if using transformers) or `SamplingParams` (if using vLLM) when sampling completions. This can be used to further customize the generation behavior, such as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that conflict with the other generation parameters (like `min_p`, `top_p`, etc.), they will override them."
+ },
+ )
+ chat_template_kwargs: dict[str, Any] | None = field(
+ default=None,
+ metadata={
+ "help": "Additional keyword arguments to pass to the `apply_chat_template` function when generating completions."
+ },
+ )
+ repetition_penalty: float = field(
+ default=1.0,
+ metadata={
+ "help": "Float that penalizes new tokens based on whether they appear in the prompt and the generated text so far. Values > 1.0 encourage the model to use new tokens, while values < 1.0 encourage the model to repeat tokens."
+ },
+ )
+ cache_implementation: str | None = field(
+ default=None,
+ metadata={"help": "Implementation of the cache method for faster generation when use_vllm is set to False."},
+ )
+ use_vllm: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for generation instead of the default model.generate(). Requires `vllm` to be installed."
+ },
+ )
+ use_teacher_server: bool = field(
+ default=False,
+ metadata={
+ "help": "Compute teacher logprobs from the running vLLM generation server instead of a local teacher "
+ "forward. Only supported for `teacher_model_kind='live'` with `use_vllm=True` and `vllm_mode='server'`, "
+ "and `distillation_mode` in {'sampled_token', 'topk_logits'} (the server returns the teacher's top-k "
+ "logprobs, not the full vocabulary; `topk_logits` distills over the teacher's own top-k support)."
+ },
+ )
+ vllm_mode: str = field(
+ default="colocate",
+ metadata={
+ "help": "Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `'server'` or `'colocate'`. `'server'`: The trainer will send generation requests to a separate vLLM server. Make sure a TRL vLLM server is running (start with `trl vllm-serve`). `'colocate'`: vLLM will run in the same process and share the training GPUs. This avoids the need for a separate server but may cause resource contention with training."
+ },
+ )
+ vllm_model_impl: str = field(
+ default="vllm",
+ metadata={
+ "help": "Model implementation to use for vLLM. Must be one of `transformers` or `vllm`. `transformers`: Use the `transformers` backend for model implementation. `vllm`: Use the `vllm` library for model implementation."
+ },
+ )
+ vllm_enable_sleep_mode: bool = field(
+ default=False,
+ metadata={
+ "help": "Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory usage low, but waking the engine adds host–device transfer latency."
+ },
+ )
+ vllm_server_base_url: str | None = field(
+ default=None,
+ metadata={
+ "help": "Base URL for the vLLM server (e.g., 'http://localhost:8000'). If provided, `vllm_server_host` and `vllm_server_port` are ignored."
+ },
+ )
+ vllm_server_host: str = field(
+ default="0.0.0.0",
+ metadata={"help": "Host of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."},
+ )
+ vllm_server_port: int = field(
+ default=8000,
+ metadata={"help": "Port of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."},
+ )
+ vllm_group_port: int = field(
+ default=51216,
+ metadata={
+ "help": "Port number for the weight update group. This is used to communicate with the vLLM server. Unless the port is occupied, there is no need to change it."
+ },
+ )
+ vllm_server_timeout: float = field(
+ default=240.0,
+ metadata={
+ "help": "Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up after the timeout, a `ConnectionError` is raised."
+ },
+ )
+ vllm_tensor_parallel_size: int = field(
+ default=1,
+ metadata={
+ "help": "Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when launching the vLLM server via the `--vllm_tensor_parallel_size` flag."
+ },
+ )
+ vllm_gpu_memory_utilization: float = field(
+ default=0.3,
+ metadata={
+ "help": "Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when launching the vLLM server via the `--vllm_gpu_memory_utilization` flag."
+ },
+ )
+ vllm_max_model_length: int | None = field(
+ default=None,
+ metadata={
+ "help": "Context window for vLLM. Set it to at least the maximum prompt length in the dataset plus `max_completion_length`; if omitted, it is inferred from the model config."
+ },
+ )
+ num_iterations: int = field(
+ default=1,
+ metadata={"help": "Number of iterations per batch (denoted as μ in the algorithm)."},
+ )
+ teacher_model_kind: str = field(
+ default="base",
+ metadata={
+ "help": "Semantic teacher choice for SDFT. `base` uses the initial student, `live` uses the current "
+ "student, and `ema` uses an exponentially averaged teacher."
+ },
+ )
+ teacher_update_rate: float = field(
+ default=0.05,
+ metadata={
+ "help": 'EMA update rate used when `teacher_model_kind="ema"`. A value of `1.0` reduces the update '
+ "to a hard overwrite, periodically resyncing the teacher to the current student weights."
+ },
+ )
+ teacher_sync_steps: int = field(
+ default=1,
+ metadata={"help": "Number of optimizer steps between teacher updates."},
+ )
+ distillation_alpha: float = field(
+ default=0.5,
+ metadata={"help": "Divergence interpolation coefficient for SDFT top-k logit distillation."},
+ )
+ distillation_mode: Literal["sampled_token", "full_logits", "topk_logits"] = field(
+ default="topk_logits",
+ metadata={"help": "Distillation objective mode. SDFT defaults to top-k logit distillation."},
+ )
+ distillation_topk: int | None = field(
+ default=100,
+ metadata={"help": "Number of top tokens used by the default SDFT top-k logit objective."},
+ )
+ distillation_is_clip: float | None = field(
+ default=2.0,
+ metadata={
+ "help": "Clipping coefficient for importance sampling in self-distillation. `None` disables clipping."
+ },
+ )
+ distillation_add_tail: bool = field(
+ default=False,
+ metadata={"help": "Whether to add a tail bucket for non-top-k probability mass."},
+ )
+ generate_from_teacher: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether on-policy generation should use the teacher-conditioned prompt instead of the student prompt."
+ },
+ )
+ teacher_prompt_template: str = field(
+ default="{prompt}\n\n{privileged_context}",
+ metadata={
+ "help": "Template used to combine the student prompt and privileged context into the teacher prompt."
+ },
+ )
+ num_loss_tokens_to_skip: int = field(
+ default=0,
+ metadata={"help": "Number of initial completion tokens to exclude from the distillation loss."},
+ )
+
+ def __post_init__(self):
+ super().__post_init__()
+ if self.distillation_mode == "sampled_token" and self.distillation_alpha != 1.0:
+ raise ValueError(
+ "`distillation_mode='sampled_token'` only supports reverse KL, so it requires "
+ f"`distillation_alpha=1.0`, got {self.distillation_alpha}."
+ )
+ num_processes = self.world_size
+ if self.generation_batch_size is None and self.steps_per_generation is None:
+ self.steps_per_generation = self.gradient_accumulation_steps
+ self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation
+ elif self.generation_batch_size is not None and self.steps_per_generation is None:
+ global_batch_size = self.per_device_train_batch_size * num_processes
+ if self.generation_batch_size % global_batch_size != 0:
+ raise ValueError(
+ f"generation_batch_size ({self.generation_batch_size}) must be divisible by the global batch size ({global_batch_size})."
+ )
+ self.steps_per_generation = self.generation_batch_size // global_batch_size
+ elif self.generation_batch_size is None and self.steps_per_generation is not None:
+ self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation
+ else:
+ raise ValueError("'generation_batch_size' and 'steps_per_generation' can not both be configured")
+
+ if self.generation_batch_size % self.num_generations != 0:
+ raise ValueError(
+ f"generation_batch_size ({self.generation_batch_size}) must be divisible by num_generations ({self.num_generations})."
+ )
+
+ if self.do_eval and self.eval_strategy != "no":
+ num_generations_eval = self.num_generations_eval or self.num_generations
+ if (self.per_device_eval_batch_size * num_processes) % num_generations_eval != 0:
+ raise ValueError(
+ f"The global eval batch size ({self.per_device_eval_batch_size} * {num_processes}) must be "
+ f"divisible by the number of generations used for evaluation ({num_generations_eval})."
+ )
+
+ if (
+ "{prompt}" not in self.teacher_prompt_template
+ or "{privileged_context}" not in self.teacher_prompt_template
+ ):
+ raise ValueError(
+ "teacher_prompt_template must contain both `{prompt}` and `{privileged_context}` placeholders"
+ )
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdft/sdft_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdft/sdft_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..1f68ad8467b8345bf67e509b17d8ae1f064c8857
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdft/sdft_trainer.py
@@ -0,0 +1,1311 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import inspect
+import textwrap
+from collections import defaultdict
+from contextlib import nullcontext
+from dataclasses import dataclass
+from functools import partial
+from typing import Any
+
+import datasets
+import torch
+from accelerate.logging import get_logger
+from accelerate.utils import is_peft_model
+from datasets import Dataset, IterableDataset
+from torch import nn
+from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+from torch.utils.data import DataLoader, Sampler
+from transformers import (
+ AutoProcessor,
+ GenerationConfig,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+ ProcessorMixin,
+ TrainerCallback,
+)
+from transformers.trainer_utils import seed_worker
+from transformers.utils import is_datasets_available, is_liger_kernel_available, is_peft_available
+
+from ...data_utils import is_conversational
+from ...models import prepare_deepspeed, prepare_fsdp, unwrap_model_for_generation
+from ...models.utils import _ForwardRedirection
+from ...trainer.base_trainer import _BaseTrainer
+from ...trainer.utils import (
+ RepeatSampler,
+ create_model_from_path,
+ disable_dropout_in_model,
+ get_config_model_id,
+ identity,
+ pad,
+ selective_log_softmax,
+ split_tensor_dict,
+ use_adapter,
+)
+from ..utils import prepare_peft_model
+from .loss_utils import (
+ add_tail_bucket,
+ apply_importance_sampling_clipping,
+ compute_divergence,
+ compute_full_logit_self_distillation_loss,
+ compute_sampled_token_self_distillation_loss,
+ compute_topk_self_distillation_loss,
+)
+from .sdft_config import SDFTConfig
+from .teacher_sync import PEFTAdapterEMACallback, SyncTeacherModelCallback, is_pure_lora_training
+
+
+if is_peft_available():
+ from peft import PeftConfig
+
+if is_liger_kernel_available():
+ from liger_kernel.chunked_loss import LigerFusedLinearJSDLoss
+
+
+logger = get_logger(__name__)
+
+
+TrainingBatch = dict[str, torch.Tensor | Any]
+
+
+def build_teacher_request_inputs(
+ input_ids: torch.Tensor,
+ attention_mask: torch.Tensor,
+ prompt_attention_mask: torch.Tensor,
+) -> tuple[list[list[int]], list[int], list[int]]:
+ """Trim padded batch tensors into per-sample (prompt+completion) sequences for teacher-server requests."""
+ if input_ids.shape != attention_mask.shape:
+ raise ValueError(
+ f"input_ids and attention_mask must have the same shape, got {input_ids.shape} and {attention_mask.shape}."
+ )
+
+ input_ids_cpu = input_ids.detach().cpu()
+ attention_mask_cpu = attention_mask.detach().cpu().bool()
+ prompt_lengths = prompt_attention_mask.detach().cpu().sum(dim=1).to(torch.long)
+
+ trimmed_input_ids: list[list[int]] = []
+ prompt_lengths_list: list[int] = []
+ completion_lengths_list: list[int] = []
+ for row, mask, prompt_length in zip(input_ids_cpu, attention_mask_cpu, prompt_lengths, strict=True):
+ trimmed_row = row[mask]
+ prompt_len = int(prompt_length.item())
+ if prompt_len < 0 or prompt_len > trimmed_row.numel():
+ raise ValueError(
+ f"Invalid prompt length {prompt_len} for trimmed sequence of length {trimmed_row.numel()}."
+ )
+ trimmed_input_ids.append(trimmed_row.tolist())
+ prompt_lengths_list.append(prompt_len)
+ completion_lengths_list.append(int(trimmed_row.numel()) - prompt_len)
+ return trimmed_input_ids, prompt_lengths_list, completion_lengths_list
+
+
+@dataclass
+class DistillationLogits:
+ """Aligned logits and masks used to compute a self-distillation objective."""
+
+ completion_ids: torch.Tensor
+ loss_mask: torch.Tensor
+ student_logits: torch.Tensor
+ teacher_logits: torch.Tensor
+
+
+def _extract_last_user_text(messages: list[dict[str, Any]]) -> str:
+ """Extract the text content from the last user message in a conversational prompt."""
+ last_message = messages[-1]
+ if last_message.get("role") != "user":
+ raise ValueError(
+ f"Self-distillation teacher prompt construction expects the conversation to end with a user turn, "
+ f"but the last message has role '{last_message.get('role')}'. "
+ f"Prompts ending with assistant prefills or tool turns are not supported."
+ )
+ content = last_message.get("content", "")
+ if isinstance(content, list):
+ return " ".join(part.get("text", "") for part in content if part.get("type") == "text")
+ return content
+
+
+class DemonstrationTeacherContextBuilder:
+ """Builds student and teacher contexts from prompts plus privileged context"""
+
+ def __init__(self, trainer):
+ self.trainer = trainer
+
+ def _stringify_privileged_context(self, privileged_context: Any) -> str:
+ if privileged_context is None:
+ raise ValueError(
+ "`privileged_context` must not be None for self-distillation teacher prompt construction."
+ )
+ if isinstance(privileged_context, str):
+ return privileged_context
+ if isinstance(privileged_context, list) and privileged_context and isinstance(privileged_context[0], dict):
+ chunks = []
+ for message in privileged_context:
+ content = message.get("content", "")
+ if isinstance(content, list):
+ text = " ".join(part.get("text", "") for part in content if part.get("type") == "text")
+ else:
+ text = str(content)
+ if text:
+ chunks.append(text)
+ return "\n".join(chunks)
+ return str(privileged_context)
+
+ def _compose_teacher_prompt(self, prompt: Any, privileged_context: Any) -> Any:
+ privileged_text = self._stringify_privileged_context(privileged_context)
+ if isinstance(prompt, list):
+ system_messages = prompt[:-1]
+ prompt_text = _extract_last_user_text(prompt)
+ teacher_text = self.trainer.args.teacher_prompt_template.format(
+ prompt=prompt_text,
+ privileged_context=privileged_text,
+ )
+ return system_messages + [{"role": "user", "content": teacher_text}]
+ return self.trainer.args.teacher_prompt_template.format(prompt=prompt, privileged_context=privileged_text)
+
+ def select_generation_prompts(self, prompts: list[Any], privileged_contexts: list[Any]) -> list[Any]:
+ return [
+ self._compose_teacher_prompt(prompt, privileged_context)
+ for prompt, privileged_context in zip(prompts, privileged_contexts, strict=True)
+ ]
+
+ def build(
+ self,
+ prompts: list[Any],
+ privileged_contexts: list[Any],
+ completion_ids: torch.Tensor,
+ completion_mask: torch.Tensor,
+ ) -> dict[str, torch.Tensor]:
+ teacher_prompts = [
+ self._compose_teacher_prompt(prompt, privileged_context)
+ for prompt, privileged_context in zip(prompts, privileged_contexts, strict=True)
+ ]
+ teacher_prompt_ids_list = self.trainer._tokenize_prompts(teacher_prompts)
+ device = completion_ids.device
+ teacher_prompt_ids = [torch.tensor(ids) for ids in teacher_prompt_ids_list]
+ teacher_prompt_mask = [torch.ones_like(ids, dtype=torch.long) for ids in teacher_prompt_ids]
+ teacher_prompt_ids = pad(
+ teacher_prompt_ids, padding_value=self.trainer._tokenizer.pad_token_id, padding_side="left"
+ ).to(device=device)
+ teacher_prompt_mask = pad(teacher_prompt_mask, padding_value=0, padding_side="left").to(device=device)
+ teacher_input_ids = torch.cat([teacher_prompt_ids, completion_ids], dim=1)
+ teacher_attention_mask = torch.cat([teacher_prompt_mask, completion_mask], dim=1)
+ return {
+ "teacher_input_ids": teacher_input_ids,
+ "teacher_attention_mask": teacher_attention_mask,
+ }
+
+
+class SDFTTrainer(_BaseTrainer):
+ """Trainer for SDFT-style on-policy self-distillation with explicit teacher prompts."""
+
+ _tag_names = ["trl", "sdft"]
+ _name = "SDFT"
+ config_cls = SDFTConfig
+ # docstyle-ignore
+ _paper = {
+ "title": "Self-Distillation Enables Continual Learning",
+ "id": "2601.19897",
+ "citation": textwrap.dedent("""\
+ @article{shenfeld2026selfdistillation,
+ title = {{Self-Distillation Enables Continual Learning}},
+ author = {Idan Shenfeld and Mehul Damani and Jonas H\\"ubotter and Pulkit Agrawal},
+ year = 2026,
+ eprint = {arXiv:2601.19897}
+ }"""),
+ }
+
+ def __init__(
+ self,
+ model: str | PreTrainedModel | nn.Module,
+ args: SDFTConfig | None = None,
+ train_dataset: Dataset | IterableDataset | None = None,
+ eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None,
+ processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None,
+ callbacks: list[TrainerCallback] | None = None,
+ optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None),
+ peft_config: PeftConfig | None = None,
+ ):
+ if isinstance(train_dataset, IterableDataset):
+ raise NotImplementedError("Iterable datasets are not yet supported in SDFTTrainer.")
+ if isinstance(eval_dataset, IterableDataset) or (
+ isinstance(eval_dataset, dict) and any(isinstance(ds, IterableDataset) for ds in eval_dataset.values())
+ ):
+ raise NotImplementedError("Iterable eval datasets are not yet supported in SDFTTrainer.")
+
+ self.num_loss_tokens_to_skip = args.num_loss_tokens_to_skip
+ self.teacher_context_builder = DemonstrationTeacherContextBuilder(self)
+
+ if train_dataset is None:
+ raise ValueError("`train_dataset` is required")
+
+ if isinstance(model, str):
+ model_init_kwargs = args.model_init_kwargs or {}
+ if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]:
+ model_init_kwargs["device_map"] = None
+ model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+ model = create_model_from_path(model, **model_init_kwargs)
+ elif args.model_init_kwargs is not None:
+ logger.warning(
+ "You passed `model_init_kwargs` to the self-distillation config, but `model` is already "
+ "instantiated. The `model_init_kwargs` will be ignored."
+ )
+
+ self.model_kwarg_keys = (
+ inspect.signature(model.forward).parameters.keys()
+ if not hasattr(model, "get_base_model")
+ else inspect.signature(model.get_base_model().forward).parameters.keys()
+ )
+
+ if peft_config is None and getattr(model, "peft_config", None) is not None:
+ logger.warning(
+ "The provided self-distillation student model already contains a PEFT adapter. "
+ "This setup is accepted but not directly supported. In particular, `teacher_model_kind='base'` "
+ "may refer to the underlying base weights rather than the exact initially loaded student state "
+ "including its adapter. For unambiguous teacher behavior, start from a merged/non-adapter model "
+ "or manage separate adapters explicitly."
+ )
+ if peft_config is not None:
+ if not is_peft_available():
+ raise ImportError(
+ "You passed `peft_config` but the `peft` library is not installed. "
+ "Install it with `pip install trl[peft]`."
+ )
+ if not isinstance(peft_config, PeftConfig):
+ raise TypeError(
+ f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), "
+ f"got {type(peft_config).__name__}."
+ )
+ if is_peft_model(model):
+ raise ValueError(
+ "You passed a `PeftModel` instance together with a `peft_config`. Pass either a base "
+ "model with `peft_config`, or a pre-wrapped PEFT model."
+ )
+ if peft_config is not None or (is_peft_available() and getattr(model, "peft_config", None) is not None):
+ model = prepare_peft_model(model, peft_config, args)
+
+ if processing_class is None:
+ processing_class = AutoProcessor.from_pretrained(
+ get_config_model_id(model.config),
+ truncation_side="left",
+ padding_side="left",
+ trust_remote_code=args.trust_remote_code,
+ )
+
+ if isinstance(processing_class, ProcessorMixin):
+ self._tokenizer = processing_class.tokenizer
+ elif isinstance(processing_class, PreTrainedTokenizerBase):
+ self._tokenizer = processing_class
+ else:
+ raise TypeError("The `processing_class` must be either a `PreTrainedTokenizerBase` or a `ProcessorMixin`")
+
+ if self._tokenizer.pad_token is None:
+ self._tokenizer.pad_token = self._tokenizer.eos_token
+
+ self.max_prompt_length = args.max_prompt_length
+ self.max_completion_length = args.max_completion_length
+ self.num_generations = args.num_generations
+ self.num_generations_eval = args.num_generations_eval or args.num_generations
+ self.num_iterations = args.num_iterations
+ self.shuffle_dataset = args.shuffle_dataset
+ self.temperature = args.temperature
+ self.generate_from_teacher = args.generate_from_teacher
+ self.use_vllm = args.use_vllm
+ self.chat_template_kwargs = args.chat_template_kwargs or {}
+ self._step = 0
+ self._buffered_inputs = None
+ self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)}
+
+ self.generation_kwargs = {
+ "max_new_tokens": self.max_completion_length,
+ "do_sample": True,
+ "pad_token_id": self._tokenizer.pad_token_id,
+ "bos_token_id": self._tokenizer.bos_token_id,
+ "eos_token_id": self._tokenizer.eos_token_id,
+ "temperature": args.temperature,
+ "top_p": args.top_p,
+ "top_k": args.top_k,
+ "min_p": args.min_p,
+ "repetition_penalty": args.repetition_penalty,
+ "cache_implementation": args.cache_implementation,
+ }
+ if args.generation_kwargs is not None:
+ self.generation_kwargs.update(args.generation_kwargs)
+ self.generation_config = GenerationConfig(**self.generation_kwargs, disable_compile=True)
+
+ if hasattr(model, "warnings_issued"):
+ model.warnings_issued["estimate_tokens"] = True
+
+ # Teacher logprobs from the running vLLM generation server (reuses the synced student weights) instead of a
+ # local teacher forward. MVP: `live` teacher only — the generation server holds the current student weights.
+ self.use_teacher_server = args.use_teacher_server
+ if self.use_teacher_server:
+ if not (args.use_vllm and args.vllm_mode == "server"):
+ raise ValueError(
+ "`use_teacher_server=True` requires `use_vllm=True` and `vllm_mode='server'`: teacher logprobs are "
+ "served by the same vLLM server used for generation."
+ )
+ if args.teacher_model_kind != "live":
+ raise ValueError(
+ "`use_teacher_server=True` only supports `teacher_model_kind='live'` (the generation server holds "
+ f"the current student weights), got {args.teacher_model_kind!r}."
+ )
+ if args.distillation_mode not in ("sampled_token", "topk_logits"):
+ raise ValueError(
+ "`use_teacher_server=True` only supports `distillation_mode` in {'sampled_token', 'topk_logits'}, "
+ f"got {args.distillation_mode!r}. The server returns the teacher's top-k logprobs, not the full "
+ "vocabulary, so `full_logits` is unavailable. Note `topk_logits` distills over the teacher's own "
+ "top-k support (the server cannot score the student's top-k indices)."
+ )
+ if args.use_liger_kernel:
+ raise ValueError(
+ "`use_teacher_server=True` is incompatible with `use_liger_kernel`: the server returns top-k "
+ "logprobs while the Liger fused loss needs full-vocabulary hidden states."
+ )
+ # Liger fused JSD loss for `full_logits`: same generalized JSD as `compute_divergence`, so alpha maps to beta.
+ self.use_liger_loss = False
+ if args.use_liger_kernel:
+ if not is_liger_kernel_available():
+ raise ImportError(
+ "Liger is required to use `use_liger_kernel` as the self-distillation loss. Run "
+ "`pip install liger-kernel`."
+ )
+ if args.distillation_mode != "full_logits":
+ raise ValueError(
+ "`use_liger_kernel` only supports `distillation_mode='full_logits'`, got "
+ f"{args.distillation_mode!r}. The fused JSD kernel operates on the full vocabulary and cannot "
+ "express the top-k support or sampled-token objectives."
+ )
+ if args.distillation_is_clip is not None:
+ raise ValueError(
+ "`use_liger_kernel` is incompatible with `distillation_is_clip`: the fused kernel does not expose "
+ "per-token losses for importance-sampling clipping."
+ )
+ self.liger_jsd_loss = LigerFusedLinearJSDLoss(
+ beta=args.distillation_alpha,
+ ignore_index=-100,
+ temperature=args.temperature,
+ compiled=False,
+ weight_hard_loss=0.0,
+ weight_soft_loss=1.0,
+ )
+ self._forward_redirection = _ForwardRedirection()
+ self.use_liger_loss = True
+
+ super().__init__(
+ model=model,
+ args=args,
+ data_collator=identity,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=processing_class,
+ callbacks=callbacks,
+ optimizers=optimizers,
+ compute_loss_func="non-None value to disable scaling",
+ )
+
+ self._last_loaded_step = -1 if self.use_vllm else 0
+ if self.use_vllm:
+ from ...generation.vllm_generation import VLLMGeneration
+
+ self.vllm_generation = VLLMGeneration(
+ model=self.model,
+ accelerator=self.accelerator,
+ processing_class=self.processing_class,
+ mode=args.vllm_mode,
+ server_base_url=args.vllm_server_base_url,
+ server_host=args.vllm_server_host,
+ server_port=args.vllm_server_port,
+ group_port=args.vllm_group_port,
+ server_timeout=args.vllm_server_timeout,
+ tensor_parallel_size=args.vllm_tensor_parallel_size,
+ gpu_memory_utilization=args.vllm_gpu_memory_utilization,
+ max_model_length=args.vllm_max_model_length,
+ max_num_seqs=args.per_device_train_batch_size
+ * args.vllm_tensor_parallel_size
+ * args.steps_per_generation,
+ enable_sleep_mode=args.vllm_enable_sleep_mode,
+ model_impl=args.vllm_model_impl,
+ repetition_penalty=args.repetition_penalty,
+ temperature=self.temperature,
+ top_p=args.top_p,
+ top_k=args.top_k,
+ min_p=args.min_p,
+ max_completion_length=self.max_completion_length,
+ logprobs=None,
+ generation_kwargs=args.generation_kwargs,
+ )
+
+ # Per-rank read-only client to the same generation server for teacher scoring (weights are synced there by
+ # `VLLMGeneration`; scoring needs no weight-update communicator). Mirrors the distillation trainer's
+ # `teacher_client`.
+ self.teacher_client = None
+ if self.use_teacher_server:
+ from ...generation.vllm_client import VLLMClient
+
+ base_url = args.vllm_server_base_url or f"http://{args.vllm_server_host}:{args.vllm_server_port}"
+ self.teacher_client = VLLMClient(base_url=base_url, connection_timeout=args.vllm_server_timeout)
+
+ if args.disable_dropout:
+ disable_dropout_in_model(self.model)
+
+ if hasattr(self.model, "add_model_tags"):
+ self.model.add_model_tags(self._tag_names)
+
+ self._setup_teacher_model()
+ self.model_accepts_loss_kwargs = False
+
+ def _set_signature_columns_if_needed(self):
+ if self._signature_columns is None:
+ self._signature_columns = ["prompt", "privileged_context"]
+
+ def _dispatch_self_distillation_callback(self, event_name: str, **payload) -> None:
+ for callback in self.callback_handler.callbacks:
+ callback_fn = getattr(callback, event_name, None)
+ if callback_fn is not None:
+ callback_fn(
+ args=self.args,
+ state=self.state,
+ control=self.control,
+ model=self.model,
+ processing_class=self.processing_class,
+ **payload,
+ )
+
+ def _setup_teacher_model(self) -> None:
+ """Prepare teacher state according to the semantic teacher choice.
+
+ Resolve `teacher_model_kind` × PEFT state into the effective teacher:
+
+ - `"live"` (any model):
+ Teacher is the student. No divergence, no callback.
+ - `"base"` + PEFT model:
+ Teacher reuses `self.model`; the base weights are recovered downstream by disabling the adapter via
+ `use_adapter` during teacher forward.
+ - `"base"` + non-PEFT model:
+ Teacher is a frozen deepcopy of the initial student (falls through to the copy branch below).
+ - `"ema"` + pure-LoRA training:
+ Teacher reuses `self.model`; a dedicated `"teacher"` LoRA adapter is attached and updated by
+ `PEFTAdapterEMACallback`. Teacher forward switches to that adapter downstream.
+ - `"ema"` (otherwise):
+ Teacher is a frozen deepcopy synchronized each step by `SyncTeacherModelCallback`.
+
+ Must be called after `super().__init__` so that `self.callback_handler` is available.
+ """
+
+ teacher_model_kind = self.args.teacher_model_kind
+
+ if teacher_model_kind == "live":
+ self.teacher_model = self.model
+ return
+
+ if teacher_model_kind == "base" and is_peft_model(self.model):
+ self.teacher_model = self.model
+ return
+
+ if self._use_peft_ema_teacher_adapter():
+ # Must run after super().__init__ so self.callback_handler exists.
+ self.add_callback(
+ PEFTAdapterEMACallback(
+ model=self.model,
+ teacher_adapter_name="teacher",
+ update_rate=self.args.teacher_update_rate,
+ sync_steps=self.args.teacher_sync_steps,
+ accelerator=self.accelerator,
+ )
+ )
+ self.teacher_model = self.model
+ return
+
+ if is_peft_model(self.model):
+ raise ValueError(
+ "`teacher_model_kind='ema'` with a non-pure-LoRA PEFT model is not supported: the separate EMA "
+ "teacher cannot be parameter-matched to the PEFT student. Use pure-LoRA training, a non-PEFT model, "
+ "or `teacher_model_kind` in {'live', 'base'}."
+ )
+
+ # Build the teacher from the model path (like the GRPO/DPO reference model) rather than deep-copying the
+ # student: under ZeRO-3 the student params are already sharded, so a deep copy would clone empty shards.
+ model_init_kwargs = self.args.model_init_kwargs or {}
+ if self.args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]:
+ model_init_kwargs["device_map"] = None
+ model_init_kwargs.setdefault("trust_remote_code", self.args.trust_remote_code)
+ self.teacher_model = create_model_from_path(get_config_model_id(self.model.config), **model_init_kwargs)
+ self.teacher_model.requires_grad_(False)
+ self.teacher_model.eval()
+ if self.is_deepspeed_enabled:
+ self.teacher_model = prepare_deepspeed(self.teacher_model, self.accelerator)
+ elif self.is_fsdp_enabled:
+ self.teacher_model = prepare_fsdp(self.teacher_model, self.accelerator)
+ else:
+ self.teacher_model = self.accelerator.prepare_model(self.teacher_model, evaluation_mode=True)
+
+ if teacher_model_kind == "ema":
+ self.add_callback(SyncTeacherModelCallback(teacher_model=self.teacher_model, accelerator=self.accelerator))
+
+ def _use_peft_ema_teacher_adapter(self) -> bool:
+ return self.args.teacher_model_kind == "ema" and is_pure_lora_training(self.model, self.accelerator)
+
+ def get_train_dataloader(self):
+ if self.train_dataset is None:
+ raise ValueError("Trainer: training requires a train_dataset.")
+
+ train_dataset = self.train_dataset
+ data_collator = self.data_collator
+ if is_datasets_available() and isinstance(train_dataset, datasets.Dataset):
+ train_dataset = self._remove_unused_columns(train_dataset, description="training")
+ else:
+ data_collator = self._get_collator_with_removed_columns(data_collator, description="training")
+
+ dataloader_params = {
+ "batch_size": self._train_batch_size * self.args.steps_per_generation,
+ "collate_fn": data_collator,
+ "num_workers": self.args.dataloader_num_workers,
+ "pin_memory": self.args.dataloader_pin_memory,
+ "persistent_workers": self.args.dataloader_persistent_workers,
+ }
+ if not isinstance(train_dataset, torch.utils.data.IterableDataset):
+ dataloader_params["sampler"] = self._get_train_sampler()
+ dataloader_params["drop_last"] = self.args.dataloader_drop_last
+ dataloader_params["worker_init_fn"] = partial(
+ seed_worker, num_workers=self.args.dataloader_num_workers, rank=self.args.process_index
+ )
+ dataloader_params["prefetch_factor"] = self.args.dataloader_prefetch_factor
+ return self.accelerator.prepare(DataLoader(train_dataset, **dataloader_params))
+
+ def _get_train_sampler(self, dataset=None) -> Sampler:
+ if dataset is None:
+ dataset = self.train_dataset
+ return RepeatSampler(
+ data_source=dataset,
+ mini_repeat_count=self.num_generations,
+ batch_size=self.args.generation_batch_size // self.num_generations,
+ repeat_count=self.num_iterations * self.args.steps_per_generation,
+ shuffle=self.shuffle_dataset,
+ seed=self.args.seed,
+ )
+
+ def _get_eval_sampler(self, eval_dataset) -> Sampler:
+ return RepeatSampler(
+ data_source=eval_dataset,
+ mini_repeat_count=self.num_generations_eval,
+ seed=self.args.seed,
+ )
+
+ def training_step(self, model, inputs, num_items_in_batch):
+ # Gather spans forward+backward: the fused JSD computes the lm_head grad in backward.
+ with self._get_liger_zero3_lm_head_gather_ctx(model):
+ output = super().training_step(model, inputs, num_items_in_batch)
+ self._step += 1
+ return output
+
+ def prediction_step(self, model, inputs, prediction_loss_only, ignore_keys=None):
+ if not isinstance(inputs, dict):
+ inputs = self._prepare_inputs(inputs)
+ with torch.no_grad():
+ with self.compute_loss_context_manager():
+ loss = self.compute_loss(model, inputs)
+ return loss.detach(), None, None
+
+ def _prepare_inputs(self, generation_batch):
+ """Return the per-step training batch, regenerating rollouts and buffering them for reuse in train mode.
+
+ In train mode, rollouts are generated once every `steps_per_generation * num_iterations` steps and split into
+ per-step slices reused until the next regeneration. In eval mode, every batch is freshly prepared.
+ """
+ mode = "train" if self.model.training else "eval"
+ if mode == "train":
+ generate_every = self.args.steps_per_generation * self.num_iterations
+ if self._step % generate_every == 0 or self._buffered_inputs is None:
+ buffered_batch = self._prepare_training_batch(generation_batch)
+ self._buffered_inputs = split_tensor_dict(buffered_batch, self.args.steps_per_generation)
+ self._dispatch_self_distillation_callback(
+ "on_generation_batch_built",
+ generate_every=generate_every,
+ steps_per_generation=self.args.steps_per_generation,
+ )
+ return self._buffered_inputs[self._step % self.args.steps_per_generation]
+ return self._prepare_training_batch(generation_batch)
+
+ def _prepare_training_batch(self, inputs: list[dict[str, Any]]) -> TrainingBatch:
+ """Sample student rollouts and construct teacher prompts"""
+ batch = self.sample_rollouts(inputs)
+ mode = "train" if self.model.training else "eval"
+ self._record_completion_metrics(mode, batch)
+ prompts = [example["prompt"] for example in inputs]
+ privileged_contexts = [example.get("privileged_context") for example in inputs]
+ teacher_batch = self.teacher_context_builder.build(
+ prompts,
+ privileged_contexts,
+ batch["completion_ids"],
+ batch["completion_mask"],
+ )
+ batch.update(
+ {
+ "teacher_input_ids": teacher_batch["teacher_input_ids"],
+ "teacher_attention_mask": teacher_batch["teacher_attention_mask"],
+ }
+ )
+
+ self._dispatch_self_distillation_callback(
+ "on_self_distillation_batch_prepared",
+ old_per_token_logps=batch.get("old_per_token_logps"),
+ prompt_ids=batch["prompt_ids"],
+ completion_ids=batch["completion_ids"],
+ teacher_input_ids=batch["teacher_input_ids"],
+ teacher_attention_mask=batch["teacher_attention_mask"],
+ )
+ return batch
+
+ def sample_rollouts(self, inputs: list[dict[str, Any]]) -> TrainingBatch:
+ """Generate completions for a batch of prompts and assemble the training batch."""
+ prompts = [example["prompt"] for example in inputs]
+ privileged_contexts = [example.get("privileged_context") for example in inputs]
+
+ student_prompt_ids_list = self._tokenize_prompts(prompts)
+ if self.generate_from_teacher:
+ generation_prompts = self.teacher_context_builder.select_generation_prompts(prompts, privileged_contexts)
+ generation_prompt_ids_list = self._tokenize_prompts(generation_prompts)
+ else:
+ generation_prompts = prompts
+ generation_prompt_ids_list = student_prompt_ids_list
+
+ self._dispatch_self_distillation_callback(
+ "on_generation_prompts_selected",
+ generation_prompts=generation_prompts,
+ generation_prompt_text=None,
+ )
+
+ _, completion_ids_list = self._generate(generation_prompt_ids_list)
+ device = self.accelerator.device
+ prompt_ids = [torch.tensor(ids) for ids in student_prompt_ids_list]
+ prompt_mask = [torch.ones_like(ids, dtype=torch.long) for ids in prompt_ids]
+ prompt_ids = pad(prompt_ids, padding_value=self._tokenizer.pad_token_id, padding_side="left").to(device=device)
+ prompt_mask = pad(prompt_mask, padding_value=0, padding_side="left").to(device=device)
+
+ completion_ids = [torch.tensor(ids) for ids in completion_ids_list]
+ completion_mask = [torch.ones_like(ids, dtype=torch.long) for ids in completion_ids]
+ completion_ids = pad(completion_ids, padding_value=self._tokenizer.pad_token_id, padding_side="right").to(
+ device=device
+ )
+ completion_mask = pad(completion_mask, padding_value=0, padding_side="right").to(device=device)
+
+ old_per_token_logps = None
+ if not self.generate_from_teacher:
+ old_per_token_logps = self._compute_rollout_logps(
+ prompt_ids=prompt_ids,
+ prompt_mask=prompt_mask,
+ completion_ids=completion_ids,
+ completion_mask=completion_mask,
+ )
+ batch: TrainingBatch = {
+ "prompt_ids": prompt_ids,
+ "prompt_mask": prompt_mask,
+ "completion_ids": completion_ids,
+ "completion_mask": completion_mask,
+ "raw_completion_lengths": torch.tensor(
+ [len(ids) for ids in completion_ids_list], device=device, dtype=torch.long
+ ),
+ }
+ if old_per_token_logps is not None:
+ batch["old_per_token_logps"] = old_per_token_logps
+ return batch
+
+ def _get_completion_ids_list(self, batch: TrainingBatch) -> list[list[int]]:
+ raw_completion_lengths = batch["raw_completion_lengths"].detach().cpu().tolist()
+ return [
+ ids[:length].tolist()
+ for ids, length in zip(batch["completion_ids"].detach().cpu(), raw_completion_lengths, strict=True)
+ ]
+
+ def _tokenize_prompts(self, prompts: list[Any]) -> list[list[int]]:
+ if is_conversational({"prompt": prompts[0]}):
+ tokenized = self.processing_class.apply_chat_template(
+ conversation=prompts,
+ add_generation_prompt=True,
+ tokenize=True,
+ return_dict=True,
+ **self.chat_template_kwargs,
+ )
+ prompt_ids = tokenized["input_ids"]
+ else:
+ prompt_ids = self.processing_class(text=prompts)["input_ids"]
+ if self.max_prompt_length is not None:
+ prompt_ids = [ids[-self.max_prompt_length :] for ids in prompt_ids]
+ return prompt_ids
+
+ def _generate(self, prompt_ids: list[list[int]]) -> tuple[list[list[int]], list[list[int]]]:
+ if self.use_vllm:
+ return self._generate_vllm(prompt_ids)
+ return self._generate_transformers(prompt_ids)
+
+ def _generate_vllm(self, prompt_ids: list[list[int]]) -> tuple[list[list[int]], list[list[int]]]:
+ if self.state.global_step != self._last_loaded_step:
+ self.vllm_generation.sync_weights()
+ self._last_loaded_step = self.state.global_step
+
+ mode = "train" if self.model.training else "eval"
+ num_generations = self.num_generations if mode == "train" else self.num_generations_eval
+ prompt_ids_out, completion_ids_list, _, _ = self.vllm_generation.generate(
+ prompts=prompt_ids,
+ images=None,
+ num_generations=num_generations,
+ )
+ return prompt_ids_out, completion_ids_list
+
+ def _generate_transformers(self, prompt_ids: list[list[int]]) -> tuple[list[list[int]], list[list[int]]]:
+ device = self.accelerator.device
+ prompt_tensors = [torch.tensor(ids) for ids in prompt_ids]
+ padded_ids = pad(prompt_tensors, padding_value=self._tokenizer.pad_token_id, padding_side="left").to(
+ device=device
+ )
+ attention_mask = pad([torch.ones_like(t) for t in prompt_tensors], padding_value=0, padding_side="left").to(
+ device=device
+ )
+ generate_inputs: dict[str, torch.Tensor | Any] = {"input_ids": padded_ids, "attention_mask": attention_mask}
+
+ with (
+ unwrap_model_for_generation(
+ self.model_wrapped,
+ self.accelerator,
+ gather_deepspeed3_params=self.args.ds3_gather_for_generation,
+ generation_kwargs=self.generation_kwargs,
+ ) as unwrapped_model,
+ torch.no_grad(),
+ FSDP.summon_full_params(self.model_wrapped, recurse=False) if self.is_fsdp_enabled else nullcontext(),
+ ):
+ prompt_completion_ids = unwrapped_model.generate(
+ **generate_inputs, generation_config=self.generation_config
+ )
+
+ prompt_length = generate_inputs["input_ids"].size(1)
+ completion_ids = prompt_completion_ids[:, prompt_length:]
+ is_eos = completion_ids == self._tokenizer.eos_token_id
+ eos_idx = torch.full((is_eos.size(0),), is_eos.size(1), dtype=torch.long, device=device)
+ eos_idx[is_eos.any(dim=1)] = is_eos.int().argmax(dim=1)[is_eos.any(dim=1)]
+ seq_idx = torch.arange(is_eos.size(1), device=device).expand(is_eos.size(0), -1)
+ completion_mask = (seq_idx <= eos_idx.unsqueeze(1)).int()
+ completion_ids_list = [
+ c[m].tolist() for c, m in zip(completion_ids.cpu(), completion_mask.bool().cpu(), strict=True)
+ ]
+ return prompt_ids, completion_ids_list
+
+ def _compute_rollout_logps(
+ self,
+ prompt_ids: torch.Tensor,
+ prompt_mask: torch.Tensor,
+ completion_ids: torch.Tensor,
+ completion_mask: torch.Tensor,
+ ) -> torch.Tensor | None:
+ generate_every = self.args.steps_per_generation * self.num_iterations
+ old_per_token_logps = None
+
+ if self.args.gradient_accumulation_steps % generate_every != 0:
+ prompt_completion_ids = torch.cat([prompt_ids, completion_ids], dim=1)
+ attention_mask = torch.cat([prompt_mask, completion_mask], dim=1)
+ logits_to_keep = completion_ids.size(1)
+ with torch.no_grad():
+ logits = self._forward_logits(
+ self.model,
+ prompt_completion_ids,
+ attention_mask,
+ logits_to_keep,
+ )
+ old_per_token_logps = selective_log_softmax(logits, completion_ids)
+
+ return old_per_token_logps
+
+ def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
+ if return_outputs:
+ raise ValueError("The SDFTTrainer does not support returning outputs")
+
+ if self.use_teacher_server:
+ loss = self._compute_server_distillation_loss(model, inputs)
+ elif self.use_liger_loss:
+ loss = self._compute_liger_loss(model, inputs)
+ else:
+ distillation_logits = self._compute_teacher_student_logits(model, self.teacher_model, inputs)
+ loss = self._compute_self_distillation_loss(model, inputs, distillation_logits)
+ accumulation_scale = self.current_gradient_accumulation_steps if self.model.training else 1.0
+ return loss / accumulation_scale
+
+ def _compute_self_distillation_loss(
+ self,
+ model,
+ inputs: TrainingBatch,
+ distillation_logits: DistillationLogits,
+ ) -> torch.Tensor:
+ """Compute the per-token distillation loss and aggregate by normalizing over sequence length.
+
+ Dispatches between three objectives based on `distillation_mode`:
+
+ - `"topk_logits"`: top-k approximation of the divergence, optionally with a tail bucket for the remaining
+ probability mass (`distillation_add_tail`).
+ - `"full_logits"`: full-vocab divergence.
+ - `"sampled_token"`: token-level (reverse-KL) distillation on sampled `completion_ids`.
+
+ When `distillation_is_clip` is set and `old_per_token_logps` are available, the loss is corrected by a clipped
+ importance-sampling ratio between the current student and the student at rollout time.
+ """
+ if distillation_logits.loss_mask.sum() == 0:
+ mode = "train" if model.training else "eval"
+ self._log_self_distillation_metric(mode, 0.0)
+ # Keep the zero loss attached to the student graph so backward produces zero gradients instead of stopping.
+ return distillation_logits.student_logits.sum() * 0.0
+
+ if self.args.distillation_mode == "topk_logits":
+ if self.args.distillation_topk is None:
+ raise ValueError("`distillation_mode='topk_logits'` requires `distillation_topk` to be set.")
+ per_token_loss = compute_topk_self_distillation_loss(
+ distillation_logits.student_logits,
+ distillation_logits.teacher_logits,
+ distillation_topk=self.args.distillation_topk,
+ distillation_alpha=self.args.distillation_alpha,
+ distillation_add_tail=self.args.distillation_add_tail,
+ )
+ elif self.args.distillation_mode == "full_logits":
+ per_token_loss = compute_full_logit_self_distillation_loss(
+ distillation_logits.student_logits,
+ distillation_logits.teacher_logits,
+ distillation_alpha=self.args.distillation_alpha,
+ )
+ elif self.args.distillation_mode == "sampled_token":
+ per_token_loss = compute_sampled_token_self_distillation_loss(
+ distillation_logits.student_logits,
+ distillation_logits.teacher_logits,
+ distillation_logits.completion_ids,
+ distillation_alpha=self.args.distillation_alpha,
+ )
+ else:
+ raise ValueError(
+ "distillation_mode must be one of: 'sampled_token', 'full_logits', 'topk_logits', "
+ f"got {self.args.distillation_mode!r}"
+ )
+
+ old_per_token_logps = inputs.get("old_per_token_logps")
+ if self.args.distillation_is_clip is not None and old_per_token_logps is not None:
+ student_per_token_logps = selective_log_softmax(
+ distillation_logits.student_logits,
+ distillation_logits.completion_ids,
+ )
+ per_token_loss = apply_importance_sampling_clipping(
+ per_token_loss,
+ student_per_token_logps,
+ old_per_token_logps,
+ self.args.distillation_is_clip,
+ )
+
+ loss = (per_token_loss * distillation_logits.loss_mask).sum(-1) / distillation_logits.loss_mask.sum(-1).clamp(
+ min=1.0
+ )
+ loss = loss.mean()
+
+ mode = "train" if model.training else "eval"
+ mean_distill_loss = (
+ per_token_loss * distillation_logits.loss_mask
+ ).sum() / distillation_logits.loss_mask.sum().clamp(min=1.0)
+ self._log_self_distillation_metric(
+ mode,
+ self.accelerator.gather(mean_distill_loss).mean().item(),
+ )
+ return loss
+
+ def _compute_server_distillation_loss(self, model, inputs: TrainingBatch) -> torch.Tensor:
+ """Distillation loss with teacher logprobs served by the vLLM generation server (`teacher_model_kind='live'`).
+
+ The student is forwarded locally (grad) for its logits; the teacher logprobs are fetched from the server (no
+ local teacher forward). `sampled_token` distills the realized token (reverse KL); `topk_logits` distills over
+ the teacher's own top-k support (the server cannot score the student's top-k indices).
+ """
+ # Buffered batches are reused across optimizer steps (`num_iterations > 1`), so the server weights can lag the
+ # live student; re-sync before scoring.
+ if self.state.global_step != self._last_loaded_step:
+ self.vllm_generation.sync_weights()
+ # Only the main process pushes weights to the server, so hold every rank here until the push completes;
+ # otherwise non-main ranks could score against half-updated weights.
+ self.accelerator.wait_for_everyone()
+ self._last_loaded_step = self.state.global_step
+
+ completion_ids = inputs["completion_ids"]
+ completion_mask = inputs["completion_mask"]
+ logits_to_keep = completion_ids.size(1)
+
+ # SDFT skips the first few completion tokens in the distillation loss to suppress teacher-prompt artifacts.
+ loss_mask = completion_mask
+ if self.num_loss_tokens_to_skip > 0:
+ token_positions = torch.arange(completion_mask.size(1), device=completion_mask.device).unsqueeze(0)
+ loss_mask = completion_mask * (token_positions >= self.num_loss_tokens_to_skip).long()
+
+ student_input_ids = torch.cat([inputs["prompt_ids"], completion_ids], dim=1)
+ student_attention_mask = torch.cat([inputs["prompt_mask"], completion_mask], dim=1)
+ student_logits = self._forward_logits(
+ model=model,
+ input_ids=student_input_ids,
+ attention_mask=student_attention_mask,
+ logits_to_keep=logits_to_keep,
+ )
+
+ mode = "train" if model.training else "eval"
+ teacher = self._get_teacher_token_logprobs_from_server(inputs, logits_to_keep)
+ # Padding positions come back as `-inf`; the masked-out positions are neutralized to finite values below so the
+ # divergence does not leak `+inf` through them (mirrors the distillation trainer).
+ required = loss_mask.bool()
+ student_per_token_logps = selective_log_softmax(student_logits, completion_ids)
+
+ teacher_per_token_logps = teacher["actual_logprobs"]
+ if (required & ~torch.isfinite(teacher_per_token_logps)).any():
+ raise ValueError("Teacher server returned no logprob for a required completion token.")
+ teacher_per_token_logps = torch.where(
+ required, teacher_per_token_logps, torch.zeros_like(teacher_per_token_logps)
+ )
+
+ # Diagnostic for disagreement between local student scores and server teacher scores on realized tokens.
+ # Sudden jumps can indicate stale server weights or numerical drift.
+ abs_diff = ((student_per_token_logps.detach() - teacher_per_token_logps).abs() * loss_mask).sum() / (
+ loss_mask.sum().clamp(min=1.0)
+ )
+ self._metrics[mode]["self_distillation/server_logprob_abs_diff"].append(
+ self.accelerator.gather(abs_diff).mean().item()
+ )
+
+ if self.args.distillation_mode == "sampled_token":
+ # Reverse-KL token-level objective, matching `compute_sampled_token_self_distillation_loss`.
+ per_token_loss = (student_per_token_logps - teacher_per_token_logps).detach() * student_per_token_logps
+ else:
+ teacher_topk_logps = teacher["topk_logprobs"]
+ teacher_topk_ids = teacher["topk_token_ids"]
+ # Project the student onto the teacher's top-k support, then renormalize (or add a tail bucket) before the
+ # divergence, matching `compute_topk_self_distillation_loss` on the teacher's support.
+ keep = required.unsqueeze(-1)
+ student_topk_logps = torch.gather(
+ torch.log_softmax(student_logits, dim=-1), dim=-1, index=teacher_topk_ids
+ )
+ student_topk_logps = torch.where(keep, student_topk_logps, torch.zeros_like(student_topk_logps))
+ teacher_topk_logps = torch.where(keep, teacher_topk_logps, torch.zeros_like(teacher_topk_logps))
+ if self.args.distillation_add_tail:
+ student_topk_logps = add_tail_bucket(student_topk_logps)
+ teacher_topk_logps = add_tail_bucket(teacher_topk_logps)
+ else:
+ student_topk_logps = student_topk_logps - torch.logsumexp(student_topk_logps, dim=-1, keepdim=True)
+ teacher_topk_logps = teacher_topk_logps - torch.logsumexp(teacher_topk_logps, dim=-1, keepdim=True)
+ per_token_loss = compute_divergence(student_topk_logps, teacher_topk_logps, self.args.distillation_alpha)
+
+ old_per_token_logps = inputs.get("old_per_token_logps")
+ if self.args.distillation_is_clip is not None and old_per_token_logps is not None:
+ per_token_loss = apply_importance_sampling_clipping(
+ per_token_loss, student_per_token_logps, old_per_token_logps, self.args.distillation_is_clip
+ )
+
+ loss = (per_token_loss * loss_mask).sum(-1) / loss_mask.sum(-1).clamp(min=1.0)
+ loss = loss.mean()
+ mean_distill_loss = (per_token_loss * loss_mask).sum() / loss_mask.sum().clamp(min=1.0)
+ self._log_self_distillation_metric(mode, self.accelerator.gather(mean_distill_loss).mean().item())
+ return loss
+
+ def _get_teacher_token_logprobs_from_server(
+ self, inputs: TrainingBatch, logits_to_keep: int
+ ) -> dict[str, torch.Tensor]:
+ """Per-token teacher logprobs from the vLLM server.
+
+ Returns a dict with `actual_logprobs` (`(B, T)`, the realized-token logprob for reverse KL) and `topk_logprobs`
+ / `topk_token_ids` (`(B, T, K)`, the teacher's top-k support for top-k logit distillation). Completions are
+ right-padded, so server values fill the leading positions of each row and the trailing padding keeps the `-inf`
+ / `0` sentinels (neutralized by the caller).
+ """
+ import numpy as np
+
+ teacher_input_ids = inputs["teacher_input_ids"]
+ teacher_attention_mask = inputs["teacher_attention_mask"]
+ device = teacher_input_ids.device
+ batch_size = teacher_input_ids.size(0)
+ prompt_attention_mask = teacher_attention_mask[:, : teacher_attention_mask.size(1) - logits_to_keep]
+ if self.args.distillation_mode == "topk_logits" and self.args.distillation_topk is None:
+ raise ValueError("`distillation_mode='topk_logits'` requires `distillation_topk` to be set.")
+ top_logprobs = self.args.distillation_topk if self.args.distillation_mode == "topk_logits" else 1
+
+ sequences, prompt_lengths, _ = build_teacher_request_inputs(
+ teacher_input_ids, teacher_attention_mask, prompt_attention_mask
+ )
+ result = self.teacher_client.get_sequence_logprobs(
+ sequences=sequences,
+ prompt_lengths=prompt_lengths,
+ top_logprobs=top_logprobs,
+ temperature=self.temperature,
+ )
+
+ actual = np.full((batch_size, logits_to_keep), float("-inf"), dtype=np.float32)
+ topk = np.full((batch_size, logits_to_keep, top_logprobs), float("-inf"), dtype=np.float32)
+ topk_ids = np.zeros((batch_size, logits_to_keep, top_logprobs), dtype=np.int64)
+ for i in range(batch_size):
+ seq_actual = result["actual_logprobs"][i]
+ n = min(len(seq_actual), logits_to_keep)
+ if n:
+ actual[i, :n] = np.array(seq_actual, dtype=np.float32)[:n, 0]
+ topk[i, :n] = np.array(result["logprobs"][i], dtype=np.float32)[:n]
+ topk_ids[i, :n] = np.array(result["logprob_token_ids"][i], dtype=np.int64)[:n]
+ return {
+ "actual_logprobs": torch.from_numpy(actual).to(device),
+ "topk_logprobs": torch.from_numpy(topk).to(device),
+ "topk_token_ids": torch.from_numpy(topk_ids).to(device),
+ }
+
+ def _compute_teacher_student_logits(
+ self,
+ model,
+ teacher_model,
+ inputs: TrainingBatch,
+ ) -> DistillationLogits:
+ """Compute the per-token logits of the student and teacher over the completion tokens.
+
+ The student is forwarded on its own input (original prompt plus the sampled completion) while the teacher is
+ forwarded on its input (prompt, privileged context, and the same completion). Both sets of logits are aligned
+ to the completion tokens so they can be compared position-by-position in the distillation loss.
+
+ The teacher forward runs under `torch.no_grad()` and the context resolved by
+ `_get_teacher_context_for_self_distillation`, which routes it to the correct weights.
+ """
+ prompt_ids = inputs["prompt_ids"]
+ prompt_mask = inputs["prompt_mask"]
+ completion_ids = inputs["completion_ids"]
+ completion_mask = inputs["completion_mask"]
+ logits_to_keep = completion_ids.size(1)
+
+ # SDFT skips the first few completion tokens in the distillation loss to suppress teacher-prompt artifacts.
+ loss_mask = completion_mask
+ if self.num_loss_tokens_to_skip > 0:
+ token_positions = torch.arange(completion_mask.size(1), device=completion_mask.device).unsqueeze(0)
+ loss_mask = completion_mask * (token_positions >= self.num_loss_tokens_to_skip).long()
+
+ student_input_ids = torch.cat([prompt_ids, completion_ids], dim=1)
+ student_attention_mask = torch.cat([prompt_mask, completion_mask], dim=1)
+ student_logits = self._forward_logits(
+ model=model,
+ input_ids=student_input_ids,
+ attention_mask=student_attention_mask,
+ logits_to_keep=logits_to_keep,
+ )
+
+ with torch.no_grad(), self._get_teacher_context_for_self_distillation():
+ teacher_logits = self._forward_logits(
+ model=teacher_model,
+ input_ids=inputs["teacher_input_ids"],
+ attention_mask=inputs["teacher_attention_mask"],
+ logits_to_keep=logits_to_keep,
+ )
+
+ return DistillationLogits(
+ completion_ids=completion_ids,
+ loss_mask=loss_mask,
+ student_logits=student_logits,
+ teacher_logits=teacher_logits,
+ )
+
+ def _forward_logits(
+ self,
+ model,
+ input_ids: torch.Tensor,
+ attention_mask: torch.Tensor,
+ logits_to_keep: int,
+ ) -> torch.Tensor:
+ """Forward the model and return temperature-scaled logits aligned to the completion tokens."""
+ model_inputs = {
+ "input_ids": input_ids,
+ "attention_mask": attention_mask,
+ "use_cache": False,
+ }
+ if "logits_to_keep" in self.model_kwarg_keys:
+ model_inputs["logits_to_keep"] = logits_to_keep + 1
+
+ logits = model(**model_inputs).logits
+ logits = logits[:, :-1, :]
+ logits = logits[:, -logits_to_keep:, :]
+ return logits / self.temperature
+
+ def _compute_liger_loss(self, model, inputs: TrainingBatch) -> torch.Tensor:
+ """`full_logits` distillation via the Liger fused JSD kernel: forwards the base models for hidden states and
+ fuses the lm_head projection with the divergence, never materializing the full-vocab logits.
+
+ Each model is forwarded through its own wrapper via `_forward_redirection` so FSDP2/DeepSpeed materialize the
+ sharded params during the unwrapped base forward. The fused kernel needs both lm_head weights live at once, so
+ the frozen teacher weight is captured while the teacher is materialized and handed to the student pass.
+ """
+ logits_to_keep = inputs["completion_ids"].size(1)
+ completion_mask = inputs["completion_mask"]
+ loss_mask = completion_mask
+ if self.num_loss_tokens_to_skip > 0:
+ token_positions = torch.arange(completion_mask.size(1), device=completion_mask.device).unsqueeze(0)
+ loss_mask = completion_mask * (token_positions >= self.num_loss_tokens_to_skip).long()
+
+ unwrapped_student = self.accelerator.unwrap_model(model)
+ unwrapped_teacher = self.accelerator.unwrap_model(self.teacher_model)
+
+ with torch.no_grad(), self._get_teacher_context_for_self_distillation():
+ teacher_hidden, teacher_weight, teacher_bias = self._forward_redirection(
+ self.teacher_model,
+ unwrapped_teacher,
+ self._liger_teacher_side,
+ unwrapped_teacher,
+ inputs,
+ logits_to_keep,
+ )
+
+ return self._forward_redirection(
+ model,
+ unwrapped_student,
+ self._liger_student_loss,
+ unwrapped_student,
+ inputs,
+ logits_to_keep,
+ loss_mask,
+ teacher_hidden,
+ teacher_weight,
+ teacher_bias,
+ )
+
+ def _liger_teacher_side(self, teacher, inputs: TrainingBatch, logits_to_keep: int):
+ """Teacher hidden states + frozen lm_head weight, captured while the teacher params are materialized."""
+ hidden = teacher.get_decoder()(
+ input_ids=inputs["teacher_input_ids"],
+ attention_mask=inputs["teacher_attention_mask"],
+ use_cache=False,
+ ).last_hidden_state
+ hidden = hidden[:, :-1][:, -logits_to_keep:]
+ head = teacher.get_output_embeddings()
+ # Clone so the weight survives re-sharding once this forward context exits.
+ weight = head.weight.detach().clone()
+ bias = head.bias.detach().clone() if head.bias is not None else None
+ return hidden, weight, bias
+
+ def _liger_student_loss(
+ self,
+ student,
+ inputs: TrainingBatch,
+ logits_to_keep,
+ loss_mask,
+ teacher_hidden,
+ teacher_weight,
+ teacher_bias,
+ ):
+ student_input_ids = torch.cat([inputs["prompt_ids"], inputs["completion_ids"]], dim=1)
+ student_attention_mask = torch.cat([inputs["prompt_mask"], inputs["completion_mask"]], dim=1)
+ student_hidden = student.get_decoder()(
+ input_ids=student_input_ids,
+ attention_mask=student_attention_mask,
+ use_cache=False,
+ ).last_hidden_state
+ # Align hidden states to the completion-predicting positions, matching `_forward_logits`.
+ student_hidden = student_hidden[:, :-1][:, -logits_to_keep:]
+
+ # `ignore_index` masks non-response positions; the token values only feed the disabled hard-CE term.
+ completion_ids = inputs["completion_ids"]
+ true_labels = torch.where(loss_mask.bool(), completion_ids, torch.full_like(completion_ids, -100))
+
+ student_head = student.get_output_embeddings()
+ # Per-sequence then batch mean (grpo), matching the non-Liger path: the fused kernel reduces by total tokens
+ # (bnpo), so we call it per sequence and average.
+ seq_losses = [
+ self.liger_jsd_loss(
+ student_input=student_hidden[i],
+ student_weight=student_head.weight,
+ teacher_input=teacher_hidden[i],
+ teacher_weight=teacher_weight,
+ true_labels=true_labels[i],
+ student_bias=student_head.bias,
+ teacher_bias=teacher_bias,
+ )
+ for i in range(student_hidden.size(0))
+ ]
+ loss = torch.stack(seq_losses).mean()
+
+ mode = "train" if student.training else "eval"
+ self._log_self_distillation_metric(mode, self.accelerator.gather(loss.detach()).mean().item())
+ return loss
+
+ def _get_liger_zero3_lm_head_gather_ctx(self, model):
+ """Gather the sharded student/teacher lm_head weights for the fused matmul under ZeRO-3. Liger reads
+ `lm_head.weight` by attribute, so the gather hook never fires; the decoder forward gathers itself. No-op
+ outside ZeRO-3."""
+ if not self.use_liger_loss:
+ return nullcontext()
+
+ deepspeed_plugin = self.accelerator.state.deepspeed_plugin
+ if deepspeed_plugin is None or deepspeed_plugin.zero_stage != 3:
+ return nullcontext()
+
+ import deepspeed
+
+ unwrapped_student = self.accelerator.unwrap_model(model)
+ unwrapped_teacher = self.accelerator.unwrap_model(self.teacher_model)
+ student_head = unwrapped_student.get_output_embeddings()
+ teacher_head = unwrapped_teacher.get_output_embeddings()
+ params = [student_head.weight, teacher_head.weight]
+ if student_head.bias is not None:
+ params.append(student_head.bias)
+ if teacher_head.bias is not None:
+ params.append(teacher_head.bias)
+ return deepspeed.zero.GatheredParameters(params, modifier_rank=None)
+
+ def _get_teacher_context_for_self_distillation(self):
+ """Return the context manager that routes the teacher forward to the correct weights.
+
+ For non-PEFT models this is a no-op. For PEFT models:
+
+ - `teacher_model_kind == "base"`: disable the student adapter so the teacher forward uses the base weights.
+ - `teacher_model_kind == "ema"` under pure-LoRA training: switch to the `"teacher"` LoRA adapter.
+ - otherwise: no-op; the teacher is a separate deepcopy.
+ """
+ teacher_model_kind = self.args.teacher_model_kind
+ if not is_peft_model(self.model):
+ return nullcontext()
+
+ target_model = self.accelerator.unwrap_model(self.teacher_model)
+
+ if teacher_model_kind == "base":
+ return use_adapter(target_model, adapter_name=None)
+ if teacher_model_kind == "ema" and self._use_peft_ema_teacher_adapter():
+ return use_adapter(target_model, adapter_name="teacher")
+ return nullcontext()
+
+ def _record_completion_metrics(self, mode: str, batch: TrainingBatch) -> None:
+ device = self.accelerator.device
+ completion_ids_list = self._get_completion_ids_list(batch)
+ agg_completion_lengths = self.accelerator.gather(batch["raw_completion_lengths"])
+ self._metrics[mode]["completions/mean_length"].append(agg_completion_lengths.float().mean().item())
+ self._metrics[mode]["completions/min_length"].append(agg_completion_lengths.float().min().item())
+ self._metrics[mode]["completions/max_length"].append(agg_completion_lengths.float().max().item())
+
+ eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id]
+ is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids_list], device=device)
+ agg_is_truncated = self.accelerator.gather(is_truncated)
+ self._metrics[mode]["completions/clipped_ratio"].append(agg_is_truncated.float().mean().item())
+ term_completion_lengths = agg_completion_lengths[~agg_is_truncated]
+ if len(term_completion_lengths) == 0:
+ term_completion_lengths = torch.zeros(1, device=device)
+ self._metrics[mode]["completions/mean_terminated_length"].append(term_completion_lengths.float().mean().item())
+ self._metrics[mode]["completions/min_terminated_length"].append(term_completion_lengths.float().min().item())
+ self._metrics[mode]["completions/max_terminated_length"].append(term_completion_lengths.float().max().item())
+
+ def _log_self_distillation_metric(self, mode: str, value: float) -> None:
+ metric_prefix = self._name.lower().replace(" ", "_")
+ self._metrics[mode]["self_distillation/distillation_loss"].append(value)
+ self._metrics[mode][f"{metric_prefix}/distillation_loss"].append(value)
+
+ def log(self, logs: dict[str, float], start_time: float | None = None) -> None:
+ mode = "train" if self.model.training else "eval"
+ metrics = {k: sum(v) / len(v) for k, v in self._metrics[mode].items() if v}
+ if mode == "eval":
+ metrics = {f"eval_{k}": v for k, v in metrics.items()}
+ logs = {**logs, **metrics}
+ super().log(logs, start_time)
+ self._metrics[mode].clear()
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdft/teacher_sync.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdft/teacher_sync.py
new file mode 100644
index 0000000000000000000000000000000000000000..8fb0f751a0bb5f4ae69ce9d201b29c09263bf21c
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdft/teacher_sync.py
@@ -0,0 +1,184 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+
+import torch
+from accelerate.utils import is_peft_model
+from transformers import (
+ TrainerCallback,
+ TrainerControl,
+ TrainerState,
+ TrainingArguments,
+)
+
+from ...trainer.callbacks import SyncRefModelCallback
+
+
+logger = logging.getLogger(__name__)
+
+
+def is_pure_lora_training(model, accelerator=None) -> bool:
+ """Return `True` when the active adapter is LoRA and every trainable parameter is a LoRA parameter."""
+ if not is_peft_model(model):
+ return False
+
+ if accelerator is not None:
+ model = accelerator.unwrap_model(model)
+
+ adapter_name = model.active_adapter
+ if adapter_name is None:
+ adapter_name = "default"
+ adapter_config = model.peft_config.get(adapter_name)
+ peft_type = adapter_config.peft_type
+ if peft_type is None or str(peft_type).split(".")[-1] != "LORA":
+ return False
+
+ for name, param in model.named_parameters():
+ if param.requires_grad and "lora_" not in name:
+ return False
+ return True
+
+
+class SyncTeacherModelCallback(SyncRefModelCallback):
+ """Synchronize an EMA teacher model with the student model on each configured sync step."""
+
+ def __init__(self, teacher_model, accelerator=None):
+ super().__init__(ref_model=teacher_model, accelerator=accelerator)
+
+ def on_step_end(self, args, state, control, **kwargs):
+ model = kwargs["model"]
+ if self.ref_model is not None and state.global_step % args.teacher_sync_steps == 0:
+ if self.accelerator:
+ model = self.accelerator.unwrap_model(model)
+ self.sync_target_model(model, self.ref_model, args.teacher_update_rate)
+
+
+class PEFTAdapterEMACallback(TrainerCallback):
+ """
+ Callback that maintains an EMA copy of PEFT adapter weights for use as a teacher model in self-distillation.
+
+ The callback creates a secondary adapter ("teacher") with zero-initialized weights and maintains shadow weights
+ that are updated via exponential moving average: `teacher_weight = (1-α) * teacher_weight + α * student_weight`
+
+ Usage:
+ ```python
+ trainer.add_callback(
+ PEFTAdapterEMACallback(
+ model=model,
+ teacher_adapter_name="teacher",
+ update_rate=0.05,
+ )
+ )
+ ```
+ """
+
+ def __init__(
+ self,
+ model,
+ teacher_adapter_name: str = "teacher",
+ update_rate: float = 0.05,
+ sync_steps: int = 1,
+ accelerator=None,
+ ):
+ self.model = model
+ self.teacher_adapter_name = teacher_adapter_name
+ self.update_rate = update_rate
+ self.sync_steps = sync_steps
+ self.accelerator = accelerator
+ self.shadow_weights: dict[str, torch.Tensor] | None = None
+ self.teacher_adapter_config = None
+ self._initialized = False
+
+ def _get_student_state_dict(self):
+ """Get student adapter state dict using PEFT keys (without adapter name)."""
+ from peft import get_peft_model_state_dict
+
+ if self.accelerator is not None:
+ model = self.accelerator.unwrap_model(self.model)
+ else:
+ model = self.model
+ return get_peft_model_state_dict(model)
+
+ def _initialize_teacher_adapter(self):
+ """Create teacher adapter with zero weights initialized from student adapter."""
+ from peft import get_peft_model_state_dict, set_peft_model_state_dict
+
+ if self._initialized:
+ return
+
+ if self.accelerator is not None:
+ model = self.accelerator.unwrap_model(self.model)
+ else:
+ model = self.model
+
+ adapter_name = model.active_adapter
+ if adapter_name is None:
+ adapter_name = "default"
+
+ self.teacher_adapter_config = model.peft_config.get(adapter_name)
+
+ student_state = get_peft_model_state_dict(model)
+
+ teacher_state = {k: torch.zeros_like(v) for k, v in student_state.items()}
+
+ model.add_adapter(self.teacher_adapter_name, self.teacher_adapter_config)
+
+ model.set_adapter(self.teacher_adapter_name)
+ set_peft_model_state_dict(model, teacher_state, adapter_name=self.teacher_adapter_name)
+
+ model.set_adapter(adapter_name)
+
+ self.shadow_weights = {k: v.clone().zero_() for k, v in teacher_state.items()}
+
+ self._initialized = True
+ logger.info(f"Initialized PEFT adapter EMA teacher with adapter name: {self.teacher_adapter_name}")
+
+ @torch.no_grad()
+ def on_step_end(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs):
+ if state.global_step % self.sync_steps != 0:
+ return
+
+ if not self._initialized:
+ self._initialize_teacher_adapter()
+
+ if self.shadow_weights is None:
+ return
+
+ if self.accelerator is None and "accelerator" in kwargs:
+ self.accelerator = kwargs["accelerator"]
+
+ student_state = self._get_student_state_dict()
+
+ for key, student_param in student_state.items():
+ if key in self.shadow_weights:
+ shadow = self.shadow_weights[key]
+ shadow.data = (1 - self.update_rate) * shadow.data + self.update_rate * student_param.data
+
+ from peft import set_peft_model_state_dict
+
+ if self.accelerator is not None:
+ unwrapped_model = self.accelerator.unwrap_model(self.model)
+ else:
+ unwrapped_model = self.model
+
+ original_adapter = unwrapped_model.active_adapter
+ unwrapped_model.set_adapter(self.teacher_adapter_name)
+ set_peft_model_state_dict(unwrapped_model, self.shadow_weights, adapter_name=self.teacher_adapter_name)
+ unwrapped_model.set_adapter(original_adapter)
+
+ def on_train_begin(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs):
+ if self.accelerator is None and "accelerator" in kwargs:
+ self.accelerator = kwargs["accelerator"]
+ self._initialize_teacher_adapter()
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdpo/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdpo/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f50a54cf7c8d3dcc907361da9caa07e53cd21d9f
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdpo/__init__.py
@@ -0,0 +1,19 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .sdpo_config import SDPOConfig
+from .sdpo_trainer import SDPOTrainer
+
+
+__all__ = ["SDPOConfig", "SDPOTrainer"]
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdpo/loss_utils.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdpo/loss_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..5caa8c88713d2088c9c4c728dcea3e62236cf4e4
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdpo/loss_utils.py
@@ -0,0 +1,135 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Pure helper functions for self-distillation loss computation."""
+
+import torch
+import torch.nn.functional as F
+
+from ...trainer.utils import selective_log_softmax
+
+
+def compute_divergence(
+ student_log_probs: torch.Tensor,
+ teacher_log_probs: torch.Tensor,
+ alpha: float,
+) -> torch.Tensor:
+ if alpha == 0.0:
+ kl = F.kl_div(student_log_probs, teacher_log_probs, reduction="none", log_target=True)
+ elif alpha == 1.0:
+ kl = F.kl_div(teacher_log_probs, student_log_probs, reduction="none", log_target=True)
+ else:
+ alpha_t = torch.tensor(alpha, dtype=student_log_probs.dtype, device=student_log_probs.device)
+ mixture = torch.logsumexp(
+ torch.stack([student_log_probs + torch.log(1 - alpha_t), teacher_log_probs + torch.log(alpha_t)]),
+ dim=0,
+ )
+ kl_teacher = F.kl_div(mixture, teacher_log_probs, reduction="none", log_target=True)
+ kl_student = F.kl_div(mixture, student_log_probs, reduction="none", log_target=True)
+ kl = torch.lerp(kl_student, kl_teacher, alpha)
+ return kl.sum(-1)
+
+
+def add_tail_bucket(log_probs: torch.Tensor) -> torch.Tensor:
+ """Append a bucket holding the leftover probability mass to a top-k log-prob support.
+
+ `log_probs` are true log-probabilities over a top-k subset, so they sum to the captured mass `P_topk <= 1`. This
+ appends one extra category equal to the tail mass `1 - P_topk`, yielding a distribution that sums to exactly 1.
+ """
+ log_s = torch.logsumexp(log_probs, dim=-1, keepdim=True)
+ log_s = torch.clamp(log_s, max=-1e-7)
+ tail_log = torch.log(-torch.expm1(log_s))
+ return torch.cat([log_probs, tail_log], dim=-1)
+
+
+def apply_importance_sampling_clipping(
+ per_token_loss: torch.Tensor,
+ student_log_probs: torch.Tensor,
+ old_log_probs: torch.Tensor,
+ clip_coeff: float,
+) -> torch.Tensor:
+ negative_approx_kl = (student_log_probs - old_log_probs).detach()
+ negative_approx_kl = torch.clamp(negative_approx_kl, min=-20.0, max=20.0)
+ ratio = torch.exp(negative_approx_kl).clamp(max=clip_coeff)
+ return per_token_loss * ratio
+
+
+def compute_topk_self_distillation_loss(
+ student_logits: torch.Tensor,
+ teacher_logits: torch.Tensor,
+ *,
+ distillation_topk: int,
+ distillation_alpha: float,
+ distillation_add_tail: bool,
+) -> torch.Tensor:
+ """Compute distillation loss on the student's top-k token support.
+
+ The student's top-k logits define the support. The teacher distribution is projected onto the same token indices.
+ The selected support is then either renormalized or augmented with a tail bucket before the divergence is computed.
+ """
+ student_logsumexp = torch.logsumexp(student_logits, dim=-1, keepdim=True)
+ topk_student_logits, topk_indices = torch.topk(student_logits, k=distillation_topk, dim=-1)
+ topk_student_log_probs = topk_student_logits - student_logsumexp
+
+ teacher_logsumexp = torch.logsumexp(teacher_logits, dim=-1, keepdim=True)
+ topk_teacher_logits = torch.gather(teacher_logits, dim=-1, index=topk_indices)
+ topk_teacher_log_probs = topk_teacher_logits - teacher_logsumexp
+
+ # Top-k log-probs sum to the captured mass P_topk <= 1; the rest (1 - P_topk) is the "tail".
+ if distillation_add_tail:
+ # Lump the tail into one bucket so the divergence approximates the full-vocab divergence.
+ topk_student_log_probs = add_tail_bucket(topk_student_log_probs)
+ topk_teacher_log_probs = add_tail_bucket(topk_teacher_log_probs)
+ else:
+ # Drop the tail and renormalize the top-k to sum to 1: divergence over the top-k conditional only.
+ topk_student_log_probs = topk_student_log_probs - torch.logsumexp(topk_student_log_probs, dim=-1, keepdim=True)
+ topk_teacher_log_probs = topk_teacher_log_probs - torch.logsumexp(topk_teacher_log_probs, dim=-1, keepdim=True)
+
+ return compute_divergence(topk_student_log_probs, topk_teacher_log_probs, distillation_alpha)
+
+
+def compute_full_logit_self_distillation_loss(
+ student_logits: torch.Tensor,
+ teacher_logits: torch.Tensor,
+ *,
+ distillation_alpha: float,
+) -> torch.Tensor:
+ """Compute full-vocabulary self-distillation loss between student and teacher logits."""
+ student_log_probs = torch.log_softmax(student_logits, dim=-1)
+ teacher_log_probs = torch.log_softmax(teacher_logits, dim=-1)
+ return compute_divergence(student_log_probs, teacher_log_probs, distillation_alpha)
+
+
+def compute_sampled_token_self_distillation_loss(
+ student_logits: torch.Tensor,
+ teacher_logits: torch.Tensor,
+ completion_ids: torch.Tensor,
+ *,
+ distillation_alpha: float,
+) -> torch.Tensor:
+ """Compute token-level self-distillation loss only on the sampled completion tokens.
+
+ This path compares student and teacher log-probabilities on the realized completion tokens rather than over a
+ larger token support.
+ """
+ if distillation_alpha != 1.0:
+ raise ValueError(
+ "Only reverse KL (alpha=1.0) is supported for token-level distillation when "
+ f"`distillation_mode='sampled_token'`, got alpha={distillation_alpha}"
+ )
+
+ student_per_token_logps = selective_log_softmax(student_logits, completion_ids)
+ teacher_per_token_logps = selective_log_softmax(teacher_logits, completion_ids)
+ log_ratio = student_per_token_logps - teacher_per_token_logps
+ return log_ratio.detach() * student_per_token_logps
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdpo/sdpo_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdpo/sdpo_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..1981a6c4d6c82a39f68634a21aee2a712cd0d71a
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdpo/sdpo_config.py
@@ -0,0 +1,644 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+from transformers import TrainingArguments
+
+from ...trainer.base_config import _BaseConfig
+
+
+@dataclass
+class SDPOConfig(_BaseConfig):
+ r"""
+ Configuration class for the [`SDPOTrainer`].
+
+ Parameters:
+ > Parameters that control the online policy objective
+
+ beta (`float`, *optional*, defaults to `0.0`):
+ KL coefficient. If `0.0` (default), the reference model is not loaded, reducing memory usage and improving
+ training speed. [DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement
+ learning](https://huggingface.co/papers/2501.12948) use a value of `0.001`.
+ epsilon (`float`, *optional*, defaults to `0.2`):
+ Epsilon value for clipping.
+ epsilon_high (`float`, *optional*):
+ Upper-bound epsilon value for clipping. If not specified, it defaults to the same value as the lower-bound
+ specified in argument `epsilon`. Paper DAPO recommends `0.28`.
+ importance_sampling_level (`str`, *optional*, defaults to `"token"`):
+ Controls whether importance sampling ratios are computed at the `'token'` or `'sequence'` level. `'token'`
+ keeps the raw per-token log-probability ratios (one weight per token). `'sequence'` averages the
+ log-probability ratios across valid tokens to produce a single ratio per sequence. The GSPO paper shows
+ that sequence-level sampling often yields more stable training and better alignment with sequence-level
+ rewards.
+ reward_weights (`list[float]`, *optional*):
+ Weights for each reward function. Must match the number of reward functions. If `None`, all rewards are
+ weighted equally with weight `1.0`.
+ scale_rewards (`str` or `bool`, *optional*, defaults to `"group"`):
+ Specifies the scaling strategy for rewards. Supported values are: `True` or `'group'` (default): rewards
+ are scaled by the standard deviation within each group, ensuring unit variance within a group. `'batch'`:
+ rewards are scaled by the standard deviation across the entire batch, as recommended in the PPO Lite paper.
+ `False` or `'none'`: no scaling is applied. The Dr. GRPO paper recommends not scaling rewards, as scaling
+ by the standard deviation introduces a question-level difficulty bias.
+
+ > Parameters that control the SDPO loss
+
+ distillation_weight (`float`, *optional*, defaults to `1.0`):
+ Convex combination weight between the policy and self-distillation objectives. The loss is `(1 -
+ distillation_weight) * policy_loss + distillation_weight * distillation_loss`. Must be in `[0, 1]`. `1.0`
+ (default) trains purely on self-distillation, `0.0` falls back to the standard GRPO-style policy gradient,
+ and intermediate values blend both.
+ distillation_alpha (`float`, *optional*, defaults to `1.0`):
+ Divergence interpolation coefficient. Sampled-token SDPO requires the official reverse-KL setting
+ `distillation_alpha=1.0`.
+ distillation_mode (`Literal["sampled_token", "full_logits", "topk_logits"]`, *optional*, defaults to `"sampled_token"`):
+ Distillation objective mode. `sampled_token` is the default SDPO mode and requires
+ `distillation_alpha=1.0`.
+ distillation_topk (`int`, *optional*):
+ Top-k approximation for logit-level SDPO. Must be set when `distillation_mode=topk_logits` and left unset
+ otherwise.
+ distillation_is_clip (`float`, *optional*, defaults to `2.0`):
+ Clipping coefficient for importance sampling in self-distillation. `None` disables clipping.
+ distillation_add_tail (`bool`, *optional*, defaults to `False`):
+ Whether to add a tail bucket for non-top-k probability mass.
+
+ > Parameters that control the teacher
+
+ teacher_model_kind (`str`, *optional*, defaults to `"ema"`):
+ Semantic teacher choice. `base` uses the initial student, `live` uses the current student, and `ema` uses
+ an exponentially averaged teacher.
+ teacher_update_rate (`float`, *optional*, defaults to `0.05`):
+ Teacher update rate used for EMA teacher synchronization.
+ teacher_sync_steps (`int`, *optional*, defaults to `1`):
+ How often to synchronize the EMA teacher model.
+
+ > Parameters that control reprompting
+
+ use_successful_as_teacher (`bool`, *optional*, defaults to `True`):
+ Use successful rollouts as implicit feedback for self-distillation.
+ success_reward_threshold (`float`, *optional*, defaults to `1.0`):
+ Minimum reward for a rollout to be considered a successful demonstration.
+ dont_reprompt_on_self_success (`bool`, *optional*, defaults to `True`):
+ Skip reprompting when model generates correct response.
+ max_reprompt_len (`int`, *optional*, defaults to `10240`):
+ Maximum length for reprompting in self-distillation.
+ reprompt_template (`str`, *optional*, defaults to `"{prompt}{solution}{feedback}\n\nCorrectly solve the original question.\n"`):
+ Template for reprompting the teacher with a successful demonstration.
+ solution_template (`str`, *optional*, defaults to `"\nCorrect solution:
+ \n\n{successful_previous_attempt}\n\n"`): Template for formatting the successful demonstration text.
+ feedback_template (`str`, *optional*, defaults to `"\nThe following is feedback from your unsuccessful earlier attempt:
+ \n\n{feedback_raw}\n\n"`): Template for formatting environment feedback for reprompting.
+ include_environment_feedback (`bool`, *optional*, defaults to `False`):
+ Whether to include environment feedback in teacher reprompts when available.
+ environment_feedback_only_without_solution (`bool`, *optional*, defaults to `False`):
+ Whether to use feedback only when no successful solution is available.
+ remove_thinking_from_demonstration (`bool`, *optional*, defaults to `False`):
+ Whether to remove ... blocks from the demonstration text.
+
+ > Parameters that control diagnostics
+
+ diagnostics_warning_interval (`int`, *optional*, defaults to `10`):
+ Emit repeated trainer diagnostics every N consecutive degenerate steps. Set to 0 to disable.
+ diagnostics_flat_tolerance (`float`, *optional*, defaults to `1e-8`):
+ Tolerance used to decide whether reward variance or reprompt activity is effectively zero.
+
+ > Parameters that control the model
+
+ model_init_kwargs (`dict[str, Any]`, *optional*):
+ Keyword arguments for `transformers.AutoModelForCausalLM.from_pretrained`, used when the `model` argument
+ of the `SDPOTrainer` is provided as a string.
+ trust_remote_code (`bool`, *optional*, defaults to `False`):
+ Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to
+ [`~transformers.AutoModelForCausalLM.from_pretrained`] and [`~transformers.AutoProcessor.from_pretrained`].
+ Also applied to reward-model and reward-tokenizer loads.
+ disable_dropout (`bool`, *optional*, defaults to `True`):
+ Whether to disable dropout in the model. This is useful for training with a reference model, as it prevents
+ the model from generating different logprobs for the same input.
+
+ > Parameters that control data preprocessing
+
+ remove_unused_columns (`bool`, *optional*, defaults to `False`):
+ Whether to only keep the column 'prompt' in the dataset. If you use a custom reward function that requires
+ any column other than 'prompts' and 'completions', you should keep this to `False`.
+ max_prompt_length (`int`, *optional*, defaults to `512`):
+ Maximum prompt length. Longer prompts are truncated from the left.
+ shuffle_dataset (`bool`, *optional*, defaults to `True`):
+ Whether to shuffle the training dataset.
+
+ > Parameters that control generation
+
+ num_generations (`int`, *optional*, defaults to `8`):
+ Number of generations to sample. The effective batch size (num_processes * per_device_batch_size *
+ gradient_accumulation_steps) must be evenly divisible by this value.
+ num_generations_eval (`int`, *optional*):
+ Number of generations to sample during evaluation. This allows using fewer generations during evaluation to
+ save computation. If `None`, uses the value of `num_generations`.
+ max_completion_length (`int`, *optional*, defaults to `256`):
+ Maximum length of the generated completion.
+ temperature (`float`, *optional*, defaults to `1.0`):
+ Temperature for sampling. The higher the temperature, the more random the completions.
+ top_p (`float`, *optional*, defaults to `1.0`):
+ Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. Set to 1.0
+ to consider all tokens.
+ top_k (`int`, *optional*, defaults to `0`):
+ Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, top-k-filtering is
+ disabled and all tokens are considered.
+ min_p (`float`, *optional*):
+ Minimum token probability, which will be scaled by the probability of the most likely token. It must be a
+ value between 0.0 and 1.0. Typical values are in the 0.01-0.2 range.
+ repetition_penalty (`float`, *optional*, defaults to `1.0`):
+ Float that penalizes new tokens based on whether they appear in the prompt and the generated text so far.
+ Values > 1.0 encourage the model to use new tokens, while values < 1.0 encourage the model to repeat
+ tokens.
+ cache_implementation (`str`, *optional*):
+ Implementation of the cache method for faster generation when use_vllm is set to False.
+ generation_kwargs (`dict[str, Any]`, *optional*):
+ Additional keyword arguments to pass to `GenerationConfig` (if using transformers) or `SamplingParams` (if
+ using vLLM) when sampling completions. This can be used to further customize the generation behavior, such
+ as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that conflict with the other generation
+ parameters (like `min_p`, `top_p`, etc.), they will override them.
+ chat_template_kwargs (`dict[str, Any]`, *optional*):
+ Additional keyword arguments to pass to the `apply_chat_template` function when generating completions.
+ ds3_gather_for_generation (`bool`, *optional*, defaults to `True`):
+ This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for generation,
+ improving generation speed. However, disabling this option allows training models that exceed the VRAM
+ capacity of a single GPU, albeit at the cost of slower generation. Disabling this option is not compatible
+ with vLLM generation.
+
+ > Parameters that control generation acceleration powered by vLLM
+
+ use_vllm (`bool`, *optional*, defaults to `False`):
+ Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for generation
+ instead of the default model.generate(). Requires `vllm` to be installed.
+ use_teacher_server (`bool`, *optional*, defaults to `False`):
+ Compute teacher logprobs from the running vLLM generation server instead of a local teacher forward. Only
+ supported for `teacher_model_kind='live'` with `use_vllm=True`, `vllm_mode='server'`,
+ `distillation_weight=1.0` (pure distillation), and `distillation_mode` in {'sampled_token', 'topk_logits'}
+ (the server returns the teacher's top-k logprobs, not the full vocabulary; `topk_logits` distills over the
+ teacher's own top-k support).
+ vllm_mode (`str`, *optional*, defaults to `"colocate"`):
+ Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `'server'` or
+ `'colocate'`. `'server'`: The trainer will send generation requests to a separate vLLM server. Make sure a
+ TRL vLLM server is running (start with `trl vllm-serve`). `'colocate'`: vLLM will run in the same process
+ and share the training GPUs. This avoids the need for a separate server but may cause resource contention
+ with training.
+ vllm_model_impl (`str`, *optional*, defaults to `"vllm"`):
+ Model implementation to use for vLLM. Must be one of `transformers` or `vllm`. `transformers`: Use the
+ `transformers` backend for model implementation. `vllm`: Use the `vllm` library for model implementation.
+ vllm_enable_sleep_mode (`bool`, *optional*, defaults to `False`):
+ Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory usage low, but
+ waking the engine adds host–device transfer latency.
+ vllm_server_base_url (`str`, *optional*):
+ Base URL for the vLLM server (e.g., 'http://localhost:8000'). If provided, `vllm_server_host` and
+ `vllm_server_port` are ignored.
+ vllm_server_host (`str`, *optional*, defaults to `"0.0.0.0"`):
+ Host of the vLLM server to connect to. Ignored if vllm_server_base_url is provided.
+ vllm_server_port (`int`, *optional*, defaults to `8000`):
+ Port of the vLLM server to connect to. Ignored if vllm_server_base_url is provided.
+ vllm_group_port (`int`, *optional*, defaults to `51216`):
+ Port number for the weight update group. This is used to communicate with the vLLM server. Unless the port
+ is occupied, there is no need to change it.
+ vllm_server_timeout (`float`, *optional*, defaults to `240.0`):
+ Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up after the
+ timeout, a `ConnectionError` is raised.
+ vllm_tensor_parallel_size (`int`, *optional*, defaults to `1`):
+ Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set to
+ `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when
+ launching the vLLM server via the `--vllm_tensor_parallel_size` flag.
+ vllm_gpu_memory_utilization (`float`, *optional*, defaults to `0.3`):
+ Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set to
+ `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when
+ launching the vLLM server via the `--vllm_gpu_memory_utilization` flag.
+ vllm_max_model_length (`int`, *optional*):
+ Context window for vLLM. Set it to at least the maximum prompt length in the dataset plus
+ `max_completion_length`; if omitted, it is inferred from the model config.
+
+ > Parameters that control the training
+
+ loss_type (`str`, *optional*, defaults to `"dapo"`):
+ Specifies the loss formulation to use. Supported values are 'grpo', 'bnpo', 'dr_grpo', and 'dapo'. 'grpo':
+ Aggregates token-level losses by normalizing over sequence length. Not recommended due to length bias—this
+ approach tends to prefer shorter completions with positive advantages and longer ones with negative
+ advantages. 'dapo' (default): Aggregates token-level losses by normalizing with the number of active tokens
+ in the global accumulated batch. This method was introduced in the DAPO paper to eliminate length bias.
+ 'dr_grpo': Aggregates token-level losses by normalizing with a global constant. This method was introduced
+ in the Dr. GRPO paper to eliminate length bias. The value of the constant corresponds to
+ `max_completion_length`. 'bnpo': Aggregates token-level losses by normalizing with the number of active
+ tokens in the local batch. Note that normalization is performed over the local batch only, so results may
+ slightly vary depending on the local batch size, despite a constant effective batch size. When using
+ `per_device_train_batch_size==1`, the loss is equivalent to the GRPO loss.
+ num_iterations (`int`, *optional*, defaults to `1`):
+ Number of iterations per batch (denoted as μ in the algorithm).
+ generation_batch_size (`int`, *optional*):
+ Batch size to use for generation. If `None`, it defaults to the effective training batch size:
+ `per_device_train_batch_size * num_processes * steps_per_generation`.
+ steps_per_generation (`int`, *optional*):
+ Number of steps per generation. If `None`, it defaults to `gradient_accumulation_steps`.
+ mask_truncated_completions (`bool`, *optional*, defaults to `False`):
+ When enabled, truncated completions are excluded from the loss calculation, preventing them from being
+ incorrectly penalized and introducing noise during training. According to the DAPO paper, this is a good
+ practice for training stability.
+ """
+
+ _VALID_DICT_FIELDS = TrainingArguments._VALID_DICT_FIELDS + ["model_init_kwargs"]
+
+ model_init_kwargs: dict[str, Any] | None = field(
+ default=None,
+ metadata={
+ "help": "Keyword arguments for `transformers.AutoModelForCausalLM.from_pretrained`, used when the `model` argument of the `SDPOTrainer` is provided as a string."
+ },
+ )
+ trust_remote_code: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. "
+ "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoProcessor.from_pretrained`. Also applied to "
+ "reward-model and reward-tokenizer loads."
+ },
+ )
+ disable_dropout: bool = field(
+ default=True,
+ metadata={
+ "help": "Whether to disable dropout in the model. This is useful for training with a reference model, as it prevents the model from generating different logprobs for the same input."
+ },
+ )
+ remove_unused_columns: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to only keep the column 'prompt' in the dataset. If you use a custom reward function that requires any column other than 'prompts' and 'completions', you should keep this to `False`."
+ },
+ )
+ max_prompt_length: int | None = field(
+ default=512,
+ metadata={"help": "Maximum prompt length. Longer prompts are truncated from the left."},
+ )
+ num_generations: int = field(
+ default=8,
+ metadata={
+ "help": "Number of generations to sample. The effective batch size (num_processes * per_device_batch_size * gradient_accumulation_steps) must be evenly divisible by this value."
+ },
+ )
+ num_generations_eval: int | None = field(
+ default=None,
+ metadata={
+ "help": "Number of generations to sample during evaluation. This allows using fewer generations during evaluation to save computation. If `None`, uses the value of `num_generations`."
+ },
+ )
+ max_completion_length: int | None = field(
+ default=256,
+ metadata={"help": "Maximum length of the generated completion."},
+ )
+ ds3_gather_for_generation: bool = field(
+ default=True,
+ metadata={
+ "help": "This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for generation, improving generation speed. However, disabling this option allows training models that exceed the VRAM capacity of a single GPU, albeit at the cost of slower generation. Disabling this option is not compatible with vLLM generation."
+ },
+ )
+ shuffle_dataset: bool = field(
+ default=True,
+ metadata={"help": "Whether to shuffle the training dataset."},
+ )
+ generation_batch_size: int | None = field(
+ default=None,
+ metadata={
+ "help": "Batch size to use for generation. If `None`, it defaults to the effective training batch size: `per_device_train_batch_size * num_processes * steps_per_generation`."
+ },
+ )
+ steps_per_generation: int | None = field(
+ default=None,
+ metadata={"help": "Number of steps per generation. If `None`, it defaults to `gradient_accumulation_steps`."},
+ )
+ temperature: float = field(
+ default=1.0,
+ metadata={"help": "Temperature for sampling. The higher the temperature, the more random the completions."},
+ )
+ top_p: float = field(
+ default=1.0,
+ metadata={
+ "help": "Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. Set to 1.0 to consider all tokens."
+ },
+ )
+ top_k: int = field(
+ default=0,
+ metadata={
+ "help": "Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, top-k-filtering is disabled and all tokens are considered."
+ },
+ )
+ min_p: float | None = field(
+ default=None,
+ metadata={
+ "help": "Minimum token probability, which will be scaled by the probability of the most likely token. It must be a value between 0.0 and 1.0. Typical values are in the 0.01-0.2 range."
+ },
+ )
+ generation_kwargs: dict[str, Any] | None = field(
+ default=None,
+ metadata={
+ "help": "Additional keyword arguments to pass to `GenerationConfig` (if using transformers) or `SamplingParams` (if using vLLM) when sampling completions. This can be used to further customize the generation behavior, such as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that conflict with the other generation parameters (like `min_p`, `top_p`, etc.), they will override them."
+ },
+ )
+ chat_template_kwargs: dict[str, Any] | None = field(
+ default=None,
+ metadata={
+ "help": "Additional keyword arguments to pass to the `apply_chat_template` function when generating completions."
+ },
+ )
+ repetition_penalty: float = field(
+ default=1.0,
+ metadata={
+ "help": "Float that penalizes new tokens based on whether they appear in the prompt and the generated text so far. Values > 1.0 encourage the model to use new tokens, while values < 1.0 encourage the model to repeat tokens."
+ },
+ )
+ cache_implementation: str | None = field(
+ default=None,
+ metadata={"help": "Implementation of the cache method for faster generation when use_vllm is set to False."},
+ )
+ use_vllm: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for generation instead of the default model.generate(). Requires `vllm` to be installed."
+ },
+ )
+ use_teacher_server: bool = field(
+ default=False,
+ metadata={
+ "help": "Compute teacher logprobs from the running vLLM generation server instead of a local teacher "
+ "forward. Only supported for `teacher_model_kind='live'` with `use_vllm=True`, `vllm_mode='server'`, "
+ "`distillation_weight=1.0` (pure distillation), and `distillation_mode` in {'sampled_token', "
+ "'topk_logits'} (the server returns the teacher's top-k logprobs, not the full vocabulary; `topk_logits` "
+ "distills over the teacher's own top-k support)."
+ },
+ )
+ vllm_mode: str = field(
+ default="colocate",
+ metadata={
+ "help": "Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `'server'` or `'colocate'`. `'server'`: The trainer will send generation requests to a separate vLLM server. Make sure a TRL vLLM server is running (start with `trl vllm-serve`). `'colocate'`: vLLM will run in the same process and share the training GPUs. This avoids the need for a separate server but may cause resource contention with training."
+ },
+ )
+ vllm_model_impl: str = field(
+ default="vllm",
+ metadata={
+ "help": "Model implementation to use for vLLM. Must be one of `transformers` or `vllm`. `transformers`: Use the `transformers` backend for model implementation. `vllm`: Use the `vllm` library for model implementation."
+ },
+ )
+ vllm_enable_sleep_mode: bool = field(
+ default=False,
+ metadata={
+ "help": "Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory usage low, but waking the engine adds host–device transfer latency."
+ },
+ )
+ vllm_server_base_url: str | None = field(
+ default=None,
+ metadata={
+ "help": "Base URL for the vLLM server (e.g., 'http://localhost:8000'). If provided, `vllm_server_host` and `vllm_server_port` are ignored."
+ },
+ )
+ vllm_server_host: str = field(
+ default="0.0.0.0",
+ metadata={"help": "Host of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."},
+ )
+ vllm_server_port: int = field(
+ default=8000,
+ metadata={"help": "Port of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."},
+ )
+ vllm_group_port: int = field(
+ default=51216,
+ metadata={
+ "help": "Port number for the weight update group. This is used to communicate with the vLLM server. Unless the port is occupied, there is no need to change it."
+ },
+ )
+ vllm_server_timeout: float = field(
+ default=240.0,
+ metadata={
+ "help": "Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up after the timeout, a `ConnectionError` is raised."
+ },
+ )
+ vllm_tensor_parallel_size: int = field(
+ default=1,
+ metadata={
+ "help": "Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when launching the vLLM server via the `--vllm_tensor_parallel_size` flag."
+ },
+ )
+ vllm_gpu_memory_utilization: float = field(
+ default=0.3,
+ metadata={
+ "help": "Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when launching the vLLM server via the `--vllm_gpu_memory_utilization` flag."
+ },
+ )
+ vllm_max_model_length: int | None = field(
+ default=None,
+ metadata={
+ "help": "Context window for vLLM. Set it to at least the maximum prompt length in the dataset plus `max_completion_length`; if omitted, it is inferred from the model config."
+ },
+ )
+ num_iterations: int = field(
+ default=1,
+ metadata={"help": "Number of iterations per batch (denoted as μ in the algorithm)."},
+ )
+ loss_type: str = field(
+ default="dapo",
+ metadata={
+ "help": "Specifies the loss formulation to use. Supported values are 'grpo', 'bnpo', 'dr_grpo', and 'dapo'. 'grpo': Aggregates token-level losses by normalizing over sequence length. Not recommended due to length bias—this approach tends to prefer shorter completions with positive advantages and longer ones with negative advantages. 'dapo' (default): Aggregates token-level losses by normalizing with the number of active tokens in the global accumulated batch. This method was introduced in the DAPO paper to eliminate length bias. 'dr_grpo': Aggregates token-level losses by normalizing with a global constant. This method was introduced in the Dr. GRPO paper to eliminate length bias. The value of the constant corresponds to `max_completion_length`. 'bnpo': Aggregates token-level losses by normalizing with the number of active tokens in the local batch. Note that normalization is performed over the local batch only, so results may slightly vary depending on the local batch size, despite a constant effective batch size. When using `per_device_train_batch_size==1`, the loss is equivalent to the GRPO loss."
+ },
+ )
+ mask_truncated_completions: bool = field(
+ default=False,
+ metadata={
+ "help": "When enabled, truncated completions are excluded from the loss calculation, preventing them from being incorrectly penalized and introducing noise during training. According to the DAPO paper, this is a good practice for training stability."
+ },
+ )
+ dont_reprompt_on_self_success: bool = field(
+ default=True,
+ metadata={"help": "Skip reprompting when model generates correct response."},
+ )
+ beta: float = field(
+ default=0.0,
+ metadata={
+ "help": "KL coefficient. If `0.0` (default), the reference model is not loaded, reducing memory usage and improving training speed. [DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning](https://huggingface.co/papers/2501.12948) use a value of `0.001`."
+ },
+ )
+ epsilon: float = field(
+ default=0.2,
+ metadata={"help": "Epsilon value for clipping."},
+ )
+ epsilon_high: float | None = field(
+ default=None,
+ metadata={
+ "help": "Upper-bound epsilon value for clipping. If not specified, it defaults to the same value as the lower-bound specified in argument `epsilon`. Paper DAPO recommends `0.28`."
+ },
+ )
+ importance_sampling_level: str = field(
+ default="token",
+ metadata={
+ "help": "Controls whether importance sampling ratios are computed at the `'token'` or `'sequence'` level. `'token'` keeps the raw per-token log-probability ratios (one weight per token). `'sequence'` averages the log-probability ratios across valid tokens to produce a single ratio per sequence. The GSPO paper shows that sequence-level sampling often yields more stable training and better alignment with sequence-level rewards."
+ },
+ )
+ reward_weights: list[float] | None = field(
+ default=None,
+ metadata={
+ "help": "Weights for each reward function. Must match the number of reward functions. If `None`, all rewards are weighted equally with weight `1.0`."
+ },
+ )
+ scale_rewards: str | bool = field(
+ default="group",
+ metadata={
+ "help": "Specifies the scaling strategy for rewards. Supported values are: `True` or `'group'` (default): rewards are scaled by the standard deviation within each group, ensuring unit variance within a group. `'batch'`: rewards are scaled by the standard deviation across the entire batch, as recommended in the PPO Lite paper. `False` or `'none'`: no scaling is applied. The Dr. GRPO paper recommends not scaling rewards, as scaling by the standard deviation introduces a question-level difficulty bias."
+ },
+ )
+ distillation_alpha: float = field(
+ default=1.0,
+ metadata={
+ "help": "Divergence interpolation coefficient. Sampled-token SDPO requires the official reverse-KL setting "
+ "`distillation_alpha=1.0`."
+ },
+ )
+ distillation_mode: Literal["sampled_token", "full_logits", "topk_logits"] = field(
+ default="sampled_token",
+ metadata={
+ "help": "Distillation objective mode. `sampled_token` is the default SDPO mode and requires "
+ "`distillation_alpha=1.0`."
+ },
+ )
+ distillation_topk: int | None = field(
+ default=None,
+ metadata={
+ "help": "Top-k approximation for logit-level SDPO. Must be set when `distillation_mode=topk_logits` and left "
+ "unset otherwise."
+ },
+ )
+ distillation_is_clip: float | None = field(
+ default=2.0,
+ metadata={
+ "help": "Clipping coefficient for importance sampling in self-distillation. `None` disables clipping."
+ },
+ )
+ distillation_add_tail: bool = field(
+ default=False,
+ metadata={"help": "Whether to add a tail bucket for non-top-k probability mass."},
+ )
+ distillation_weight: float = field(
+ default=1.0,
+ metadata={
+ "help": "Convex combination weight between the policy and self-distillation objectives. The loss is "
+ "`(1 - distillation_weight) * policy_loss + distillation_weight * distillation_loss`. Must be in `[0, 1]`. "
+ "`1.0` (default) trains purely on self-distillation, `0.0` falls back to the standard GRPO-style policy "
+ "gradient, and intermediate values blend both."
+ },
+ )
+ teacher_model_kind: str = field(
+ default="ema",
+ metadata={
+ "help": "Semantic teacher choice. `base` uses the initial student, `live` uses the current student, "
+ "and `ema` uses an exponentially averaged teacher."
+ },
+ )
+ teacher_update_rate: float = field(
+ default=0.05,
+ metadata={"help": "Teacher update rate used for EMA teacher synchronization."},
+ )
+ teacher_sync_steps: int = field(
+ default=1,
+ metadata={"help": "How often to synchronize the EMA teacher model."},
+ )
+ max_reprompt_len: int = field(
+ default=10240,
+ metadata={"help": "Maximum length for reprompting in self-distillation."},
+ )
+ use_successful_as_teacher: bool = field(
+ default=True,
+ metadata={"help": "Use successful rollouts as implicit feedback for self-distillation."},
+ )
+ success_reward_threshold: float = field(
+ default=1.0,
+ metadata={"help": "Minimum reward for a rollout to be considered a successful demonstration."},
+ )
+ reprompt_template: str = field(
+ default="{prompt}{solution}{feedback}\n\nCorrectly solve the original question.\n",
+ metadata={"help": "Template for reprompting the teacher with a successful demonstration."},
+ )
+ solution_template: str = field(
+ default="\nCorrect solution:\n\n{successful_previous_attempt}\n\n",
+ metadata={"help": "Template for formatting the successful demonstration text."},
+ )
+ feedback_template: str = field(
+ default="\nThe following is feedback from your unsuccessful earlier attempt:\n\n{feedback_raw}\n\n",
+ metadata={"help": "Template for formatting environment feedback for reprompting."},
+ )
+ include_environment_feedback: bool = field(
+ default=False,
+ metadata={"help": "Whether to include environment feedback in teacher reprompts when available."},
+ )
+ environment_feedback_only_without_solution: bool = field(
+ default=False,
+ metadata={"help": "Whether to use feedback only when no successful solution is available."},
+ )
+ remove_thinking_from_demonstration: bool = field(
+ default=False,
+ metadata={"help": "Whether to remove ... blocks from the demonstration text."},
+ )
+ diagnostics_warning_interval: int = field(
+ default=10,
+ metadata={
+ "help": "Emit repeated trainer diagnostics every N consecutive degenerate steps. Set to 0 to disable."
+ },
+ )
+ diagnostics_flat_tolerance: float = field(
+ default=1e-8,
+ metadata={
+ "help": "Tolerance used to decide whether reward variance or reprompt activity is effectively zero."
+ },
+ )
+
+ def __post_init__(self):
+ super().__post_init__()
+ if not 0.0 <= self.distillation_weight <= 1.0:
+ raise ValueError(f"`distillation_weight` must be in [0, 1], got {self.distillation_weight}.")
+ if self.distillation_mode == "sampled_token" and self.distillation_alpha != 1.0:
+ raise ValueError(
+ "`distillation_mode='sampled_token'` only supports reverse KL, so it requires "
+ f"`distillation_alpha=1.0`, got {self.distillation_alpha}."
+ )
+ num_processes = self.world_size
+ if self.generation_batch_size is None and self.steps_per_generation is None:
+ self.steps_per_generation = self.gradient_accumulation_steps
+ self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation
+ elif self.generation_batch_size is not None and self.steps_per_generation is None:
+ global_batch_size = self.per_device_train_batch_size * num_processes
+ if self.generation_batch_size % global_batch_size != 0:
+ raise ValueError(
+ f"generation_batch_size ({self.generation_batch_size}) must be divisible by the global batch size ({global_batch_size})."
+ )
+ self.steps_per_generation = self.generation_batch_size // global_batch_size
+ elif self.generation_batch_size is None and self.steps_per_generation is not None:
+ self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation
+ else:
+ raise ValueError("'generation_batch_size' and 'steps_per_generation' can not both be configured")
+
+ if self.generation_batch_size % self.num_generations != 0:
+ raise ValueError(
+ f"generation_batch_size ({self.generation_batch_size}) must be divisible by num_generations ({self.num_generations})."
+ )
+
+ if self.do_eval and self.eval_strategy != "no":
+ num_generations_eval = self.num_generations_eval or self.num_generations
+ if (self.per_device_eval_batch_size * num_processes) % num_generations_eval != 0:
+ raise ValueError(
+ f"The global eval batch size ({self.per_device_eval_batch_size} * {num_processes}) must be "
+ f"divisible by the number of generations used for evaluation ({num_generations_eval})."
+ )
+
+ self.scale_rewards = {True: "group", False: "none"}.get(self.scale_rewards, self.scale_rewards)
+
+ if self.epsilon_high is None:
+ self.epsilon_high = self.epsilon
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdpo/sdpo_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdpo/sdpo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ee0a0b8415ea31b96f6be375fe1220f0b51f217
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdpo/sdpo_trainer.py
@@ -0,0 +1,1773 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import inspect
+import math
+import re
+import textwrap
+from collections import defaultdict
+from contextlib import nullcontext
+from dataclasses import dataclass
+from functools import partial
+from typing import Any
+
+import datasets
+import torch
+from accelerate.logging import get_logger
+from accelerate.utils import gather_object, is_peft_model
+from datasets import Dataset, IterableDataset
+from torch import nn
+from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+from torch.utils.data import DataLoader, Sampler
+from transformers import (
+ AutoModelForSequenceClassification,
+ AutoProcessor,
+ AutoTokenizer,
+ GenerationConfig,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+ ProcessorMixin,
+ TrainerCallback,
+)
+from transformers.trainer_utils import seed_worker
+from transformers.utils import is_datasets_available, is_liger_kernel_available, is_peft_available
+
+from ...data_utils import apply_chat_template, is_conversational
+from ...models import prepare_deepspeed, prepare_fsdp, unwrap_model_for_generation
+from ...models.utils import _ForwardRedirection
+from ...trainer.base_trainer import _BaseTrainer
+from ...trainer.utils import (
+ RepeatSampler,
+ create_model_from_path,
+ disable_dropout_in_model,
+ get_config_model_id,
+ identity,
+ pad,
+ selective_log_softmax,
+ split_tensor_dict,
+ use_adapter,
+)
+from ..utils import prepare_peft_model
+from .loss_utils import (
+ add_tail_bucket,
+ apply_importance_sampling_clipping,
+ compute_divergence,
+ compute_full_logit_self_distillation_loss,
+ compute_sampled_token_self_distillation_loss,
+ compute_topk_self_distillation_loss,
+)
+from .sdpo_config import SDPOConfig
+from .teacher_sync import PEFTAdapterEMACallback, SyncTeacherModelCallback, is_pure_lora_training
+
+
+logger = get_logger(__name__)
+
+
+if is_peft_available():
+ from peft import PeftConfig
+
+if is_liger_kernel_available():
+ from liger_kernel.chunked_loss import LigerFusedLinearJSDLoss
+
+
+TrainingBatch = dict[str, torch.Tensor | Any]
+
+
+def build_teacher_request_inputs(
+ input_ids: torch.Tensor,
+ attention_mask: torch.Tensor,
+ prompt_attention_mask: torch.Tensor,
+) -> tuple[list[list[int]], list[int], list[int]]:
+ """Trim padded batch tensors into per-sample (prompt+completion) sequences for teacher-server requests."""
+ if input_ids.shape != attention_mask.shape:
+ raise ValueError(
+ f"input_ids and attention_mask must have the same shape, got {input_ids.shape} and {attention_mask.shape}."
+ )
+
+ input_ids_cpu = input_ids.detach().cpu()
+ attention_mask_cpu = attention_mask.detach().cpu().bool()
+ prompt_lengths = prompt_attention_mask.detach().cpu().sum(dim=1).to(torch.long)
+
+ trimmed_input_ids: list[list[int]] = []
+ prompt_lengths_list: list[int] = []
+ completion_lengths_list: list[int] = []
+ for row, mask, prompt_length in zip(input_ids_cpu, attention_mask_cpu, prompt_lengths, strict=True):
+ trimmed_row = row[mask]
+ prompt_len = int(prompt_length.item())
+ if prompt_len < 0 or prompt_len > trimmed_row.numel():
+ raise ValueError(
+ f"Invalid prompt length {prompt_len} for trimmed sequence of length {trimmed_row.numel()}."
+ )
+ trimmed_input_ids.append(trimmed_row.tolist())
+ prompt_lengths_list.append(prompt_len)
+ completion_lengths_list.append(int(trimmed_row.numel()) - prompt_len)
+ return trimmed_input_ids, prompt_lengths_list, completion_lengths_list
+
+
+@dataclass
+class DistillationLogits:
+ """Aligned logits and masks used to compute a self-distillation objective."""
+
+ completion_ids: torch.Tensor
+ completion_mask: torch.Tensor
+ loss_mask: torch.Tensor
+ student_logits: torch.Tensor
+ teacher_logits: torch.Tensor
+
+
+def _extract_last_user_text(messages: list[dict[str, Any]]) -> str:
+ """Extract the text content from the last user message in a conversational prompt."""
+ last_message = messages[-1]
+ if last_message.get("role") != "user":
+ raise ValueError(
+ f"Self-distillation teacher prompt construction expects the conversation to end with a user turn, "
+ f"but the last message has role '{last_message.get('role')}'. "
+ f"Prompts ending with assistant prefills or tool turns are not supported."
+ )
+ content = last_message.get("content", "")
+ if isinstance(content, list):
+ return " ".join(part.get("text", "") for part in content if part.get("type") == "text")
+ return content
+
+
+class SuccessfulRolloutTeacherContextBuilder:
+ """Builds teacher contexts from successful rollouts"""
+
+ def __init__(self, trainer):
+ self.trainer = trainer
+ self.last_metrics: dict[str, float] = {}
+
+ def _build_reprompt_text(self, prompt_text: str, solution_text: str, feedback_text: str) -> str:
+ return self.trainer.args.reprompt_template.format(
+ prompt=prompt_text,
+ solution=solution_text,
+ feedback=feedback_text,
+ )
+
+ def _tokenize_teacher_messages(
+ self, teacher_messages_list: list[str | list[dict[str, Any]]]
+ ) -> dict[str, torch.Tensor]:
+ device = self.trainer.accelerator.device
+ teacher_prompt_ids_list = self.trainer._tokenize_prompts_untruncated(teacher_messages_list)
+ teacher_prompt_ids = [
+ torch.as_tensor(ids[-self.trainer.args.max_reprompt_len :], device=device)
+ for ids in teacher_prompt_ids_list
+ ]
+ teacher_prompt_mask = [torch.ones(len(ids), dtype=torch.long, device=device) for ids in teacher_prompt_ids]
+ return {
+ "prompt_ids": pad(
+ teacher_prompt_ids, padding_value=self.trainer._tokenizer.pad_token_id, padding_side="left"
+ ),
+ "prompt_mask": pad(teacher_prompt_mask, padding_value=0, padding_side="left"),
+ }
+
+ def build(
+ self,
+ output: dict[str, torch.Tensor | Any],
+ prompts: list[Any],
+ rewards: torch.Tensor,
+ feedbacks: list[Any] | None = None,
+ ) -> dict[str, torch.Tensor]:
+ device = self.trainer.accelerator.device
+ mode = "train" if self.trainer.model.training else "eval"
+ num_generations = self.trainer.num_generations if mode == "train" else self.trainer.num_generations_eval
+ completion_ids = output["completion_ids"]
+ completion_mask = output["completion_mask"]
+
+ num_local = len(prompts)
+ process_start = self.trainer.accelerator.process_index * num_local
+ process_slice = slice(process_start, process_start + num_local)
+
+ # Rewards arrive already locally sliced (per-process) from the rollout mixin; re-gather them so
+ # the mining loop can find successful rollouts across all processes within each generation group.
+ all_rewards = self.trainer.accelerator.gather(rewards)
+ # Completion tensors are padded to the local max length per rank; align shapes before gathering.
+ # Use separate variables so the original completion_ids/completion_mask stay unpadded for the
+ # teacher concat (they must match the student's sequence length for logits_to_keep alignment).
+ padded_completion_ids = self.trainer.accelerator.pad_across_processes(
+ completion_ids, dim=1, pad_index=self.trainer._tokenizer.pad_token_id
+ )
+ all_completion_ids = self.trainer.accelerator.gather(padded_completion_ids)
+ all_prompts = gather_object(prompts)
+ total_samples = all_rewards.shape[0]
+ all_feedbacks = gather_object(feedbacks) if feedbacks is not None else [None] * total_samples
+
+ threshold = self.trainer.args.success_reward_threshold
+ dont_reprompt_self = self.trainer.args.dont_reprompt_on_self_success
+ feedback_only_without_solution = self.trainer.args.environment_feedback_only_without_solution
+ self_distillation_mask = torch.zeros(total_samples, device=device)
+ num_with_solution = 0
+ num_with_feedback_available = 0
+ num_with_feedback_used = 0
+ success_group_count = 0
+ successful_demo_indices: list[int | None] = [None] * total_samples
+ use_feedback_flags: list[bool] = [False] * total_samples
+ has_solution_flags: list[bool] = [False] * total_samples
+
+ for i in range(total_samples):
+ group_start = (i // num_generations) * num_generations
+ group_end = group_start + num_generations
+
+ successful = []
+ if self.trainer.args.use_successful_as_teacher:
+ for j in range(group_start, group_end):
+ if dont_reprompt_self and j == i:
+ continue
+ if all_rewards[j].item() >= threshold:
+ successful.append(j)
+
+ if i % num_generations == 0:
+ # Count groups with any successful rollout, ignoring self-exclusion which only
+ # affects per-sample teacher assignment, not whether the group has successes.
+ group_has_success = any(all_rewards[j].item() >= threshold for j in range(group_start, group_end))
+ if group_has_success:
+ success_group_count += 1
+
+ raw_feedback = all_feedbacks[i]
+ has_feedback = isinstance(raw_feedback, str) and raw_feedback.strip() != ""
+ if has_feedback:
+ num_with_feedback_available += 1
+
+ has_solution = len(successful) > 0
+ has_solution_flags[i] = has_solution
+ if has_solution:
+ successful_demo_indices[i] = successful[0]
+ use_feedback = (
+ self.trainer.args.include_environment_feedback
+ and has_feedback
+ and (not feedback_only_without_solution or not has_solution)
+ )
+ use_feedback_flags[i] = use_feedback
+ if use_feedback:
+ num_with_feedback_used += 1
+ if has_solution or use_feedback:
+ self_distillation_mask[i] = 1.0
+ if has_solution:
+ num_with_solution += 1
+
+ local_teacher_messages = []
+ local_self_distillation_mask = self_distillation_mask[process_slice]
+ for global_idx in range(process_start, process_start + num_local):
+ original_prompt = all_prompts[global_idx]
+ raw_feedback = all_feedbacks[global_idx]
+ has_solution = has_solution_flags[global_idx]
+ use_feedback = use_feedback_flags[global_idx]
+
+ if not has_solution and not use_feedback:
+ local_teacher_messages.append(original_prompt)
+ continue
+
+ solution_text = ""
+ if has_solution:
+ demo_idx = successful_demo_indices[global_idx]
+ if demo_idx is None:
+ raise RuntimeError("Expected a successful demonstration index for an active SDPO teacher prompt.")
+ demo_ids = all_completion_ids[demo_idx]
+ demo_ids = demo_ids[demo_ids != self.trainer._tokenizer.pad_token_id]
+ demo_text = self.trainer.processing_class.decode(demo_ids, skip_special_tokens=True)
+
+ if self.trainer.args.remove_thinking_from_demonstration:
+ demo_text = re.sub(r".*?", "", demo_text, flags=re.DOTALL).strip()
+
+ solution_text = self.trainer.args.solution_template.format(successful_previous_attempt=demo_text)
+
+ feedback_text = ""
+ if use_feedback:
+ feedback_text = self.trainer.args.feedback_template.format(feedback_raw=raw_feedback)
+
+ if isinstance(original_prompt, list):
+ system_messages = original_prompt[:-1]
+ prompt_text = _extract_last_user_text(original_prompt)
+ reprompt_text = self._build_reprompt_text(prompt_text, solution_text, feedback_text)
+ local_teacher_messages.append(system_messages + [{"role": "user", "content": reprompt_text}])
+ else:
+ local_teacher_messages.append(self._build_reprompt_text(original_prompt, solution_text, feedback_text))
+
+ teacher_batch = self._tokenize_teacher_messages(local_teacher_messages)
+ teacher_input_ids = torch.cat([teacher_batch["prompt_ids"], completion_ids], dim=1)
+ teacher_attention_mask = torch.cat([teacher_batch["prompt_mask"], completion_mask], dim=1)
+
+ batch_size = total_samples if total_samples > 0 else 1
+ num_groups = max(1, total_samples // max(1, num_generations))
+ self.last_metrics = {
+ "self_distillation/success_group_fraction": success_group_count / num_groups,
+ "self_distillation/success_sample_fraction": num_with_solution / batch_size,
+ "self_distillation/feedback_available_fraction": num_with_feedback_available / batch_size,
+ "self_distillation/feedback_used_fraction": num_with_feedback_used / batch_size,
+ "self_distillation/reprompt_sample_fraction": self_distillation_mask.float().mean().item(),
+ }
+
+ return {
+ "teacher_input_ids": teacher_input_ids,
+ "teacher_attention_mask": teacher_attention_mask,
+ "self_distillation_mask": local_self_distillation_mask,
+ }
+
+
+class SDPOTrainer(_BaseTrainer):
+ """
+ Trainer for Self-Distillation Policy Optimization (SDPO).
+
+ SDPO augments on-policy optimization with self-distillation from the model's own high-reward trajectories. It
+ converts tokenized feedback into a dense learning signal without any external teacher or explicit reward model.
+ SDPO treats the current model conditioned on feedback as a self-teacher and distills its feedback-informed
+ next-token predictions back into the policy.
+ """
+
+ config_cls = SDPOConfig
+ _tag_names = ["trl", "sdpo"]
+ _name = "SDPO"
+ # docstyle-ignore
+ _paper = {
+ "title": "Reinforcement Learning via Self-Distillation",
+ "id": "2601.20802",
+ "citation": textwrap.dedent("""\
+ @article{hubotter2026sdpo,
+ title = {{Reinforcement Learning via Self-Distillation}},
+ author = {Jonas H\\"ubotter and Frederike L\\"ubeck and Lejs Behric and Anton Baumann and Marco Bagatella and Daniel Marta and Ido Hakimi and Idan Shenfeld and Thomas Kleine Buening and Carlos Guestrin and Andreas Krause},
+ year = 2026,
+ eprint = {arXiv:2601.20802}
+ }"""),
+ }
+
+ def __init__(
+ self,
+ model: str | PreTrainedModel | nn.Module,
+ reward_funcs: Any | list[Any] | None = None,
+ args: SDPOConfig | None = None,
+ train_dataset: Dataset | IterableDataset | None = None,
+ eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None,
+ processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None,
+ reward_processing_classes: PreTrainedTokenizerBase | list[PreTrainedTokenizerBase] | None = None,
+ callbacks: list[TrainerCallback] | None = None,
+ optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None),
+ peft_config=None,
+ ):
+ if reward_funcs is None or (isinstance(reward_funcs, list) and len(reward_funcs) == 0):
+ raise ValueError("`reward_funcs` is required for SDPOTrainer because SDPO must score rollouts.")
+ if train_dataset is None:
+ raise ValueError("`train_dataset` is required")
+
+ if isinstance(model, str):
+ model_init_kwargs = args.model_init_kwargs or {}
+ if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]:
+ model_init_kwargs["device_map"] = None
+ model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+ model = create_model_from_path(model, **model_init_kwargs)
+ elif args.model_init_kwargs is not None:
+ logger.warning(
+ "You passed `model_init_kwargs` to the self-distillation config, but `model` is already "
+ "instantiated. The `model_init_kwargs` will be ignored."
+ )
+
+ self.model_kwarg_keys = (
+ inspect.signature(model.forward).parameters.keys()
+ if not hasattr(model, "get_base_model")
+ else inspect.signature(model.get_base_model().forward).parameters.keys()
+ )
+
+ if peft_config is None and getattr(model, "peft_config", None) is not None:
+ logger.warning(
+ "The provided self-distillation student model already contains a PEFT adapter. "
+ "This setup is accepted but not directly supported. In particular, `teacher_model_kind='base'` "
+ "may refer to the underlying base weights rather than the exact initially loaded student state "
+ "including its adapter. For unambiguous teacher behavior, start from a merged/non-adapter model "
+ "or manage separate adapters explicitly."
+ )
+ if peft_config is not None:
+ if not is_peft_available():
+ raise ImportError(
+ "You passed `peft_config` but the `peft` library is not installed. "
+ "Install it with `pip install trl[peft]`."
+ )
+ if not isinstance(peft_config, PeftConfig):
+ raise TypeError(
+ f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), "
+ f"got {type(peft_config).__name__}."
+ )
+ if is_peft_model(model):
+ raise ValueError(
+ "You passed a `PeftModel` instance together with a `peft_config`. Pass either a base "
+ "model with `peft_config`, or a pre-wrapped PEFT model."
+ )
+ if peft_config is not None or (is_peft_available() and getattr(model, "peft_config", None) is not None):
+ model = prepare_peft_model(model, peft_config, args)
+
+ if processing_class is None:
+ processing_class = AutoProcessor.from_pretrained(
+ get_config_model_id(model.config),
+ truncation_side="left",
+ padding_side="left",
+ trust_remote_code=args.trust_remote_code,
+ )
+
+ if isinstance(processing_class, ProcessorMixin):
+ self._tokenizer = processing_class.tokenizer
+ elif isinstance(processing_class, PreTrainedTokenizerBase):
+ self._tokenizer = processing_class
+ else:
+ raise TypeError("The `processing_class` must be either a `PreTrainedTokenizerBase` or a `ProcessorMixin`")
+
+ if self._tokenizer.pad_token is None:
+ self._tokenizer.pad_token = self._tokenizer.eos_token
+
+ self.max_prompt_length = args.max_prompt_length
+ self.max_completion_length = args.max_completion_length
+ self.num_generations = args.num_generations
+ self.num_generations_eval = args.num_generations_eval or args.num_generations
+ self.num_iterations = args.num_iterations
+ self.shuffle_dataset = args.shuffle_dataset
+ self.loss_type = args.loss_type
+ self.mask_truncated_completions = args.mask_truncated_completions
+ self.temperature = args.temperature
+ self.use_vllm = args.use_vllm
+ self.chat_template_kwargs = args.chat_template_kwargs or {}
+ self._step = 0
+ self._buffered_inputs = None
+ self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)}
+ self._diagnostic_counters = {
+ "train": defaultdict(int),
+ "eval": defaultdict(int),
+ }
+
+ self.generation_kwargs = {
+ "max_new_tokens": self.max_completion_length,
+ "do_sample": True,
+ "pad_token_id": self._tokenizer.pad_token_id,
+ "bos_token_id": self._tokenizer.bos_token_id,
+ "eos_token_id": self._tokenizer.eos_token_id,
+ "temperature": args.temperature,
+ "top_p": args.top_p,
+ "top_k": args.top_k,
+ "min_p": args.min_p,
+ "repetition_penalty": args.repetition_penalty,
+ "cache_implementation": args.cache_implementation,
+ }
+ if args.generation_kwargs is not None:
+ self.generation_kwargs.update(args.generation_kwargs)
+ self.generation_config = GenerationConfig(**self.generation_kwargs, disable_compile=True)
+
+ if hasattr(model, "warnings_issued"):
+ model.warnings_issued["estimate_tokens"] = True
+
+ # Teacher logprobs from the running vLLM generation server (reuses the synced student weights) instead of a
+ # local teacher forward. MVP: `live` teacher only — the generation server holds the current student weights.
+ self.use_teacher_server = args.use_teacher_server
+ if self.use_teacher_server:
+ if not (args.use_vllm and args.vllm_mode == "server"):
+ raise ValueError(
+ "`use_teacher_server=True` requires `use_vllm=True` and `vllm_mode='server'`: teacher logprobs are "
+ "served by the same vLLM server used for generation."
+ )
+ if args.teacher_model_kind != "live":
+ raise ValueError(
+ "`use_teacher_server=True` only supports `teacher_model_kind='live'` (the generation server holds "
+ f"the current student weights), got {args.teacher_model_kind!r}."
+ )
+ if args.distillation_weight != 1.0:
+ raise ValueError(
+ "`use_teacher_server=True` only supports pure self-distillation with `distillation_weight=1.0`, "
+ f"got {args.distillation_weight}. A convex blend with the policy loss needs the full-vocabulary "
+ "logits, which the server does not return."
+ )
+ if args.distillation_mode not in ("sampled_token", "topk_logits"):
+ raise ValueError(
+ "`use_teacher_server=True` only supports `distillation_mode` in {'sampled_token', 'topk_logits'}, "
+ f"got {args.distillation_mode!r}. The server returns the teacher's top-k logprobs, not the full "
+ "vocabulary, so `full_logits` is unavailable. Note `topk_logits` distills over the teacher's own "
+ "top-k support (the server cannot score the student's top-k indices)."
+ )
+ if args.use_liger_kernel:
+ raise ValueError(
+ "`use_teacher_server=True` is incompatible with `use_liger_kernel`: the server returns top-k "
+ "logprobs while the Liger fused loss needs full-vocabulary hidden states."
+ )
+ # Liger fused JSD loss for `full_logits`: same generalized JSD as `compute_divergence`, so alpha maps to beta.
+ self.use_liger_loss = False
+ if args.use_liger_kernel:
+ if not is_liger_kernel_available():
+ raise ImportError(
+ "Liger is required to use `use_liger_kernel` as the self-distillation loss. Run "
+ "`pip install liger-kernel`."
+ )
+ if args.distillation_weight != 1.0:
+ raise ValueError(
+ "`use_liger_kernel` only supports pure self-distillation with `distillation_weight=1.0`, got "
+ f"{args.distillation_weight}. A convex blend with the policy loss needs the policy-gradient term, "
+ "so the fused distillation kernel offers no benefit there."
+ )
+ if args.distillation_mode != "full_logits":
+ raise ValueError(
+ "`use_liger_kernel` only supports `distillation_mode='full_logits'`, got "
+ f"{args.distillation_mode!r}. The fused JSD kernel operates on the full vocabulary and cannot "
+ "express the top-k support or sampled-token objectives."
+ )
+ if args.distillation_is_clip is not None:
+ raise ValueError(
+ "`use_liger_kernel` is incompatible with `distillation_is_clip`: the fused kernel does not expose "
+ "per-token losses for importance-sampling clipping."
+ )
+ if args.loss_type != "bnpo":
+ logger.warning(
+ "The Liger fused loss reduces with a token-level mean (equivalent to `loss_type='bnpo'`); the "
+ f"configured `loss_type={args.loss_type!r}` is ignored on the Liger path."
+ )
+ self.liger_jsd_loss = LigerFusedLinearJSDLoss(
+ beta=args.distillation_alpha,
+ ignore_index=-100,
+ temperature=args.temperature,
+ compiled=False,
+ weight_hard_loss=0.0,
+ weight_soft_loss=1.0,
+ )
+ self._forward_redirection = _ForwardRedirection()
+ self.use_liger_loss = True
+
+ super().__init__(
+ model=model,
+ args=args,
+ data_collator=identity,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=processing_class,
+ callbacks=callbacks,
+ optimizers=optimizers,
+ compute_loss_func="non-None value to disable scaling",
+ )
+
+ self._last_loaded_step = -1 if self.use_vllm else 0
+ if self.use_vllm:
+ from ...generation.vllm_generation import VLLMGeneration
+
+ self.vllm_generation = VLLMGeneration(
+ model=self.model,
+ accelerator=self.accelerator,
+ processing_class=self.processing_class,
+ mode=args.vllm_mode,
+ server_base_url=args.vllm_server_base_url,
+ server_host=args.vllm_server_host,
+ server_port=args.vllm_server_port,
+ group_port=args.vllm_group_port,
+ server_timeout=args.vllm_server_timeout,
+ tensor_parallel_size=args.vllm_tensor_parallel_size,
+ gpu_memory_utilization=args.vllm_gpu_memory_utilization,
+ max_model_length=args.vllm_max_model_length,
+ max_num_seqs=args.per_device_train_batch_size
+ * args.vllm_tensor_parallel_size
+ * args.steps_per_generation,
+ enable_sleep_mode=args.vllm_enable_sleep_mode,
+ model_impl=args.vllm_model_impl,
+ repetition_penalty=args.repetition_penalty,
+ temperature=self.temperature,
+ top_p=args.top_p,
+ top_k=args.top_k,
+ min_p=args.min_p,
+ max_completion_length=self.max_completion_length,
+ logprobs=None,
+ generation_kwargs=args.generation_kwargs,
+ )
+
+ # Per-rank read-only client to the same generation server for teacher scoring (weights are synced there by
+ # `VLLMGeneration`; scoring needs no weight-update communicator). Mirrors the distillation trainer's
+ # `teacher_client`.
+ self.teacher_client = None
+ if self.use_teacher_server:
+ from ...generation.vllm_client import VLLMClient
+
+ base_url = args.vllm_server_base_url or f"http://{args.vllm_server_host}:{args.vllm_server_port}"
+ self.teacher_client = VLLMClient(base_url=base_url, connection_timeout=args.vllm_server_timeout)
+
+ if args.disable_dropout:
+ disable_dropout_in_model(self.model)
+
+ if hasattr(self.model, "add_model_tags"):
+ self.model.add_model_tags(self._tag_names)
+
+ self._setup_teacher_model()
+ self.model_accepts_loss_kwargs = False
+
+ self.importance_sampling_level = args.importance_sampling_level
+ self.scale_rewards = args.scale_rewards
+ self.epsilon_low = args.epsilon
+ self.epsilon_high = args.epsilon_high
+ self.beta = args.beta
+
+ if not isinstance(reward_funcs, list):
+ reward_funcs = [reward_funcs]
+ self.reward_func_names = []
+ for i, reward_func in enumerate(reward_funcs):
+ if isinstance(reward_func, str):
+ reward_model_init_kwargs = args.model_init_kwargs or {}
+ if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]:
+ reward_model_init_kwargs["device_map"] = None
+ reward_model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+ reward_funcs[i] = AutoModelForSequenceClassification.from_pretrained(
+ reward_func,
+ num_labels=1,
+ **reward_model_init_kwargs,
+ )
+ if isinstance(reward_funcs[i], nn.Module):
+ self.reward_func_names.append(get_config_model_id(reward_funcs[i].config).split("/")[-1])
+ else:
+ self.reward_func_names.append(reward_funcs[i].__name__)
+ self.reward_funcs = reward_funcs
+
+ if args.reward_weights is not None:
+ if len(args.reward_weights) != len(self.reward_funcs):
+ raise ValueError("Number of reward weights must match number of reward functions")
+ self.reward_weights = torch.tensor(args.reward_weights, dtype=torch.float32)
+ else:
+ self.reward_weights = torch.ones(len(self.reward_funcs), dtype=torch.float32)
+
+ if reward_processing_classes is None:
+ reward_processing_classes = [None] * len(self.reward_funcs)
+ elif not isinstance(reward_processing_classes, list):
+ reward_processing_classes = [reward_processing_classes]
+ if len(reward_processing_classes) != len(self.reward_funcs):
+ raise ValueError("Number of reward processing classes must match number of reward functions")
+
+ for i, (reward_processing_class, reward_func) in enumerate(
+ zip(reward_processing_classes, self.reward_funcs, strict=True)
+ ):
+ if isinstance(reward_func, PreTrainedModel):
+ if reward_processing_class is None:
+ reward_processing_class = AutoTokenizer.from_pretrained(
+ get_config_model_id(reward_func.config), trust_remote_code=args.trust_remote_code
+ )
+ if reward_processing_class.pad_token_id is None:
+ reward_processing_class.pad_token = reward_processing_class.eos_token
+ reward_func.config.pad_token_id = reward_processing_class.pad_token_id
+ reward_processing_classes[i] = reward_processing_class
+ self.reward_processing_classes = reward_processing_classes
+
+ for i, reward_func in enumerate(self.reward_funcs):
+ if isinstance(reward_func, nn.Module):
+ if self.is_deepspeed_enabled:
+ self.reward_funcs[i] = prepare_deepspeed(reward_func, self.accelerator)
+ elif self.is_fsdp_enabled:
+ self.reward_funcs[i] = prepare_fsdp(reward_func, self.accelerator)
+ else:
+ self.reward_funcs[i] = self.accelerator.prepare_model(reward_func, evaluation_mode=True)
+
+ self.teacher_context_builder = SuccessfulRolloutTeacherContextBuilder(self)
+
+ def _set_signature_columns_if_needed(self):
+ if self._signature_columns is None:
+ self._signature_columns = ["prompt", "privileged_context"]
+
+ def _dispatch_self_distillation_callback(self, event_name: str, **payload) -> None:
+ for callback in self.callback_handler.callbacks:
+ callback_fn = getattr(callback, event_name, None)
+ if callback_fn is not None:
+ callback_fn(
+ args=self.args,
+ state=self.state,
+ control=self.control,
+ model=self.model,
+ processing_class=self.processing_class,
+ **payload,
+ )
+
+ def _setup_teacher_model(self) -> None:
+ """Prepare teacher state according to the semantic teacher choice.
+
+ Resolve `teacher_model_kind` × PEFT state into the effective teacher:
+
+ - `"live"` (any model):
+ Teacher is the student. No divergence, no callback.
+ - `"base"` + PEFT model:
+ Teacher reuses `self.model`; the base weights are recovered downstream by disabling the adapter via
+ `use_adapter` during teacher forward.
+ - `"base"` + non-PEFT model:
+ Teacher is a frozen deepcopy of the initial student (falls through to the copy branch below).
+ - `"ema"` + pure-LoRA training:
+ Teacher reuses `self.model`; a dedicated `"teacher"` LoRA adapter is attached and updated by
+ `PEFTAdapterEMACallback`. Teacher forward switches to that adapter downstream.
+ - `"ema"` (otherwise):
+ Teacher is a frozen deepcopy synchronized each step by `SyncTeacherModelCallback`.
+
+ Must be called after `super().__init__` so that `self.callback_handler` is available.
+ """
+
+ teacher_model_kind = self.args.teacher_model_kind
+
+ if teacher_model_kind == "live":
+ self.teacher_model = self.model
+ return
+
+ if teacher_model_kind == "base" and is_peft_model(self.model):
+ self.teacher_model = self.model
+ return
+
+ if self._use_peft_ema_teacher_adapter():
+ # Must run after super().__init__ so self.callback_handler exists.
+ self.add_callback(
+ PEFTAdapterEMACallback(
+ model=self.model,
+ teacher_adapter_name="teacher",
+ update_rate=self.args.teacher_update_rate,
+ sync_steps=self.args.teacher_sync_steps,
+ accelerator=self.accelerator,
+ )
+ )
+ self.teacher_model = self.model
+ return
+
+ if is_peft_model(self.model):
+ raise ValueError(
+ "`teacher_model_kind='ema'` with a non-pure-LoRA PEFT model is not supported: the separate EMA "
+ "teacher cannot be parameter-matched to the PEFT student. Use pure-LoRA training, a non-PEFT model, "
+ "or `teacher_model_kind` in {'live', 'base'}."
+ )
+
+ # Build the teacher from the model path (like the GRPO/DPO reference model) rather than deep-copying the
+ # student: under ZeRO-3 the student params are already sharded, so a deep copy would clone empty shards.
+ model_init_kwargs = self.args.model_init_kwargs or {}
+ if self.args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]:
+ model_init_kwargs["device_map"] = None
+ model_init_kwargs.setdefault("trust_remote_code", self.args.trust_remote_code)
+ self.teacher_model = create_model_from_path(get_config_model_id(self.model.config), **model_init_kwargs)
+ self.teacher_model.requires_grad_(False)
+ self.teacher_model.eval()
+ if self.is_deepspeed_enabled:
+ self.teacher_model = prepare_deepspeed(self.teacher_model, self.accelerator)
+ elif self.is_fsdp_enabled:
+ self.teacher_model = prepare_fsdp(self.teacher_model, self.accelerator)
+ else:
+ self.teacher_model = self.accelerator.prepare_model(self.teacher_model, evaluation_mode=True)
+
+ if teacher_model_kind == "ema":
+ self.add_callback(SyncTeacherModelCallback(teacher_model=self.teacher_model, accelerator=self.accelerator))
+
+ def _use_peft_ema_teacher_adapter(self) -> bool:
+ return self.args.teacher_model_kind == "ema" and is_pure_lora_training(self.model, self.accelerator)
+
+ def get_train_dataloader(self):
+ if self.train_dataset is None:
+ raise ValueError("Trainer: training requires a train_dataset.")
+
+ train_dataset = self.train_dataset
+ data_collator = self.data_collator
+ if is_datasets_available() and isinstance(train_dataset, datasets.Dataset):
+ train_dataset = self._remove_unused_columns(train_dataset, description="training")
+ else:
+ data_collator = self._get_collator_with_removed_columns(data_collator, description="training")
+
+ dataloader_params = {
+ "batch_size": self._train_batch_size * self.args.steps_per_generation,
+ "collate_fn": data_collator,
+ "num_workers": self.args.dataloader_num_workers,
+ "pin_memory": self.args.dataloader_pin_memory,
+ "persistent_workers": self.args.dataloader_persistent_workers,
+ }
+ if not isinstance(train_dataset, torch.utils.data.IterableDataset):
+ dataloader_params["sampler"] = self._get_train_sampler()
+ dataloader_params["drop_last"] = self.args.dataloader_drop_last
+ dataloader_params["worker_init_fn"] = partial(
+ seed_worker, num_workers=self.args.dataloader_num_workers, rank=self.args.process_index
+ )
+ dataloader_params["prefetch_factor"] = self.args.dataloader_prefetch_factor
+ return self.accelerator.prepare(DataLoader(train_dataset, **dataloader_params))
+
+ def _get_train_sampler(self, dataset=None) -> Sampler:
+ if dataset is None:
+ dataset = self.train_dataset
+ return RepeatSampler(
+ data_source=dataset,
+ mini_repeat_count=self.num_generations,
+ batch_size=self.args.generation_batch_size // self.num_generations,
+ repeat_count=self.num_iterations * self.args.steps_per_generation,
+ shuffle=self.shuffle_dataset,
+ seed=self.args.seed,
+ )
+
+ def _get_eval_sampler(self, eval_dataset) -> Sampler:
+ return RepeatSampler(
+ data_source=eval_dataset,
+ mini_repeat_count=self.num_generations_eval,
+ seed=self.args.seed,
+ )
+
+ def training_step(self, model, inputs, num_items_in_batch):
+ # Gather spans forward+backward: the fused JSD computes the lm_head grad in backward.
+ with self._get_liger_zero3_lm_head_gather_ctx(model):
+ output = super().training_step(model, inputs, num_items_in_batch)
+ self._step += 1
+ return output
+
+ def prediction_step(self, model, inputs, prediction_loss_only, ignore_keys=None):
+ if not isinstance(inputs, dict):
+ inputs = self._prepare_inputs(inputs)
+ with torch.no_grad():
+ with self.compute_loss_context_manager():
+ loss = self.compute_loss(model, inputs)
+ return loss.detach(), None, None
+
+ def _prepare_inputs(self, generation_batch):
+ """Return the per-step training batch, regenerating rollouts and buffering them for reuse in train mode.
+
+ In train mode, rollouts are generated once every `steps_per_generation * num_iterations` steps and split into
+ per-step slices reused until the next regeneration. In eval mode, every batch is freshly prepared.
+ """
+ mode = "train" if self.model.training else "eval"
+ if mode == "train":
+ generate_every = self.args.steps_per_generation * self.num_iterations
+ if self._step % generate_every == 0 or self._buffered_inputs is None:
+ buffered_batch = self._prepare_training_batch(generation_batch)
+ self._buffered_inputs = split_tensor_dict(buffered_batch, self.args.steps_per_generation)
+ self._dispatch_self_distillation_callback(
+ "on_generation_batch_built",
+ generate_every=generate_every,
+ steps_per_generation=self.args.steps_per_generation,
+ )
+ return self._buffered_inputs[self._step % self.args.steps_per_generation]
+ return self._prepare_training_batch(generation_batch)
+
+ def _prepare_training_batch(self, inputs: list[dict[str, Any]]) -> TrainingBatch:
+ """Sample student rollouts, calculate advantage and construct teacher prompts"""
+ device = self.accelerator.device
+ mode = "train" if self.model.training else "eval"
+
+ # Generate student rollouts and decode completions for reward functions
+ batch = self.sample_rollouts(inputs)
+ prompts = [example["prompt"] for example in inputs]
+ privileged_contexts = [example.get("privileged_context") for example in inputs]
+ completion_ids_list = self._get_completion_ids_list(batch)
+ if is_conversational({"prompt": prompts[0]}):
+ completions_text = self.processing_class.batch_decode(batch["completion_ids"], skip_special_tokens=True)
+ completions = [[{"role": "assistant", "content": content}] for content in completions_text]
+ else:
+ completions = self.processing_class.batch_decode(batch["completion_ids"], skip_special_tokens=True)
+
+ # Compute rewards over the globally gathered rollout batch
+ rewards_per_func = self._calculate_rewards(inputs, prompts, completions, completion_ids_list)
+ if rewards_per_func.numel() == 0:
+ rewards = torch.zeros(self.accelerator.num_processes * len(prompts), device=device)
+ else:
+ rewards = (rewards_per_func * self.reward_weights.to(device).unsqueeze(0)).nansum(dim=1)
+
+ # Normalize rewards within generation groups to produce local policy advantages
+ num_generations = self.num_generations if mode == "train" else self.num_generations_eval
+ mean_grouped_rewards = rewards.view(-1, num_generations).mean(dim=1).repeat_interleave(num_generations, dim=0)
+ if self.scale_rewards == "batch":
+ std_rewards = rewards.std().expand_as(rewards) if rewards.numel() > 1 else torch.zeros_like(rewards)
+ group_std_rewards = rewards.view(-1, num_generations).std(dim=1)
+ elif self.scale_rewards == "none":
+ std_rewards = torch.ones_like(rewards)
+ group_std_rewards = torch.ones(rewards.numel() // num_generations, device=device, dtype=rewards.dtype)
+ else:
+ group_std_rewards = rewards.view(-1, num_generations).std(dim=1)
+ std_rewards = group_std_rewards.repeat_interleave(num_generations, dim=0)
+ advantages = (rewards - mean_grouped_rewards) / (std_rewards + 1e-4)
+ local_batch_size = batch["completion_ids"].size(0)
+ process_start = self.accelerator.process_index * local_batch_size
+ process_slice = slice(process_start, process_start + local_batch_size)
+ local_rewards = rewards[process_slice]
+ local_advantages = advantages[process_slice]
+
+ self._record_reward_diagnostics(mode, rewards, rewards_per_func, group_std_rewards)
+ self._record_completion_metrics(mode, batch)
+
+ batch["rewards"] = local_rewards
+ batch["advantages"] = local_advantages
+ teacher_context = self.teacher_context_builder.build(
+ batch,
+ prompts,
+ batch["rewards"],
+ feedbacks=privileged_contexts,
+ )
+
+ for key, value in self.teacher_context_builder.last_metrics.items():
+ self._metrics[mode][key].append(value)
+ self._warn_on_inactive_self_distillation(mode)
+
+ self._dispatch_self_distillation_callback(
+ "on_teacher_context_built",
+ teacher_input_ids=teacher_context["teacher_input_ids"],
+ teacher_attention_mask=teacher_context["teacher_attention_mask"],
+ completion_mask=batch["completion_mask"],
+ self_distillation_mask=teacher_context["self_distillation_mask"],
+ )
+
+ batch.update(
+ {
+ "teacher_input_ids": teacher_context["teacher_input_ids"],
+ "teacher_attention_mask": teacher_context["teacher_attention_mask"],
+ "self_distillation_mask": teacher_context["self_distillation_mask"],
+ }
+ )
+
+ self._dispatch_self_distillation_callback(
+ "on_self_distillation_batch_prepared",
+ old_per_token_logps=batch.get("old_per_token_logps"),
+ prompt_ids=batch["prompt_ids"],
+ completion_ids=batch["completion_ids"],
+ teacher_input_ids=batch["teacher_input_ids"],
+ teacher_attention_mask=batch["teacher_attention_mask"],
+ self_distillation_mask=batch.get("self_distillation_mask"),
+ )
+ return batch
+
+ def sample_rollouts(self, inputs: list[dict[str, Any]]) -> TrainingBatch:
+ """Generate completions for a batch of prompts and assemble the training batch."""
+ prompts = [example["prompt"] for example in inputs]
+ prompt_ids = self._tokenize_prompts(prompts)
+ self._dispatch_self_distillation_callback(
+ "on_generation_prompts_selected",
+ generation_prompts=prompts,
+ generation_prompt_text=None,
+ )
+
+ prompt_ids_list, completion_ids_list = self._generate(prompt_ids)
+ device = self.accelerator.device
+ prompt_ids = [torch.tensor(ids) for ids in prompt_ids_list]
+ prompt_mask = [torch.ones_like(ids, dtype=torch.long) for ids in prompt_ids]
+ prompt_ids = pad(prompt_ids, padding_value=self._tokenizer.pad_token_id, padding_side="left").to(device=device)
+ prompt_mask = pad(prompt_mask, padding_value=0, padding_side="left").to(device=device)
+
+ completion_ids = [torch.tensor(ids) for ids in completion_ids_list]
+ completion_mask = [torch.ones_like(ids, dtype=torch.long) for ids in completion_ids]
+ completion_ids = pad(completion_ids, padding_value=self._tokenizer.pad_token_id, padding_side="right").to(
+ device=device
+ )
+ completion_mask = pad(completion_mask, padding_value=0, padding_side="right").to(device=device)
+
+ if self.mask_truncated_completions:
+ eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id]
+ is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids_list], device=device)
+ completion_mask = completion_mask * (~is_truncated).unsqueeze(1).int()
+
+ old_per_token_logps = self._compute_rollout_logps(
+ prompt_ids=prompt_ids,
+ prompt_mask=prompt_mask,
+ completion_ids=completion_ids,
+ completion_mask=completion_mask,
+ )
+ batch: TrainingBatch = {
+ "prompt_ids": prompt_ids,
+ "prompt_mask": prompt_mask,
+ "completion_ids": completion_ids,
+ "completion_mask": completion_mask,
+ "raw_completion_lengths": torch.tensor(
+ [len(ids) for ids in completion_ids_list], device=device, dtype=torch.long
+ ),
+ }
+ if old_per_token_logps is not None:
+ batch["old_per_token_logps"] = old_per_token_logps
+ return batch
+
+ def _get_completion_ids_list(self, batch: TrainingBatch) -> list[list[int]]:
+ raw_completion_lengths = batch["raw_completion_lengths"].detach().cpu().tolist()
+ return [
+ ids[:length].tolist()
+ for ids, length in zip(batch["completion_ids"].detach().cpu(), raw_completion_lengths, strict=True)
+ ]
+
+ def _tokenize_prompts_untruncated(self, prompts: list[Any]) -> list[list[int]]:
+ if is_conversational({"prompt": prompts[0]}):
+ tokenized = self.processing_class.apply_chat_template(
+ conversation=prompts,
+ add_generation_prompt=True,
+ tokenize=True,
+ return_dict=True,
+ **self.chat_template_kwargs,
+ )
+ prompt_ids = tokenized["input_ids"]
+ else:
+ prompt_ids = self.processing_class(text=prompts)["input_ids"]
+ return prompt_ids
+
+ def _tokenize_prompts(self, prompts: list[Any]) -> list[list[int]]:
+ prompt_ids = self._tokenize_prompts_untruncated(prompts)
+ if self.max_prompt_length is not None:
+ prompt_ids = [ids[-self.max_prompt_length :] for ids in prompt_ids]
+ return prompt_ids
+
+ def _generate(self, prompt_ids: list[list[int]]) -> tuple[list[list[int]], list[list[int]]]:
+ if self.use_vllm:
+ return self._generate_vllm(prompt_ids)
+ return self._generate_transformers(prompt_ids)
+
+ def _generate_vllm(self, prompt_ids: list[list[int]]) -> tuple[list[list[int]], list[list[int]]]:
+ if self.state.global_step != self._last_loaded_step:
+ self.vllm_generation.sync_weights()
+ self._last_loaded_step = self.state.global_step
+
+ mode = "train" if self.model.training else "eval"
+ num_generations = self.num_generations if mode == "train" else self.num_generations_eval
+ prompt_ids_out, completion_ids_list, _, _ = self.vllm_generation.generate(
+ prompts=prompt_ids,
+ images=None,
+ num_generations=num_generations,
+ )
+ return prompt_ids_out, completion_ids_list
+
+ def _generate_transformers(self, prompt_ids: list[list[int]]) -> tuple[list[list[int]], list[list[int]]]:
+ device = self.accelerator.device
+ prompt_tensors = [torch.tensor(ids) for ids in prompt_ids]
+ padded_ids = pad(prompt_tensors, padding_value=self._tokenizer.pad_token_id, padding_side="left").to(
+ device=device
+ )
+ attention_mask = pad([torch.ones_like(t) for t in prompt_tensors], padding_value=0, padding_side="left").to(
+ device=device
+ )
+ generate_inputs: dict[str, torch.Tensor | Any] = {"input_ids": padded_ids, "attention_mask": attention_mask}
+
+ with (
+ unwrap_model_for_generation(
+ self.model_wrapped,
+ self.accelerator,
+ gather_deepspeed3_params=self.args.ds3_gather_for_generation,
+ generation_kwargs=self.generation_kwargs,
+ ) as unwrapped_model,
+ torch.no_grad(),
+ FSDP.summon_full_params(self.model_wrapped, recurse=False) if self.is_fsdp_enabled else nullcontext(),
+ ):
+ prompt_completion_ids = unwrapped_model.generate(
+ **generate_inputs, generation_config=self.generation_config
+ )
+
+ prompt_length = generate_inputs["input_ids"].size(1)
+ completion_ids = prompt_completion_ids[:, prompt_length:]
+ is_eos = completion_ids == self._tokenizer.eos_token_id
+ eos_idx = torch.full((is_eos.size(0),), is_eos.size(1), dtype=torch.long, device=device)
+ eos_idx[is_eos.any(dim=1)] = is_eos.int().argmax(dim=1)[is_eos.any(dim=1)]
+ seq_idx = torch.arange(is_eos.size(1), device=device).expand(is_eos.size(0), -1)
+ completion_mask = (seq_idx <= eos_idx.unsqueeze(1)).int()
+ completion_ids_list = [
+ c[m].tolist() for c, m in zip(completion_ids.cpu(), completion_mask.bool().cpu(), strict=True)
+ ]
+ return prompt_ids, completion_ids_list
+
+ def _compute_rollout_logps(
+ self,
+ prompt_ids: torch.Tensor,
+ prompt_mask: torch.Tensor,
+ completion_ids: torch.Tensor,
+ completion_mask: torch.Tensor,
+ ) -> torch.Tensor | None:
+ generate_every = self.args.steps_per_generation * self.num_iterations
+ old_per_token_logps = None
+
+ if self.args.gradient_accumulation_steps % generate_every != 0:
+ prompt_completion_ids = torch.cat([prompt_ids, completion_ids], dim=1)
+ attention_mask = torch.cat([prompt_mask, completion_mask], dim=1)
+ logits_to_keep = completion_ids.size(1)
+ with torch.no_grad():
+ logits = self._forward_logits(
+ self.model,
+ prompt_completion_ids,
+ attention_mask,
+ logits_to_keep,
+ )
+ old_per_token_logps = selective_log_softmax(logits, completion_ids)
+
+ return old_per_token_logps
+
+ def _calculate_rewards(self, inputs, prompts, completions, completion_ids_list):
+ device = self.accelerator.device
+ if len(self.reward_funcs) == 0:
+ return torch.zeros((len(prompts), 0), device=device)
+
+ rewards_per_func = torch.zeros(len(prompts), len(self.reward_funcs), device=device)
+ keys = [key for key in inputs[0] if key not in ["prompt", "completion", "completion_ids"]]
+ reward_kwargs = {key: [example[key] for example in inputs] for key in keys}
+ reward_kwargs["trainer_state"] = self.state
+
+ for i, (reward_func, reward_processing_class) in enumerate(
+ zip(self.reward_funcs, self.reward_processing_classes, strict=True)
+ ):
+ if isinstance(reward_func, nn.Module):
+ if is_conversational(inputs[0]):
+ messages = [{"messages": p + c} for p, c in zip(prompts, completions, strict=True)]
+ texts = [
+ apply_chat_template(x, reward_processing_class, **self.chat_template_kwargs)["text"]
+ for x in messages
+ ]
+ else:
+ texts = [p + c for p, c in zip(prompts, completions, strict=True)]
+ reward_inputs = reward_processing_class(
+ text=texts,
+ return_tensors="pt",
+ padding=True,
+ padding_side="right",
+ add_special_tokens=False,
+ )
+ reward_inputs = _BaseTrainer._prepare_inputs(self, reward_inputs)
+ with torch.inference_mode():
+ rewards_per_func[:, i] = reward_func(**reward_inputs).logits[:, 0]
+ else:
+ output_reward_func = reward_func(
+ prompts=prompts,
+ completions=completions,
+ completion_ids=completion_ids_list,
+ **reward_kwargs,
+ )
+ output_reward_func = [reward if reward is not None else torch.nan for reward in output_reward_func]
+ rewards_per_func[:, i] = torch.tensor(output_reward_func, dtype=torch.float32, device=device)
+
+ return self.accelerator.gather(rewards_per_func)
+
+ def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
+ if return_outputs:
+ raise ValueError("The SDPOTrainer does not support returning outputs")
+
+ if self.args.distillation_weight == 1.0:
+ if self.use_teacher_server:
+ loss = self._compute_server_distillation_loss(model, inputs)
+ elif self.use_liger_loss:
+ accumulation_scale = self.current_gradient_accumulation_steps if self.model.training else 1.0
+ return self._compute_liger_loss(model, inputs) / accumulation_scale
+ else:
+ distillation_logits = self._compute_teacher_student_logits(model, self.teacher_model, inputs)
+ loss = self._compute_self_distillation_loss(model, inputs, distillation_logits)
+ elif self.args.distillation_weight == 0.0:
+ student_input_ids = torch.cat([inputs["prompt_ids"], inputs["completion_ids"]], dim=1)
+ student_attention_mask = torch.cat([inputs["prompt_mask"], inputs["completion_mask"]], dim=1)
+ student_logits = self._forward_logits(
+ model=model,
+ input_ids=student_input_ids,
+ attention_mask=student_attention_mask,
+ logits_to_keep=inputs["completion_ids"].size(1),
+ )
+ loss = self._compute_policy_loss(inputs, student_logits)
+ else:
+ distillation_logits = self._compute_teacher_student_logits(model, self.teacher_model, inputs)
+ policy_loss = self._compute_policy_loss(inputs, distillation_logits.student_logits)
+ distillation_loss = self._compute_self_distillation_loss(model, inputs, distillation_logits)
+ loss = (
+ 1 - self.args.distillation_weight
+ ) * policy_loss + self.args.distillation_weight * distillation_loss
+
+ accumulation_scale = self.current_gradient_accumulation_steps if self.model.training else 1.0
+ return loss / accumulation_scale
+
+ def _compute_policy_loss(
+ self,
+ inputs,
+ student_logits,
+ ) -> torch.Tensor:
+ completion_ids = inputs["completion_ids"]
+ completion_mask = inputs["completion_mask"]
+ per_token_logps = selective_log_softmax(student_logits, completion_ids)
+ old_per_token_logps = inputs.get("old_per_token_logps")
+ old_per_token_logps = per_token_logps.detach() if old_per_token_logps is None else old_per_token_logps
+ advantages = inputs["advantages"]
+ if advantages.dim() == 1:
+ advantages = advantages.unsqueeze(1)
+ log_ratio = per_token_logps - old_per_token_logps
+ if self.importance_sampling_level == "sequence":
+ log_ratio = (log_ratio * completion_mask).sum(-1, keepdim=True) / completion_mask.sum(
+ -1, keepdim=True
+ ).clamp(min=1.0)
+ coef_1 = torch.exp(log_ratio)
+ coef_2 = torch.clamp(coef_1, 1 - self.epsilon_low, 1 + self.epsilon_high)
+ per_token_loss = -torch.min(coef_1 * advantages, coef_2 * advantages)
+
+ if self.loss_type == "grpo":
+ loss = (per_token_loss * completion_mask).sum(-1) / completion_mask.sum(-1).clamp(min=1.0)
+ loss = loss.mean()
+ elif self.loss_type == "bnpo":
+ loss = (per_token_loss * completion_mask).sum() / completion_mask.sum().clamp(min=1.0)
+ elif self.loss_type == "dr_grpo":
+ loss = (per_token_loss * completion_mask).sum() / (per_token_loss.size(0) * self.max_completion_length)
+ elif self.loss_type == "dapo":
+ loss = (per_token_loss * completion_mask).sum() / completion_mask.sum().clamp(min=1.0)
+ else:
+ raise ValueError(f"Unsupported loss_type: {self.loss_type}")
+
+ mode = "train" if self.model.training else "eval"
+ self._metrics[mode]["self_distillation/policy_loss"].append(
+ self.accelerator.gather(loss.detach()).mean().item()
+ )
+
+ return loss
+
+ def _compute_self_distillation_loss(
+ self,
+ model,
+ inputs: TrainingBatch,
+ distillation_logits: DistillationLogits,
+ ) -> torch.Tensor:
+ """Compute the per-token distillation loss and aggregate by normalizing over sequence length.
+
+ Dispatches between three objectives based on `distillation_mode`:
+
+ - `"topk_logits"`: top-k approximation of the divergence, optionally with a tail bucket for the remaining
+ probability mass (`distillation_add_tail`).
+ - `"full_logits"`: full-vocab divergence.
+ - `"sampled_token"`: token-level (reverse-KL) distillation on sampled `completion_ids`.
+
+ When `distillation_is_clip` is set and `old_per_token_logps` are available, the loss is corrected by a clipped
+ importance-sampling ratio between the current student and the student at rollout time.
+ """
+ if distillation_logits.loss_mask.sum() == 0:
+ mode = "train" if model.training else "eval"
+ self._log_self_distillation_metric(mode, 0.0)
+ # Keep the zero loss attached to the student graph so backward produces zero gradients instead of stopping.
+ return distillation_logits.student_logits.sum() * 0.0
+
+ if self.args.distillation_mode == "topk_logits":
+ if self.args.distillation_topk is None:
+ raise ValueError("`distillation_mode='topk_logits'` requires `distillation_topk` to be set.")
+ per_token_loss = compute_topk_self_distillation_loss(
+ distillation_logits.student_logits,
+ distillation_logits.teacher_logits,
+ distillation_topk=self.args.distillation_topk,
+ distillation_alpha=self.args.distillation_alpha,
+ distillation_add_tail=self.args.distillation_add_tail,
+ )
+ elif self.args.distillation_mode == "full_logits":
+ per_token_loss = compute_full_logit_self_distillation_loss(
+ distillation_logits.student_logits,
+ distillation_logits.teacher_logits,
+ distillation_alpha=self.args.distillation_alpha,
+ )
+ elif self.args.distillation_mode == "sampled_token":
+ per_token_loss = compute_sampled_token_self_distillation_loss(
+ distillation_logits.student_logits,
+ distillation_logits.teacher_logits,
+ distillation_logits.completion_ids,
+ distillation_alpha=self.args.distillation_alpha,
+ )
+ else:
+ raise ValueError(
+ "distillation_mode must be one of: 'sampled_token', 'full_logits', 'topk_logits', "
+ f"got {self.args.distillation_mode!r}"
+ )
+
+ old_per_token_logps = inputs.get("old_per_token_logps")
+ if self.args.distillation_is_clip is not None and old_per_token_logps is not None:
+ student_per_token_logps = selective_log_softmax(
+ distillation_logits.student_logits,
+ distillation_logits.completion_ids,
+ )
+ per_token_loss = apply_importance_sampling_clipping(
+ per_token_loss,
+ student_per_token_logps,
+ old_per_token_logps,
+ self.args.distillation_is_clip,
+ )
+
+ loss = (per_token_loss * distillation_logits.loss_mask).sum(-1) / distillation_logits.loss_mask.sum(-1).clamp(
+ min=1.0
+ )
+ loss = loss.mean()
+
+ mode = "train" if model.training else "eval"
+ mean_distill_loss = (
+ per_token_loss * distillation_logits.loss_mask
+ ).sum() / distillation_logits.loss_mask.sum().clamp(min=1.0)
+ self._log_self_distillation_metric(
+ mode,
+ self.accelerator.gather(mean_distill_loss).mean().item(),
+ )
+ return loss
+
+ def _compute_server_distillation_loss(self, model, inputs: TrainingBatch) -> torch.Tensor:
+ """Distillation loss with teacher logprobs served by the vLLM generation server (`teacher_model_kind='live'`).
+
+ The student is forwarded locally (grad) for its logits; the teacher logprobs are fetched from the server (no
+ local teacher forward). `sampled_token` distills the realized token (reverse KL); `topk_logits` distills over
+ the teacher's own top-k support (the server cannot score the student's top-k indices).
+ """
+ # Buffered batches are reused across optimizer steps (`num_iterations > 1`), so the server weights can lag the
+ # live student; re-sync before scoring.
+ if self.state.global_step != self._last_loaded_step:
+ self.vllm_generation.sync_weights()
+ # Only the main process pushes weights to the server, so hold every rank here until the push completes;
+ # otherwise non-main ranks could score against half-updated weights.
+ self.accelerator.wait_for_everyone()
+ self._last_loaded_step = self.state.global_step
+
+ completion_ids = inputs["completion_ids"]
+ completion_mask = inputs["completion_mask"]
+ logits_to_keep = completion_ids.size(1)
+
+ self_distillation_mask = inputs.get("self_distillation_mask")
+ if self_distillation_mask is None:
+ loss_mask = completion_mask
+ else:
+ loss_mask = completion_mask * self_distillation_mask.unsqueeze(1)
+
+ student_input_ids = torch.cat([inputs["prompt_ids"], completion_ids], dim=1)
+ student_attention_mask = torch.cat([inputs["prompt_mask"], completion_mask], dim=1)
+ student_logits = self._forward_logits(
+ model=model,
+ input_ids=student_input_ids,
+ attention_mask=student_attention_mask,
+ logits_to_keep=logits_to_keep,
+ )
+
+ mode = "train" if model.training else "eval"
+ teacher = self._get_teacher_token_logprobs_from_server(inputs, logits_to_keep)
+ # Padding positions come back as `-inf`; the masked-out positions are neutralized to finite values below so the
+ # divergence does not leak `+inf` through them (mirrors the distillation trainer).
+ required = loss_mask.bool()
+ student_per_token_logps = selective_log_softmax(student_logits, completion_ids)
+
+ teacher_per_token_logps = teacher["actual_logprobs"]
+ if (required & ~torch.isfinite(teacher_per_token_logps)).any():
+ raise ValueError("Teacher server returned no logprob for a required completion token.")
+ teacher_per_token_logps = torch.where(
+ required, teacher_per_token_logps, torch.zeros_like(teacher_per_token_logps)
+ )
+
+ # Diagnostic for disagreement between local student scores and server teacher scores on realized tokens.
+ # Sudden jumps can indicate stale server weights or numerical drift.
+ abs_diff = ((student_per_token_logps.detach() - teacher_per_token_logps).abs() * loss_mask).sum() / (
+ loss_mask.sum().clamp(min=1.0)
+ )
+ self._metrics[mode]["self_distillation/server_logprob_abs_diff"].append(
+ self.accelerator.gather(abs_diff).mean().item()
+ )
+
+ if self.args.distillation_mode == "sampled_token":
+ # Reverse-KL token-level objective, matching `compute_sampled_token_self_distillation_loss`.
+ per_token_loss = (student_per_token_logps - teacher_per_token_logps).detach() * student_per_token_logps
+ else:
+ teacher_topk_logps = teacher["topk_logprobs"]
+ teacher_topk_ids = teacher["topk_token_ids"]
+ # Project the student onto the teacher's top-k support, then renormalize (or add a tail bucket) before the
+ # divergence, matching `compute_topk_self_distillation_loss` on the teacher's support.
+ keep = required.unsqueeze(-1)
+ student_topk_logps = torch.gather(
+ torch.log_softmax(student_logits, dim=-1), dim=-1, index=teacher_topk_ids
+ )
+ student_topk_logps = torch.where(keep, student_topk_logps, torch.zeros_like(student_topk_logps))
+ teacher_topk_logps = torch.where(keep, teacher_topk_logps, torch.zeros_like(teacher_topk_logps))
+ if self.args.distillation_add_tail:
+ student_topk_logps = add_tail_bucket(student_topk_logps)
+ teacher_topk_logps = add_tail_bucket(teacher_topk_logps)
+ else:
+ student_topk_logps = student_topk_logps - torch.logsumexp(student_topk_logps, dim=-1, keepdim=True)
+ teacher_topk_logps = teacher_topk_logps - torch.logsumexp(teacher_topk_logps, dim=-1, keepdim=True)
+ per_token_loss = compute_divergence(student_topk_logps, teacher_topk_logps, self.args.distillation_alpha)
+
+ old_per_token_logps = inputs.get("old_per_token_logps")
+ if self.args.distillation_is_clip is not None and old_per_token_logps is not None:
+ per_token_loss = apply_importance_sampling_clipping(
+ per_token_loss, student_per_token_logps, old_per_token_logps, self.args.distillation_is_clip
+ )
+
+ loss = (per_token_loss * loss_mask).sum(-1) / loss_mask.sum(-1).clamp(min=1.0)
+ loss = loss.mean()
+ mean_distill_loss = (per_token_loss * loss_mask).sum() / loss_mask.sum().clamp(min=1.0)
+ self._log_self_distillation_metric(mode, self.accelerator.gather(mean_distill_loss).mean().item())
+ return loss
+
+ def _get_teacher_token_logprobs_from_server(
+ self, inputs: TrainingBatch, logits_to_keep: int
+ ) -> dict[str, torch.Tensor]:
+ """Per-token teacher logprobs from the vLLM server.
+
+ Returns a dict with `actual_logprobs` (`(B, T)`, the realized-token logprob for reverse KL) and `topk_logprobs`
+ / `topk_token_ids` (`(B, T, K)`, the teacher's top-k support for top-k logit distillation). Completions are
+ right-padded, so server values fill the leading positions of each row and the trailing padding keeps the `-inf`
+ / `0` sentinels (neutralized by the caller).
+ """
+ import numpy as np
+
+ teacher_input_ids = inputs["teacher_input_ids"]
+ teacher_attention_mask = inputs["teacher_attention_mask"]
+ device = teacher_input_ids.device
+ batch_size = teacher_input_ids.size(0)
+ prompt_attention_mask = teacher_attention_mask[:, : teacher_attention_mask.size(1) - logits_to_keep]
+ if self.args.distillation_mode == "topk_logits" and self.args.distillation_topk is None:
+ raise ValueError("`distillation_mode='topk_logits'` requires `distillation_topk` to be set.")
+ top_logprobs = self.args.distillation_topk if self.args.distillation_mode == "topk_logits" else 1
+
+ sequences, prompt_lengths, _ = build_teacher_request_inputs(
+ teacher_input_ids, teacher_attention_mask, prompt_attention_mask
+ )
+ result = self.teacher_client.get_sequence_logprobs(
+ sequences=sequences,
+ prompt_lengths=prompt_lengths,
+ top_logprobs=top_logprobs,
+ temperature=self.temperature,
+ )
+
+ actual = np.full((batch_size, logits_to_keep), float("-inf"), dtype=np.float32)
+ topk = np.full((batch_size, logits_to_keep, top_logprobs), float("-inf"), dtype=np.float32)
+ topk_ids = np.zeros((batch_size, logits_to_keep, top_logprobs), dtype=np.int64)
+ for i in range(batch_size):
+ seq_actual = result["actual_logprobs"][i]
+ n = min(len(seq_actual), logits_to_keep)
+ if n:
+ actual[i, :n] = np.array(seq_actual, dtype=np.float32)[:n, 0]
+ topk[i, :n] = np.array(result["logprobs"][i], dtype=np.float32)[:n]
+ topk_ids[i, :n] = np.array(result["logprob_token_ids"][i], dtype=np.int64)[:n]
+ return {
+ "actual_logprobs": torch.from_numpy(actual).to(device),
+ "topk_logprobs": torch.from_numpy(topk).to(device),
+ "topk_token_ids": torch.from_numpy(topk_ids).to(device),
+ }
+
+ def _compute_teacher_student_logits(
+ self,
+ model,
+ teacher_model,
+ inputs: TrainingBatch,
+ ) -> DistillationLogits:
+ """Compute the per-token logits of the student and teacher over the completion tokens.
+
+ The student is forwarded on its own input (original prompt plus the sampled completion) while the teacher is
+ forwarded on its input (prompt, privileged context, and the same completion). Both sets of logits are aligned
+ to the completion tokens so they can be compared position-by-position in the distillation loss.
+
+ The teacher forward runs under `torch.no_grad()` and the context resolved by
+ `_get_teacher_context_for_self_distillation`, which routes it to the correct weights.
+ """
+ prompt_ids = inputs["prompt_ids"]
+ prompt_mask = inputs["prompt_mask"]
+ completion_ids = inputs["completion_ids"]
+ completion_mask = inputs["completion_mask"]
+ logits_to_keep = completion_ids.size(1)
+
+ self_distillation_mask = inputs.get("self_distillation_mask")
+ if self_distillation_mask is None:
+ loss_mask = completion_mask
+ else:
+ loss_mask = completion_mask * self_distillation_mask.unsqueeze(1)
+ student_input_ids = torch.cat([prompt_ids, completion_ids], dim=1)
+ student_attention_mask = torch.cat([prompt_mask, completion_mask], dim=1)
+ student_logits = self._forward_logits(
+ model=model,
+ input_ids=student_input_ids,
+ attention_mask=student_attention_mask,
+ logits_to_keep=logits_to_keep,
+ )
+
+ with torch.no_grad(), self._get_teacher_context_for_self_distillation():
+ teacher_logits = self._forward_logits(
+ model=teacher_model,
+ input_ids=inputs["teacher_input_ids"],
+ attention_mask=inputs["teacher_attention_mask"],
+ logits_to_keep=logits_to_keep,
+ )
+
+ return DistillationLogits(
+ completion_ids=completion_ids,
+ completion_mask=completion_mask,
+ loss_mask=loss_mask,
+ student_logits=student_logits,
+ teacher_logits=teacher_logits,
+ )
+
+ def _forward_logits(
+ self,
+ model,
+ input_ids: torch.Tensor,
+ attention_mask: torch.Tensor,
+ logits_to_keep: int,
+ ) -> torch.Tensor:
+ """Forward the model and return temperature-scaled logits aligned to the completion tokens."""
+ model_inputs = {
+ "input_ids": input_ids,
+ "attention_mask": attention_mask,
+ "use_cache": False,
+ }
+ if "logits_to_keep" in self.model_kwarg_keys:
+ model_inputs["logits_to_keep"] = logits_to_keep + 1
+
+ logits = model(**model_inputs).logits
+ logits = logits[:, :-1, :]
+ logits = logits[:, -logits_to_keep:, :]
+ return logits / self.temperature
+
+ def _compute_liger_loss(self, model, inputs: TrainingBatch) -> torch.Tensor:
+ """`full_logits` distillation via the Liger fused JSD kernel: forwards the base models for hidden states and
+ fuses the lm_head projection with the divergence, never materializing the full-vocab logits.
+
+ Each model is forwarded through its own wrapper via `_forward_redirection` so FSDP2/DeepSpeed materialize the
+ sharded params during the unwrapped base forward. The fused kernel needs both lm_head weights live at once, so
+ the frozen teacher weight is captured while the teacher is materialized and handed to the student pass.
+ """
+ logits_to_keep = inputs["completion_ids"].size(1)
+ self_distillation_mask = inputs.get("self_distillation_mask")
+ if self_distillation_mask is None:
+ loss_mask = inputs["completion_mask"]
+ else:
+ loss_mask = inputs["completion_mask"] * self_distillation_mask.unsqueeze(1)
+
+ unwrapped_student = self.accelerator.unwrap_model(model)
+ unwrapped_teacher = self.accelerator.unwrap_model(self.teacher_model)
+
+ with torch.no_grad(), self._get_teacher_context_for_self_distillation():
+ teacher_hidden, teacher_weight, teacher_bias = self._forward_redirection(
+ self.teacher_model,
+ unwrapped_teacher,
+ self._liger_teacher_side,
+ unwrapped_teacher,
+ inputs,
+ logits_to_keep,
+ )
+
+ return self._forward_redirection(
+ model,
+ unwrapped_student,
+ self._liger_student_loss,
+ unwrapped_student,
+ inputs,
+ logits_to_keep,
+ loss_mask,
+ teacher_hidden,
+ teacher_weight,
+ teacher_bias,
+ )
+
+ def _liger_teacher_side(self, teacher, inputs: TrainingBatch, logits_to_keep: int):
+ """Teacher hidden states + frozen lm_head weight, captured while the teacher params are materialized."""
+ hidden = teacher.get_decoder()(
+ input_ids=inputs["teacher_input_ids"],
+ attention_mask=inputs["teacher_attention_mask"],
+ use_cache=False,
+ ).last_hidden_state
+ hidden = hidden[:, :-1][:, -logits_to_keep:]
+ head = teacher.get_output_embeddings()
+ # Clone so the weight survives re-sharding once this forward context exits.
+ weight = head.weight.detach().clone()
+ bias = head.bias.detach().clone() if head.bias is not None else None
+ return hidden, weight, bias
+
+ def _liger_student_loss(
+ self,
+ student,
+ inputs: TrainingBatch,
+ logits_to_keep,
+ loss_mask,
+ teacher_hidden,
+ teacher_weight,
+ teacher_bias,
+ ):
+ student_input_ids = torch.cat([inputs["prompt_ids"], inputs["completion_ids"]], dim=1)
+ student_attention_mask = torch.cat([inputs["prompt_mask"], inputs["completion_mask"]], dim=1)
+ student_hidden = student.get_decoder()(
+ input_ids=student_input_ids,
+ attention_mask=student_attention_mask,
+ use_cache=False,
+ ).last_hidden_state
+ # Align hidden states to the completion-predicting positions, matching `_forward_logits`.
+ student_hidden = student_hidden[:, :-1][:, -logits_to_keep:]
+
+ # `ignore_index` masks non-response positions; the token values only feed the disabled hard-CE term.
+ completion_ids = inputs["completion_ids"]
+ true_labels = torch.where(loss_mask.bool(), completion_ids, torch.full_like(completion_ids, -100))
+
+ student_head = student.get_output_embeddings()
+ # Per-sequence then batch mean (grpo), matching the non-Liger path: the fused kernel reduces by total tokens
+ # (bnpo), so we call it per sequence and average.
+ seq_losses = [
+ self.liger_jsd_loss(
+ student_input=student_hidden[i],
+ student_weight=student_head.weight,
+ teacher_input=teacher_hidden[i],
+ teacher_weight=teacher_weight,
+ true_labels=true_labels[i],
+ student_bias=student_head.bias,
+ teacher_bias=teacher_bias,
+ )
+ for i in range(student_hidden.size(0))
+ ]
+ loss = torch.stack(seq_losses).mean()
+
+ mode = "train" if student.training else "eval"
+ self._log_self_distillation_metric(mode, self.accelerator.gather(loss.detach()).mean().item())
+ return loss
+
+ def _get_liger_zero3_lm_head_gather_ctx(self, model):
+ """Gather the sharded student/teacher lm_head weights for the fused matmul under ZeRO-3. Liger reads
+ `lm_head.weight` by attribute, so the gather hook never fires; the decoder forward gathers itself. No-op
+ outside ZeRO-3."""
+ if not self.use_liger_loss:
+ return nullcontext()
+
+ deepspeed_plugin = self.accelerator.state.deepspeed_plugin
+ if deepspeed_plugin is None or deepspeed_plugin.zero_stage != 3:
+ return nullcontext()
+
+ import deepspeed
+
+ unwrapped_student = self.accelerator.unwrap_model(model)
+ unwrapped_teacher = self.accelerator.unwrap_model(self.teacher_model)
+ student_head = unwrapped_student.get_output_embeddings()
+ teacher_head = unwrapped_teacher.get_output_embeddings()
+ params = [student_head.weight, teacher_head.weight]
+ if student_head.bias is not None:
+ params.append(student_head.bias)
+ if teacher_head.bias is not None:
+ params.append(teacher_head.bias)
+ return deepspeed.zero.GatheredParameters(params, modifier_rank=None)
+
+ def _get_teacher_context_for_self_distillation(self):
+ """Return the context manager that routes the teacher forward to the correct weights.
+
+ For non-PEFT models this is a no-op. For PEFT models:
+
+ - `teacher_model_kind == "base"`: disable the student adapter so the teacher forward uses the base weights.
+ - `teacher_model_kind == "ema"` under pure-LoRA training: switch to the `"teacher"` LoRA adapter.
+ - otherwise: no-op; the teacher is a separate deepcopy.
+ """
+ teacher_model_kind = self.args.teacher_model_kind
+ if not is_peft_model(self.model):
+ return nullcontext()
+
+ target_model = self.accelerator.unwrap_model(self.teacher_model)
+
+ if teacher_model_kind == "base":
+ return use_adapter(target_model, adapter_name=None)
+ if teacher_model_kind == "ema" and self._use_peft_ema_teacher_adapter():
+ return use_adapter(target_model, adapter_name="teacher")
+ return nullcontext()
+
+ def _record_completion_metrics(self, mode: str, batch: TrainingBatch) -> None:
+ device = self.accelerator.device
+ completion_ids_list = self._get_completion_ids_list(batch)
+ agg_completion_lengths = self.accelerator.gather(batch["raw_completion_lengths"])
+ self._metrics[mode]["completions/mean_length"].append(agg_completion_lengths.float().mean().item())
+ self._metrics[mode]["completions/min_length"].append(agg_completion_lengths.float().min().item())
+ self._metrics[mode]["completions/max_length"].append(agg_completion_lengths.float().max().item())
+
+ eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id]
+ is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids_list], device=device)
+ agg_is_truncated = self.accelerator.gather(is_truncated)
+ self._metrics[mode]["completions/clipped_ratio"].append(agg_is_truncated.float().mean().item())
+ term_completion_lengths = agg_completion_lengths[~agg_is_truncated]
+ if len(term_completion_lengths) == 0:
+ term_completion_lengths = torch.zeros(1, device=device)
+ self._metrics[mode]["completions/mean_terminated_length"].append(term_completion_lengths.float().mean().item())
+ self._metrics[mode]["completions/min_terminated_length"].append(term_completion_lengths.float().min().item())
+ self._metrics[mode]["completions/max_terminated_length"].append(term_completion_lengths.float().max().item())
+
+ def _log_self_distillation_metric(self, mode: str, value: float) -> None:
+ metric_prefix = self._name.lower().replace(" ", "_")
+ self._metrics[mode]["self_distillation/distillation_loss"].append(value)
+ self._metrics[mode][f"{metric_prefix}/distillation_loss"].append(value)
+
+ def log(self, logs: dict[str, float], start_time: float | None = None) -> None:
+ mode = "train" if self.model.training else "eval"
+ # Average the metrics
+ metrics = {}
+ for key, val in self._metrics[mode].items():
+ # Filter out NaN values before averaging. A reward function that returns None for all samples
+ # in a batch produces NaN for that batch's metric. With logging_steps > 1, a naive sum()/len()
+ # would let a single NaN contaminate valid data from other batches. Only return None when no
+ # valid values remain (e.g. JSON loggers crash on float NaN).
+ valid = [v for v in val if not math.isnan(v)]
+ metrics[key] = sum(valid) / len(valid) if valid else None
+
+ # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs`
+ # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format.
+ if mode == "eval":
+ metrics = {f"eval_{key}": val for key, val in metrics.items()}
+
+ logs.update(metrics)
+ super().log(logs, start_time)
+ self._metrics[mode].clear()
+
+ def _record_reward_diagnostics(
+ self,
+ mode: str,
+ rewards: torch.Tensor,
+ rewards_per_func: torch.Tensor,
+ group_std_rewards: torch.Tensor,
+ ) -> None:
+ tolerance = self.args.diagnostics_flat_tolerance
+
+ reward_mean = rewards.mean() if rewards.numel() > 0 else torch.tensor(0.0, device=self.accelerator.device)
+ reward_std = rewards.std() if rewards.numel() > 1 else torch.tensor(0.0, device=self.accelerator.device)
+ reward_min = rewards.min() if rewards.numel() > 0 else torch.tensor(0.0, device=self.accelerator.device)
+ reward_max = rewards.max() if rewards.numel() > 0 else torch.tensor(0.0, device=self.accelerator.device)
+ flat_group_fraction = (
+ (group_std_rewards <= tolerance).float().mean()
+ if group_std_rewards.numel() > 0
+ else torch.tensor(1.0, device=self.accelerator.device)
+ )
+
+ self._metrics[mode]["self_distillation/reward_mean"].append(self.accelerator.gather(reward_mean).mean().item())
+ self._metrics[mode]["self_distillation/reward_std"].append(self.accelerator.gather(reward_std).mean().item())
+ self._metrics[mode]["self_distillation/reward_min"].append(self.accelerator.gather(reward_min).min().item())
+ self._metrics[mode]["self_distillation/reward_max"].append(self.accelerator.gather(reward_max).max().item())
+ self._metrics[mode]["self_distillation/group_reward_std_mean"].append(
+ self.accelerator.gather(group_std_rewards.mean() if group_std_rewards.numel() > 0 else reward_std)
+ .mean()
+ .item()
+ )
+ self._metrics[mode]["self_distillation/flat_group_fraction"].append(
+ self.accelerator.gather(flat_group_fraction).mean().item()
+ )
+
+ if rewards_per_func.numel() > 0:
+ reward_func_means = rewards_per_func.nanmean(dim=0)
+ gathered_means = self.accelerator.gather(reward_func_means).view(-1, reward_func_means.numel()).mean(dim=0)
+ for reward_name, reward_func_mean in zip(self.reward_func_names, gathered_means.tolist(), strict=True):
+ self._metrics[mode][f"self_distillation/rewards/{reward_name}"].append(reward_func_mean)
+
+ reward_is_flat = reward_std.item() <= tolerance
+ grouped_rewards_are_flat = flat_group_fraction.item() >= 1.0 - tolerance
+ if reward_is_flat and grouped_rewards_are_flat:
+ self._warn_on_degenerate_diagnostics(
+ mode=mode,
+ counter_key="flat_rewards",
+ message=(
+ "Observed flat SDPO rewards across all sampled generations. "
+ "Policy advantages will collapse to zero, and SDPO will not learn. "
+ "Check reward density, reward shaping, or `success_reward_threshold`."
+ ),
+ )
+ else:
+ self._diagnostic_counters[mode]["flat_rewards"] = 0
+
+ def _warn_on_inactive_self_distillation(self, mode: str) -> None:
+ metrics = self.teacher_context_builder.last_metrics
+ tolerance = self.args.diagnostics_flat_tolerance
+
+ reprompt_fraction = metrics.get("self_distillation/reprompt_sample_fraction", 0.0)
+ success_fraction = metrics.get("self_distillation/success_group_fraction", 0.0)
+
+ if reprompt_fraction <= tolerance:
+ self._warn_on_degenerate_diagnostics(
+ mode=mode,
+ counter_key="inactive_self_distillation",
+ message=(
+ "SDPO self-distillation is inactive because no reprompted samples were constructed. "
+ "This usually means no rollout exceeded `success_reward_threshold` and no usable privileged "
+ "feedback was available."
+ ),
+ )
+ else:
+ self._diagnostic_counters[mode]["inactive_self_distillation"] = 0
+
+ if success_fraction <= tolerance:
+ self._warn_on_degenerate_diagnostics(
+ mode=mode,
+ counter_key="no_successful_rollouts",
+ message=(
+ "SDPO did not find any successful rollouts in the current generation groups. "
+ "If this persists, reduce task difficulty, adjust reward shaping, or lower "
+ "`success_reward_threshold`."
+ ),
+ )
+ else:
+ self._diagnostic_counters[mode]["no_successful_rollouts"] = 0
+
+ def _warn_on_degenerate_diagnostics(self, mode: str, counter_key: str, message: str) -> None:
+ interval = self.args.diagnostics_warning_interval
+ if interval == 0:
+ return
+
+ self._diagnostic_counters[mode][counter_key] += 1
+ count = self._diagnostic_counters[mode][counter_key]
+ if count == 1 or count % interval == 0:
+ logger.warning("%s Consecutive degenerate steps: %s.", message, count)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdpo/teacher_sync.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdpo/teacher_sync.py
new file mode 100644
index 0000000000000000000000000000000000000000..8fb0f751a0bb5f4ae69ce9d201b29c09263bf21c
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/sdpo/teacher_sync.py
@@ -0,0 +1,184 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+
+import torch
+from accelerate.utils import is_peft_model
+from transformers import (
+ TrainerCallback,
+ TrainerControl,
+ TrainerState,
+ TrainingArguments,
+)
+
+from ...trainer.callbacks import SyncRefModelCallback
+
+
+logger = logging.getLogger(__name__)
+
+
+def is_pure_lora_training(model, accelerator=None) -> bool:
+ """Return `True` when the active adapter is LoRA and every trainable parameter is a LoRA parameter."""
+ if not is_peft_model(model):
+ return False
+
+ if accelerator is not None:
+ model = accelerator.unwrap_model(model)
+
+ adapter_name = model.active_adapter
+ if adapter_name is None:
+ adapter_name = "default"
+ adapter_config = model.peft_config.get(adapter_name)
+ peft_type = adapter_config.peft_type
+ if peft_type is None or str(peft_type).split(".")[-1] != "LORA":
+ return False
+
+ for name, param in model.named_parameters():
+ if param.requires_grad and "lora_" not in name:
+ return False
+ return True
+
+
+class SyncTeacherModelCallback(SyncRefModelCallback):
+ """Synchronize an EMA teacher model with the student model on each configured sync step."""
+
+ def __init__(self, teacher_model, accelerator=None):
+ super().__init__(ref_model=teacher_model, accelerator=accelerator)
+
+ def on_step_end(self, args, state, control, **kwargs):
+ model = kwargs["model"]
+ if self.ref_model is not None and state.global_step % args.teacher_sync_steps == 0:
+ if self.accelerator:
+ model = self.accelerator.unwrap_model(model)
+ self.sync_target_model(model, self.ref_model, args.teacher_update_rate)
+
+
+class PEFTAdapterEMACallback(TrainerCallback):
+ """
+ Callback that maintains an EMA copy of PEFT adapter weights for use as a teacher model in self-distillation.
+
+ The callback creates a secondary adapter ("teacher") with zero-initialized weights and maintains shadow weights
+ that are updated via exponential moving average: `teacher_weight = (1-α) * teacher_weight + α * student_weight`
+
+ Usage:
+ ```python
+ trainer.add_callback(
+ PEFTAdapterEMACallback(
+ model=model,
+ teacher_adapter_name="teacher",
+ update_rate=0.05,
+ )
+ )
+ ```
+ """
+
+ def __init__(
+ self,
+ model,
+ teacher_adapter_name: str = "teacher",
+ update_rate: float = 0.05,
+ sync_steps: int = 1,
+ accelerator=None,
+ ):
+ self.model = model
+ self.teacher_adapter_name = teacher_adapter_name
+ self.update_rate = update_rate
+ self.sync_steps = sync_steps
+ self.accelerator = accelerator
+ self.shadow_weights: dict[str, torch.Tensor] | None = None
+ self.teacher_adapter_config = None
+ self._initialized = False
+
+ def _get_student_state_dict(self):
+ """Get student adapter state dict using PEFT keys (without adapter name)."""
+ from peft import get_peft_model_state_dict
+
+ if self.accelerator is not None:
+ model = self.accelerator.unwrap_model(self.model)
+ else:
+ model = self.model
+ return get_peft_model_state_dict(model)
+
+ def _initialize_teacher_adapter(self):
+ """Create teacher adapter with zero weights initialized from student adapter."""
+ from peft import get_peft_model_state_dict, set_peft_model_state_dict
+
+ if self._initialized:
+ return
+
+ if self.accelerator is not None:
+ model = self.accelerator.unwrap_model(self.model)
+ else:
+ model = self.model
+
+ adapter_name = model.active_adapter
+ if adapter_name is None:
+ adapter_name = "default"
+
+ self.teacher_adapter_config = model.peft_config.get(adapter_name)
+
+ student_state = get_peft_model_state_dict(model)
+
+ teacher_state = {k: torch.zeros_like(v) for k, v in student_state.items()}
+
+ model.add_adapter(self.teacher_adapter_name, self.teacher_adapter_config)
+
+ model.set_adapter(self.teacher_adapter_name)
+ set_peft_model_state_dict(model, teacher_state, adapter_name=self.teacher_adapter_name)
+
+ model.set_adapter(adapter_name)
+
+ self.shadow_weights = {k: v.clone().zero_() for k, v in teacher_state.items()}
+
+ self._initialized = True
+ logger.info(f"Initialized PEFT adapter EMA teacher with adapter name: {self.teacher_adapter_name}")
+
+ @torch.no_grad()
+ def on_step_end(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs):
+ if state.global_step % self.sync_steps != 0:
+ return
+
+ if not self._initialized:
+ self._initialize_teacher_adapter()
+
+ if self.shadow_weights is None:
+ return
+
+ if self.accelerator is None and "accelerator" in kwargs:
+ self.accelerator = kwargs["accelerator"]
+
+ student_state = self._get_student_state_dict()
+
+ for key, student_param in student_state.items():
+ if key in self.shadow_weights:
+ shadow = self.shadow_weights[key]
+ shadow.data = (1 - self.update_rate) * shadow.data + self.update_rate * student_param.data
+
+ from peft import set_peft_model_state_dict
+
+ if self.accelerator is not None:
+ unwrapped_model = self.accelerator.unwrap_model(self.model)
+ else:
+ unwrapped_model = self.model
+
+ original_adapter = unwrapped_model.active_adapter
+ unwrapped_model.set_adapter(self.teacher_adapter_name)
+ set_peft_model_state_dict(unwrapped_model, self.shadow_weights, adapter_name=self.teacher_adapter_name)
+ unwrapped_model.set_adapter(original_adapter)
+
+ def on_train_begin(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs):
+ if self.accelerator is None and "accelerator" in kwargs:
+ self.accelerator = kwargs["accelerator"]
+ self._initialize_teacher_adapter()
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ssd/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ssd/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d62e42ef96cc9cd6e4ff4de23ce39460420e34b7
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ssd/__init__.py
@@ -0,0 +1,19 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .ssd_config import SSDConfig
+from .ssd_trainer import SSDTrainer
+
+
+__all__ = ["SSDConfig", "SSDTrainer"]
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ssd/ssd_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ssd/ssd_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a52b9c65a2293194cd132347564e374a39c526d
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ssd/ssd_config.py
@@ -0,0 +1,263 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from transformers import TrainingArguments
+
+from ...trainer.base_config import _BaseConfig
+
+
+@dataclass
+class SSDConfig(_BaseConfig):
+ r"""
+ Configuration class for [`SSDTrainer`].
+
+ Implements Simple Self-Distillation (SSD) from [*Embarrassingly Simple Self-Distillation Improves Code
+ Generation*](https://huggingface.co/papers/2604.01193). SSD samples completions from the model at a training-time
+ temperature and truncation configuration, then fine-tunes on those raw, unverified samples with standard
+ cross-entropy loss.
+
+ The `temperature`, `top_k`, and `top_p` parameters control the training-time sampling configuration (T_train,
+ rho_train in the paper). The evaluation-time configuration (T_eval, rho_eval) is set independently at inference
+ time.
+
+ Parameters:
+ > Parameters that control generation and rollout reuse
+
+ model_init_kwargs (`dict[str, Any]`, *optional*):
+ Keyword arguments used when the `model` argument is passed as a string.
+ trust_remote_code (`bool`, *optional*, defaults to `False`):
+ Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to
+ [`~transformers.AutoModelForCausalLM.from_pretrained`] and [`~transformers.AutoProcessor.from_pretrained`].
+ max_prompt_length (`int` or `None`, *optional*, defaults to `512`):
+ Maximum prompt length. Longer prompts are truncated from the left.
+ max_completion_length (`int` or `None`, *optional*, defaults to `256`):
+ Maximum generated completion length.
+ generation_batch_size (`int` or `None`, *optional*):
+ Global batch size used for generation. Mutually exclusive with `steps_per_generation`.
+ steps_per_generation (`int` or `None`, *optional*):
+ Number of optimizer steps that reuse one generated batch. Mutually exclusive with `generation_batch_size`.
+
+ > Parameters that control sampling
+
+ temperature (`float`, *optional*, defaults to `1.0`):
+ Sampling temperature (T_train in the paper).
+ top_k (`int`, *optional*, defaults to `0`):
+ Top-k sampling parameter. `0` disables top-k filtering.
+ top_p (`float`, *optional*, defaults to `1.0`):
+ Top-p (nucleus) sampling parameter.
+ min_p (`float` or `None`, *optional*):
+ Minimum token probability for sampling.
+ repetition_penalty (`float`, *optional*, defaults to `1.0`):
+ Repetition penalty used during generation.
+ generation_kwargs (`dict[str, Any]` or `None`, *optional*):
+ Extra generation kwargs passed to `GenerationConfig`.
+
+ > Parameters that control vLLM generation
+
+ use_vllm (`bool`, *optional*, defaults to `False`):
+ Whether to use vLLM for generation instead of the training model.
+ vllm_mode (`str`, *optional*, defaults to `"colocate"`):
+ vLLM mode: `"colocate"` (shared GPU) or `"server"` (separate vLLM server).
+ vllm_model_impl (`str`, *optional*, defaults to `"vllm"`):
+ Model implementation for vLLM: `"vllm"`, `"transformers"`, or `"auto"`.
+ vllm_server_base_url (`str` or `None`, *optional*):
+ Base URL for the vLLM server. If provided, `vllm_server_host` and `vllm_server_port` are ignored.
+ vllm_server_host (`str`, *optional*, defaults to `"0.0.0.0"`):
+ Host of the vLLM server (server mode only).
+ vllm_server_port (`int`, *optional*, defaults to `8000`):
+ Port of the vLLM server (server mode only).
+ vllm_server_timeout (`float`, *optional*, defaults to `240.0`):
+ Timeout in seconds to wait for the vLLM server.
+ vllm_group_port (`int`, *optional*, defaults to `51216`):
+ Port for the weight update group (server mode only).
+ vllm_tensor_parallel_size (`int`, *optional*, defaults to `1`):
+ Tensor parallel size for colocated vLLM.
+ vllm_gpu_memory_utilization (`float`, *optional*, defaults to `0.3`):
+ GPU memory utilization ratio for colocated vLLM.
+ vllm_max_model_length (`int` or `None`, *optional*):
+ Model context length for vLLM. Inferred from model config if not set.
+ vllm_enable_sleep_mode (`bool`, *optional*, defaults to `False`):
+ Whether to enable sleep mode for colocated vLLM engine.
+
+ > Parameters that control training behavior
+
+ disable_dropout (`bool`, *optional*, defaults to `True`):
+ Whether to disable dropout in the model during training.
+ filter_empty (`bool`, *optional*, defaults to `True`):
+ Whether to filter out empty or single-line stub completions from the generated data.
+ num_iterations (`int`, *optional*, defaults to `1`):
+ Number of optimization iterations per generated batch.
+ shuffle_dataset (`bool`, *optional*, defaults to `True`):
+ Whether to shuffle the training dataset.
+ ds3_gather_for_generation (`bool`, *optional*, defaults to `True`):
+ Whether to gather ZeRO-3 weights for generation.
+ cache_implementation (`str` or `None`, *optional*):
+ Cache implementation used by transformers generation.
+ chat_template_kwargs (`dict[str, Any]` or `None`, *optional*):
+ Extra kwargs forwarded to chat template application.
+ """
+
+ _VALID_DICT_FIELDS = TrainingArguments._VALID_DICT_FIELDS + ["model_init_kwargs"]
+
+ model_init_kwargs: dict[str, Any] | None = field(
+ default=None,
+ metadata={"help": "Keyword arguments for model initialization when `model` is passed as a string."},
+ )
+ trust_remote_code: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. "
+ "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoProcessor.from_pretrained`."
+ },
+ )
+ max_prompt_length: int | None = field(
+ default=512,
+ metadata={"help": "Maximum prompt length. Longer prompts are truncated from the left."},
+ )
+ max_completion_length: int | None = field(
+ default=256,
+ metadata={"help": "Maximum generated completion length."},
+ )
+ generation_batch_size: int | None = field(
+ default=None,
+ metadata={"help": "Global batch size used for generation. Mutually exclusive with `steps_per_generation`."},
+ )
+ steps_per_generation: int | None = field(
+ default=None,
+ metadata={"help": "Number of optimizer steps that reuse one generated batch."},
+ )
+ temperature: float = field(
+ default=1.0,
+ metadata={"help": "Sampling temperature (T_train in the paper)."},
+ )
+ top_k: int = field(
+ default=0,
+ metadata={"help": "Top-k sampling parameter. `0` disables top-k filtering."},
+ )
+ top_p: float = field(
+ default=1.0,
+ metadata={"help": "Top-p (nucleus) sampling parameter."},
+ )
+ min_p: float | None = field(
+ default=None,
+ metadata={"help": "Minimum token probability for sampling."},
+ )
+ repetition_penalty: float = field(
+ default=1.0,
+ metadata={"help": "Repetition penalty used during generation."},
+ )
+ generation_kwargs: dict[str, Any] | None = field(
+ default=None,
+ metadata={"help": "Extra generation kwargs passed to `GenerationConfig`."},
+ )
+ cache_implementation: str | None = field(
+ default=None,
+ metadata={"help": "Cache implementation used by transformers generation."},
+ )
+ chat_template_kwargs: dict[str, Any] | None = field(
+ default=None,
+ metadata={"help": "Extra kwargs forwarded to chat template application."},
+ )
+ use_vllm: bool = field(
+ default=False,
+ metadata={"help": "Whether to use vLLM for generation."},
+ )
+ vllm_mode: str = field(
+ default="colocate",
+ metadata={"help": "vLLM mode: 'colocate' (shared GPU) or 'server' (separate vLLM server)."},
+ )
+ vllm_model_impl: str = field(
+ default="vllm",
+ metadata={"help": "Model implementation for vLLM: 'vllm', 'transformers', or 'auto'."},
+ )
+ vllm_server_base_url: str | None = field(
+ default=None,
+ metadata={
+ "help": "Base URL for the vLLM server. If provided, vllm_server_host and vllm_server_port are ignored."
+ },
+ )
+ vllm_server_host: str = field(
+ default="0.0.0.0",
+ metadata={"help": "Host of the vLLM server (server mode only)."},
+ )
+ vllm_server_port: int = field(
+ default=8000,
+ metadata={"help": "Port of the vLLM server (server mode only)."},
+ )
+ vllm_server_timeout: float = field(
+ default=240.0,
+ metadata={"help": "Timeout in seconds to wait for the vLLM server."},
+ )
+ vllm_group_port: int = field(
+ default=51216,
+ metadata={"help": "Port for the weight update group (server mode only)."},
+ )
+ vllm_tensor_parallel_size: int = field(
+ default=1,
+ metadata={"help": "Tensor parallel size for colocated vLLM."},
+ )
+ vllm_gpu_memory_utilization: float = field(
+ default=0.3,
+ metadata={"help": "GPU memory utilization ratio for colocated vLLM."},
+ )
+ vllm_max_model_length: int | None = field(
+ default=None,
+ metadata={"help": "Model context length for vLLM. Inferred from model config if not set."},
+ )
+ vllm_enable_sleep_mode: bool = field(
+ default=False,
+ metadata={"help": "Whether to enable sleep mode for colocated vLLM engine."},
+ )
+ disable_dropout: bool = field(
+ default=True,
+ metadata={"help": "Whether to disable dropout in the model during training."},
+ )
+ filter_empty: bool = field(
+ default=True,
+ metadata={"help": "Whether to filter out empty or single-line stub completions."},
+ )
+ num_iterations: int = field(
+ default=1,
+ metadata={"help": "Number of optimization iterations per generated batch."},
+ )
+ shuffle_dataset: bool = field(
+ default=True,
+ metadata={"help": "Whether to shuffle the training dataset."},
+ )
+ ds3_gather_for_generation: bool = field(
+ default=True,
+ metadata={"help": "Whether to gather ZeRO-3 weights for generation."},
+ )
+
+ def __post_init__(self):
+ super().__post_init__()
+
+ num_processes = self.world_size
+ if self.generation_batch_size is None and self.steps_per_generation is None:
+ self.steps_per_generation = self.gradient_accumulation_steps
+ self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation
+ elif self.generation_batch_size is not None and self.steps_per_generation is None:
+ global_batch_size = self.per_device_train_batch_size * num_processes
+ if self.generation_batch_size % global_batch_size != 0:
+ raise ValueError(
+ f"generation_batch_size ({self.generation_batch_size}) must be divisible by the global batch size ({global_batch_size})."
+ )
+ self.steps_per_generation = self.generation_batch_size // global_batch_size
+ elif self.generation_batch_size is None and self.steps_per_generation is not None:
+ self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation
+ else:
+ raise ValueError("'generation_batch_size' and 'steps_per_generation' can not both be configured")
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ssd/ssd_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ssd/ssd_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a7f83c3f171719fcdeb56d5f85bf6e5f99e97d5
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/ssd/ssd_trainer.py
@@ -0,0 +1,532 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Trainer for Simple Self-Distillation (SSD).
+
+Implements the method from *Embarrassingly Simple Self-Distillation Improves Code Generation* (Zhang et al., 2026):
+sample completions from the frozen model at a training-time temperature and truncation configuration, then fine-tune on
+those raw, unverified samples with standard cross-entropy loss. No reward model, verifier, teacher model, or
+reinforcement learning is needed.
+"""
+
+from __future__ import annotations
+
+import inspect
+import math
+import textwrap
+from collections import defaultdict
+from functools import partial
+from typing import Any
+
+import datasets
+import torch
+from accelerate.logging import get_logger
+from accelerate.utils import is_peft_model
+from datasets import Dataset, IterableDataset
+from torch import nn
+from torch.utils.data import DataLoader, Sampler
+from transformers import (
+ AutoProcessor,
+ GenerationConfig,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+ ProcessorMixin,
+ TrainerCallback,
+)
+from transformers.trainer_utils import seed_worker
+from transformers.utils import is_datasets_available, is_peft_available
+
+from ...data_utils import maybe_apply_chat_template
+from ...models import unwrap_model_for_generation
+from ...trainer.base_trainer import _BaseTrainer
+from ...trainer.utils import (
+ RepeatSampler,
+ create_model_from_path,
+ disable_dropout_in_model,
+ get_config_model_id,
+ identity,
+ pad,
+ selective_log_softmax,
+ split_tensor_dict,
+)
+from ..utils import prepare_peft_model
+from .ssd_config import SSDConfig
+
+
+if is_peft_available():
+ from peft import PeftConfig
+
+
+logger = get_logger(__name__)
+
+
+class SSDTrainer(_BaseTrainer):
+ """Trainer for SSD-style on-policy self-distillation with cross-entropy loss.
+
+ SSD generates completions from the model at a specified training-time temperature and truncation configuration,
+ then fine-tunes on those raw, unverified samples using standard cross-entropy loss. The dataset only requires a
+ ``prompt`` column.
+ """
+
+ _tag_names = ["trl", "ssd"]
+ _name = "SSD"
+ config_cls = SSDConfig
+ # docstyle-ignore
+ _paper = {
+ "title": "Embarrassingly Simple Self-Distillation Improves Code Generation",
+ "id": "2604.01193",
+ "citation": textwrap.dedent("""\
+ @article{zhang2026ssd,
+ title = {{Embarrassingly Simple Self-Distillation Improves Code Generation}},
+ author = {Ruixiang Zhang and Richard He Bai and Huangjie Zheng and Navdeep Jaitly and Ronan Collobert and Yizhe Zhang},
+ year = 2026,
+ eprint = {arXiv:2604.01193}
+ }"""),
+ }
+
+ def __init__(
+ self,
+ model: str | PreTrainedModel | nn.Module,
+ args: SSDConfig | None = None,
+ train_dataset: Dataset | IterableDataset | None = None,
+ eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None,
+ processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None,
+ callbacks: list[TrainerCallback] | None = None,
+ optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None),
+ peft_config: PeftConfig | None = None,
+ ):
+ if train_dataset is None:
+ raise ValueError("`train_dataset` is required")
+ if isinstance(train_dataset, IterableDataset):
+ raise NotImplementedError("Iterable datasets are not yet supported in SSDTrainer.")
+ if isinstance(eval_dataset, IterableDataset) or (
+ isinstance(eval_dataset, dict) and any(isinstance(ds, IterableDataset) for ds in eval_dataset.values())
+ ):
+ raise NotImplementedError("Iterable eval datasets are not yet supported in SSDTrainer.")
+ if args is None:
+ model_name = model if isinstance(model, str) else get_config_model_id(model.config)
+ model_name = model_name.split("/")[-1]
+ args = SSDConfig(f"{model_name}-SSD")
+ if isinstance(model, str):
+ model_init_kwargs = args.model_init_kwargs or {}
+ if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]:
+ model_init_kwargs["device_map"] = None
+ model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+ model = create_model_from_path(model, **model_init_kwargs)
+ elif args.model_init_kwargs is not None:
+ logger.warning(
+ "You passed `model_init_kwargs` to `SSDConfig`, but `model` is already instantiated. "
+ "The `model_init_kwargs` will be ignored."
+ )
+
+ self.model_kwarg_keys = (
+ inspect.signature(model.forward).parameters.keys()
+ if not hasattr(model, "get_base_model")
+ else inspect.signature(model.get_base_model().forward).parameters.keys()
+ )
+
+ # PEFT
+ if peft_config is not None:
+ if not is_peft_available():
+ raise ImportError(
+ "You passed `peft_config` but the `peft` library is not installed. "
+ "Install it with `pip install trl[peft]`."
+ )
+ if not isinstance(peft_config, PeftConfig):
+ raise TypeError(
+ f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), "
+ f"got {type(peft_config).__name__}."
+ )
+ if is_peft_model(model):
+ raise ValueError(
+ "You passed a `PeftModel` instance together with a `peft_config` to SSDTrainer. Pass either a base "
+ "model with `peft_config`, or a pre-wrapped PEFT model."
+ )
+ if peft_config is not None or (is_peft_available() and getattr(model, "peft_config", None) is not None):
+ model = prepare_peft_model(model, peft_config, args)
+
+ if processing_class is None:
+ processing_class = AutoProcessor.from_pretrained(
+ get_config_model_id(model.config),
+ truncation_side="left",
+ padding_side="left",
+ trust_remote_code=args.trust_remote_code,
+ )
+
+ if isinstance(processing_class, ProcessorMixin):
+ self._tokenizer = processing_class.tokenizer
+ elif isinstance(processing_class, PreTrainedTokenizerBase):
+ self._tokenizer = processing_class
+ else:
+ raise TypeError("The `processing_class` must be either a `PreTrainedTokenizerBase` or a `ProcessorMixin`")
+
+ if self._tokenizer.pad_token is None:
+ self._tokenizer.pad_token = self._tokenizer.eos_token
+
+ self.max_prompt_length = args.max_prompt_length
+ self.max_completion_length = args.max_completion_length
+ # SSD always samples a single completion per prompt (N=1 in the paper).
+ self.num_generations = 1
+ self.num_iterations = args.num_iterations
+ self.temperature = args.temperature
+ self.shuffle_dataset = args.shuffle_dataset
+ self.filter_empty = args.filter_empty
+ self.use_vllm = args.use_vllm
+ self.chat_template_kwargs = args.chat_template_kwargs or {}
+ self._step = 0
+ self._buffered_inputs = None
+ self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)}
+
+ generation_kwargs = {
+ "max_new_tokens": self.max_completion_length,
+ "do_sample": True,
+ "pad_token_id": self._tokenizer.pad_token_id,
+ "bos_token_id": self._tokenizer.bos_token_id,
+ "eos_token_id": self._tokenizer.eos_token_id,
+ "temperature": args.temperature,
+ "top_p": args.top_p,
+ "top_k": args.top_k,
+ "min_p": args.min_p,
+ "repetition_penalty": args.repetition_penalty,
+ "cache_implementation": args.cache_implementation,
+ }
+ if args.generation_kwargs is not None:
+ generation_kwargs.update(args.generation_kwargs)
+ self.generation_config = GenerationConfig(**generation_kwargs, disable_compile=True)
+
+ if hasattr(model, "warnings_issued"):
+ model.warnings_issued["estimate_tokens"] = True
+
+ super().__init__(
+ model=model,
+ args=args,
+ data_collator=identity,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=processing_class,
+ callbacks=callbacks,
+ optimizers=optimizers,
+ compute_loss_func="non-None value to disable scaling",
+ )
+
+ if args.disable_dropout:
+ disable_dropout_in_model(self.model)
+
+ self.model.add_model_tags(self._tag_names)
+
+ self.model_accepts_loss_kwargs = False
+
+ if self.use_vllm:
+ from ...generation.vllm_generation import VLLMGeneration
+
+ self.vllm_generation = VLLMGeneration(
+ model=self.model,
+ accelerator=self.accelerator,
+ processing_class=self.processing_class,
+ mode=args.vllm_mode,
+ server_base_url=args.vllm_server_base_url,
+ server_host=args.vllm_server_host,
+ server_port=args.vllm_server_port,
+ group_port=args.vllm_group_port,
+ server_timeout=args.vllm_server_timeout,
+ tensor_parallel_size=args.vllm_tensor_parallel_size,
+ gpu_memory_utilization=args.vllm_gpu_memory_utilization,
+ max_model_length=args.vllm_max_model_length,
+ max_num_seqs=args.per_device_train_batch_size
+ * args.vllm_tensor_parallel_size
+ * args.steps_per_generation,
+ enable_sleep_mode=args.vllm_enable_sleep_mode,
+ model_impl=args.vllm_model_impl,
+ repetition_penalty=args.repetition_penalty,
+ temperature=self.temperature,
+ top_p=args.top_p,
+ top_k=args.top_k,
+ min_p=args.min_p,
+ max_completion_length=self.max_completion_length,
+ logprobs=None,
+ generation_kwargs=args.generation_kwargs,
+ )
+ self._last_loaded_step = -1
+
+ def _set_signature_columns_if_needed(self):
+ if self._signature_columns is None:
+ self._signature_columns = ["prompt"]
+
+ def _apply_prompt_template(self, prompts):
+ return [
+ maybe_apply_chat_template({"prompt": prompt}, self.processing_class, **self.chat_template_kwargs)["prompt"]
+ for prompt in prompts
+ ]
+
+ # ------------------------------------------------------------------
+ # DataLoader
+ # ------------------------------------------------------------------
+
+ def get_train_dataloader(self):
+ if self.train_dataset is None:
+ raise ValueError("Trainer: training requires a train_dataset.")
+
+ train_dataset = self.train_dataset
+ data_collator = self.data_collator
+ if is_datasets_available() and isinstance(train_dataset, datasets.Dataset):
+ train_dataset = self._remove_unused_columns(train_dataset, description="training")
+ else:
+ data_collator = self._get_collator_with_removed_columns(data_collator, description="training")
+
+ dataloader_params = {
+ "batch_size": self._train_batch_size * self.args.steps_per_generation,
+ "collate_fn": data_collator,
+ "num_workers": self.args.dataloader_num_workers,
+ "pin_memory": self.args.dataloader_pin_memory,
+ "persistent_workers": self.args.dataloader_persistent_workers,
+ }
+ if not isinstance(train_dataset, torch.utils.data.IterableDataset):
+ dataloader_params["sampler"] = self._get_train_sampler()
+ dataloader_params["drop_last"] = self.args.dataloader_drop_last
+ dataloader_params["worker_init_fn"] = partial(
+ seed_worker, num_workers=self.args.dataloader_num_workers, rank=self.args.process_index
+ )
+ dataloader_params["prefetch_factor"] = self.args.dataloader_prefetch_factor
+ return self.accelerator.prepare(DataLoader(train_dataset, **dataloader_params))
+
+ def _get_train_sampler(self, dataset=None) -> Sampler:
+ if dataset is None:
+ dataset = self.train_dataset
+ return RepeatSampler(
+ data_source=dataset,
+ mini_repeat_count=self.num_generations,
+ batch_size=self.args.generation_batch_size // self.num_generations,
+ repeat_count=self.num_iterations * self.args.steps_per_generation,
+ shuffle=self.shuffle_dataset,
+ seed=self.args.seed,
+ )
+
+ def _get_eval_sampler(self, eval_dataset) -> Sampler:
+ return RepeatSampler(
+ data_source=eval_dataset,
+ mini_repeat_count=self.num_generations,
+ seed=self.args.seed,
+ )
+
+ # ------------------------------------------------------------------
+ # Training step management
+ # ------------------------------------------------------------------
+
+ def training_step(self, model, inputs, num_items_in_batch):
+ output = super().training_step(model, inputs, num_items_in_batch)
+ self._step += 1
+ return output
+
+ def _prepare_inputs(self, generation_batch):
+ mode = "train" if self.model.training else "eval"
+ if mode == "train":
+ generate_every = self.args.steps_per_generation * self.num_iterations
+ if self._step % generate_every == 0 or self._buffered_inputs is None:
+ generation_batch = self._build_buffered_batch(generation_batch)
+ self._buffered_inputs = split_tensor_dict(generation_batch, self.args.steps_per_generation)
+ return self._buffered_inputs[self._step % self.args.steps_per_generation]
+ return self._build_buffered_batch(generation_batch)
+
+ # ------------------------------------------------------------------
+ # Generation
+ # ------------------------------------------------------------------
+
+ def _generate_completion_ids(self, prompts: list[Any]) -> tuple[torch.Tensor, torch.Tensor]:
+ """Generate completions from the model at the configured training-time temperature and truncation."""
+ if self.use_vllm:
+ return self._generate_completion_ids_vllm(prompts)
+ return self._generate_completion_ids_transformers(prompts)
+
+ def _generate_completion_ids_vllm(self, prompts: list[Any]) -> tuple[torch.Tensor, torch.Tensor]:
+ """Generate completions using vLLM."""
+ if self.state.global_step != self._last_loaded_step:
+ self.vllm_generation.sync_weights()
+ self._last_loaded_step = self.state.global_step
+
+ prompts_text = self._apply_prompt_template(prompts)
+ tokenized = self.processing_class(
+ text=prompts_text,
+ return_tensors=None,
+ padding=False,
+ max_length=self.max_prompt_length,
+ truncation=True,
+ add_special_tokens=False,
+ )
+ prompt_ids = tokenized["input_ids"]
+
+ _, completion_ids_list, _, _ = self.vllm_generation.generate(
+ prompts=prompt_ids,
+ images=None,
+ num_generations=self.num_generations,
+ )
+
+ device = self.accelerator.device
+ completion_ids = [torch.tensor(ids, device=device) for ids in completion_ids_list]
+ completion_mask = [torch.ones(len(ids), dtype=torch.long, device=device) for ids in completion_ids_list]
+ return (
+ pad(completion_ids, padding_value=self._tokenizer.pad_token_id, padding_side="right"),
+ pad(completion_mask, padding_value=0, padding_side="right"),
+ )
+
+ def _generate_completion_ids_transformers(self, prompts: list[Any]) -> tuple[torch.Tensor, torch.Tensor]:
+ """Generate completions using the training model with transformers."""
+ generate_inputs = self.processing_class(
+ text=self._apply_prompt_template(prompts),
+ return_tensors="pt",
+ padding=True,
+ padding_side="left",
+ max_length=self.max_prompt_length,
+ truncation=True,
+ add_special_tokens=False,
+ )
+ # Use the base Trainer tensor preparation instead of re-entering the buffered outer training hook.
+ generate_inputs = _BaseTrainer._prepare_inputs(self, generate_inputs)
+
+ with (
+ unwrap_model_for_generation(
+ self.model_wrapped,
+ self.accelerator,
+ gather_deepspeed3_params=self.args.ds3_gather_for_generation,
+ ) as unwrapped_model,
+ torch.no_grad(),
+ ):
+ prompt_completion_ids = unwrapped_model.generate(
+ **generate_inputs, generation_config=self.generation_config
+ )
+
+ prompt_length = generate_inputs["input_ids"].size(1)
+ completion_ids = prompt_completion_ids[:, prompt_length:]
+ is_eos = completion_ids == self._tokenizer.eos_token_id
+ eos_idx = torch.full((is_eos.size(0),), is_eos.size(1), dtype=torch.long, device=completion_ids.device)
+ eos_idx[is_eos.any(dim=1)] = is_eos.int().argmax(dim=1)[is_eos.any(dim=1)]
+ seq_idx = torch.arange(is_eos.size(1), device=completion_ids.device).expand(is_eos.size(0), -1)
+ completion_mask = (seq_idx <= eos_idx.unsqueeze(1)).long()
+
+ completion_ids_list = [c[m].tolist() for c, m in zip(completion_ids, completion_mask.bool(), strict=True)]
+ completion_ids = [torch.tensor(ids, device=self.accelerator.device) for ids in completion_ids_list]
+ completion_mask = [torch.ones_like(ids, dtype=torch.long) for ids in completion_ids]
+ return (
+ pad(completion_ids, padding_value=self._tokenizer.pad_token_id, padding_side="right"),
+ pad(completion_mask, padding_value=0, padding_side="right"),
+ )
+
+ # ------------------------------------------------------------------
+ # Batch construction
+ # ------------------------------------------------------------------
+
+ def _build_buffered_batch(self, inputs: list[dict[str, Any]]) -> dict[str, torch.Tensor | Any]:
+ """Generate completions and build the training batch."""
+ prompts = [example["prompt"] for example in inputs]
+ completion_ids, completion_mask = self._generate_completion_ids(prompts)
+
+ # Optionally filter empty or single-line stub completions (the paper applies minimal syntactic filtering)
+ if self.filter_empty:
+ completions_text = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True)
+ keep = torch.ones(len(completions_text), dtype=torch.bool, device=completion_ids.device)
+ for i, text in enumerate(completions_text):
+ stripped = text.strip()
+ if len(stripped) == 0 or stripped.count("\n") == 0 and len(stripped) < 10:
+ keep[i] = False
+ completion_mask = completion_mask * keep.unsqueeze(1).long()
+
+ # Tokenize prompts for the training forward pass
+ prompt_text = self._apply_prompt_template(prompts)
+ prompt_inputs = self.processing_class(
+ text=prompt_text,
+ return_tensors="pt",
+ padding=True,
+ padding_side="left",
+ max_length=self.max_prompt_length,
+ truncation=True,
+ add_special_tokens=False,
+ )
+ prompt_inputs = _BaseTrainer._prepare_inputs(self, prompt_inputs)
+ prompt_ids = prompt_inputs["input_ids"]
+ prompt_mask = prompt_inputs["attention_mask"]
+
+ # Log completion statistics
+ mode = "train" if self.model.training else "eval"
+ completion_lengths = completion_mask.sum(dim=1).float()
+ agg_lengths = self.accelerator.gather(completion_lengths)
+ self._metrics[mode]["completions/mean_length"].append(agg_lengths.mean().item())
+ self._metrics[mode]["completions/min_length"].append(agg_lengths.min().item())
+ self._metrics[mode]["completions/max_length"].append(agg_lengths.max().item())
+ active_ratio = (completion_mask.sum(dim=1) > 0).float().mean()
+ self._metrics[mode]["ssd/active_sample_ratio"].append(self.accelerator.gather(active_ratio).mean().item())
+
+ return {
+ "prompt_ids": prompt_ids,
+ "prompt_mask": prompt_mask,
+ "completion_ids": completion_ids,
+ "completion_mask": completion_mask,
+ }
+
+ # ------------------------------------------------------------------
+ # Loss computation
+ # ------------------------------------------------------------------
+
+ def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
+ if return_outputs:
+ raise ValueError("The SSDTrainer does not support returning outputs")
+
+ prompt_ids, prompt_mask = inputs["prompt_ids"], inputs["prompt_mask"]
+ completion_ids, completion_mask = inputs["completion_ids"], inputs["completion_mask"]
+ input_ids = torch.cat([prompt_ids, completion_ids], dim=1)
+ attention_mask = torch.cat([prompt_mask, completion_mask], dim=1)
+ logits_to_keep = completion_ids.size(1)
+
+ # Forward pass
+ model_inputs = {"input_ids": input_ids, "attention_mask": attention_mask, "use_cache": False}
+ if "logits_to_keep" in self.model_kwarg_keys:
+ model_inputs["logits_to_keep"] = logits_to_keep + 1
+ logits = model(**model_inputs).logits
+ logits = logits[:, :-1, :]
+ logits = logits[:, -logits_to_keep:, :]
+
+ # Standard cross-entropy loss: -log p(y_t | x, y None:
+ mode = "train" if self.model.training else "eval"
+ metrics = {}
+ for key, val in self._metrics[mode].items():
+ valid = [v for v in val if not math.isnan(v)]
+ metrics[key] = sum(valid) / len(valid) if valid else None
+
+ # When called in evaluation, the keys in `logs` start with "eval_". We need to add the prefix "eval_" to the
+ # keys in `metrics` to match the format.
+ if mode == "eval":
+ metrics = {f"eval_{key}": val for key, val in metrics.items()}
+
+ logs.update(metrics)
+ super().log(logs, start_time)
+ self._metrics[mode].clear()
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/tpo/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/tpo/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e07ec04eb1b9f4d8a0cfeef4b64460f3c991c1fc
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/tpo/__init__.py
@@ -0,0 +1,19 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .tpo_config import TPOConfig
+from .tpo_trainer import TPOTrainer
+
+
+__all__ = ["TPOConfig", "TPOTrainer"]
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/tpo/tpo_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/tpo/tpo_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e05a73b39c683326c4a3a2e6cbb44dfc0ebded7
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/tpo/tpo_config.py
@@ -0,0 +1,174 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from ...trainer.base_config import _BaseConfig
+
+
+@dataclass
+class TPOConfig(_BaseConfig):
+ # docstyle-ignore
+ r"""
+ Configuration class for the [`experimental.tpo.TPOTrainer`].
+
+ This class includes only the parameters that are specific to TPO training. For a full list of training arguments,
+ please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may
+ differ from those in [`~transformers.TrainingArguments`].
+
+ Using [`~transformers.HfArgumentParser`] we can turn this class into
+ [argparse](https://docs.python.org/3/library/argparse#module-argparse) arguments that can be specified on the
+ command line.
+
+ Parameters:
+ > Parameters that control the model
+
+ model_init_kwargs (`dict[str, Any]`, *optional*):
+ Keyword arguments for [`~transformers.AutoModelForCausalLM.from_pretrained`], used when the `model`
+ argument of the [`experimental.tpo.TPOTrainer`] is provided as a string.
+ trust_remote_code (`bool`, *optional*, defaults to `False`):
+ Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to
+ [`~transformers.AutoModelForCausalLM.from_pretrained`] and
+ [`~transformers.AutoProcessor.from_pretrained`].
+ disable_dropout (`bool`, *optional*, defaults to `True`):
+ Whether to disable dropout in the model.
+
+ > Parameters that control the data preprocessing
+
+ dataset_num_proc (`int`, *optional*):
+ Number of processes to use for processing the dataset.
+ max_length (`int` or `None`, *optional*, defaults to `1024`):
+ Maximum length of the tokenized sequence. Sequences longer than `max_length` are truncated from the left or
+ right depending on the `truncation_mode`. If `None`, no truncation is applied.
+ truncation_mode (`str`, *optional*, defaults to `"keep_start"`):
+ Truncation mode to use when the sequence exceeds `max_length`. Possible values are `"keep_start"` and
+ `"keep_end"`.
+ pad_to_multiple_of (`int`, *optional*):
+ If set, the sequences will be padded to a multiple of this value.
+
+ > Parameters that control the training
+
+ loss_type (`str`, *optional*, defaults to `"sigmoid"`):
+ Type of loss to use. Possible values are:
+
+ - `"sigmoid"`: sigmoid loss from the original [TPO](https://huggingface.co/papers/2405.16681) paper.
+ - `"hinge"`: hinge loss on the normalized likelihood from the
+ [SLiC](https://huggingface.co/papers/2305.10425) paper.
+ - `"ipo"`: IPO loss from the [IPO](https://huggingface.co/papers/2310.12036) paper.
+ - `"tpo-l"`: length-normalized TPO variant from the
+ [TPO](https://huggingface.co/papers/2405.16681) paper, which adds a target reward margin
+ `tpo_l_gamma` to the Bradley-Terry objective.
+
+ beta (`float`, *optional*, defaults to `0.01`):
+ Parameter controlling the temperature of the TPO loss. For the IPO loss (`loss_type="ipo"`), β is the
+ regularization parameter denoted by τ in the [paper](https://huggingface.co/papers/2310.12036).
+ label_smoothing (`float`, *optional*, defaults to `0.0`):
+ Label smoothing factor.
+ tpo_alpha (`float`, *optional*, defaults to `1.0`):
+ Weight of the supervised negative log-likelihood term computed on the gold (`reference`) response in TPO
+ training. Setting `tpo_alpha=0.0` disables the NLL term and skips the corresponding forward pass.
+ tpo_l_gamma (`float`, *optional*, defaults to `0.5`):
+ Target reward margin γ for the TPO-L loss, used only when `loss_type="tpo-l"`.
+
+ > [!NOTE]
+ > These parameters have default values different from [`~transformers.TrainingArguments`]:
+ > - `logging_steps`: Defaults to `10` instead of `500`.
+ > - `gradient_checkpointing`: Defaults to `True` instead of `False`.
+ > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`.
+ > - `learning_rate`: Defaults to `5e-7` instead of `5e-5`.
+ """
+
+ _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs"]
+
+ # Parameters whose default values are overridden from TrainingArguments
+ learning_rate: float = field(
+ default=5e-7,
+ metadata={"help": "The initial learning rate for AdamW."},
+ )
+
+ # Parameters that control the model
+ model_init_kwargs: dict[str, Any] | str | None = field(
+ default=None,
+ metadata={
+ "help": "Keyword arguments for `AutoModelForCausalLM.from_pretrained`, used when the `model` argument of "
+ "the `TPOTrainer` is provided as a string."
+ },
+ )
+ trust_remote_code: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. "
+ "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoProcessor.from_pretrained`."
+ },
+ )
+ disable_dropout: bool = field(
+ default=True,
+ metadata={"help": "Whether to disable dropout in the model."},
+ )
+
+ # Parameters that control the data preprocessing
+ dataset_num_proc: int | None = field(
+ default=None,
+ metadata={"help": "Number of processes to use for processing the dataset."},
+ )
+ max_length: int | None = field(
+ default=1024,
+ metadata={
+ "help": "Maximum length of the tokenized sequence. Sequences longer than `max_length` are truncated from "
+ "the left or right depending on the `truncation_mode`. If `None`, no truncation is applied."
+ },
+ )
+ truncation_mode: str = field(
+ default="keep_start",
+ metadata={
+ "help": "Truncation mode to use when the sequence exceeds `max_length`.",
+ "choices": ["keep_end", "keep_start"],
+ },
+ )
+ pad_to_multiple_of: int | None = field(
+ default=None,
+ metadata={"help": "If set, the sequences will be padded to a multiple of this value."},
+ )
+
+ # Parameters that control the training
+ loss_type: str = field(
+ default="sigmoid",
+ metadata={
+ "help": "Type of loss to use.",
+ "choices": ["sigmoid", "hinge", "ipo", "tpo-l"],
+ },
+ )
+ beta: float = field(
+ default=0.01,
+ metadata={
+ "help": "Parameter controlling the temperature of the TPO loss. For the IPO loss (`loss_type='ipo'`), this "
+ "value is the regularization parameter denoted by τ in the IPO paper."
+ },
+ )
+ label_smoothing: float = field(
+ default=0.0,
+ metadata={"help": "Label smoothing factor."},
+ )
+ tpo_alpha: float = field(
+ default=1.0,
+ metadata={
+ "help": "Weight of the supervised NLL term computed on the gold (`reference`) response in TPO training. "
+ "Setting `tpo_alpha=0.0` disables the NLL term and skips the corresponding forward pass."
+ },
+ )
+ tpo_l_gamma: float = field(
+ default=0.5,
+ metadata={"help": "Target reward margin γ for the TPO-L loss, used only when `loss_type='tpo-l'`."},
+ )
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/tpo/tpo_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/tpo/tpo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ea3a6f86f6346376969c263790a1b12e7e8fc80
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/tpo/tpo_trainer.py
@@ -0,0 +1,790 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import textwrap
+from collections import defaultdict
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import torch
+import torch.nn.functional as F
+import transformers
+from accelerate import PartialState
+from accelerate.logging import get_logger
+from accelerate.utils import is_peft_model
+from datasets import Dataset, IterableDataset
+from packaging.version import Version
+from transformers import (
+ AutoProcessor,
+ DataCollator,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+)
+from transformers.data.data_collator import DataCollatorMixin
+from transformers.trainer_callback import TrainerCallback
+from transformers.trainer_utils import EvalPrediction
+from transformers.utils import is_peft_available
+
+from ...data_utils import extract_prompt, is_conversational
+from ...trainer.base_trainer import _BaseTrainer
+from ...trainer.utils import (
+ create_model_from_path,
+ disable_dropout_in_model,
+ entropy_from_logits,
+ get_config_model_id,
+ pad,
+ selective_log_softmax,
+)
+from .tpo_config import TPOConfig
+
+
+if is_peft_available():
+ from peft import PeftConfig, PeftModel, get_peft_model
+
+
+logger = get_logger(__name__)
+
+
+def _extract_triple_prompt(example: dict) -> dict:
+ """Extract the shared prompt from `chosen`/`rejected` and also strip it from `reference`.
+
+ Wraps [`~trl.data_utils.extract_prompt`] — which only rewrites `chosen` and `rejected` — and additionally strips
+ the extracted prompt prefix from the `reference` (gold) completion. This is specific to TPO and assumes that the
+ `reference` completion shares the same implicit prompt prefix as `chosen` and `rejected`. If it does not, a
+ `ValueError` is raised asking the caller to provide an explicit `prompt` column.
+ """
+ extracted = extract_prompt(example)
+ prompt = extracted["prompt"]
+ reference = example["reference"]
+ if reference[: len(prompt)] != prompt:
+ raise ValueError(
+ "The `reference` completion does not start with the implicit prompt extracted from `chosen`/`rejected`. "
+ "Either provide an explicit `prompt` column, or make sure the `reference` completion shares the same "
+ "prompt prefix as the `chosen` and `rejected` completions."
+ )
+ extracted["reference"] = reference[len(prompt) :]
+ return extracted
+
+
+@dataclass
+class DataCollatorForTriplePreference(DataCollatorMixin):
+ """
+ Data collator used for triple-preference data. Inputs are dynamically padded to the maximum length of a batch.
+
+ This collator expects each example in the input list to be a dictionary containing the keys `"prompt_ids"`,
+ `"chosen_ids"` and `"rejected_ids"`. When `include_reference=True` (the default) each example must additionally
+ contain `"reference_ids"`. The collator returns a dictionary containing the following keys:
+ - `"input_ids"`: Tensor of input IDs, padded to the maximum length of the batch. When
+ `include_reference=True`, the first third of the batch corresponds to the `"chosen_ids"`, the second third to
+ the `"rejected_ids"` and the last third to the `"reference_ids"`. When `include_reference=False`, the first
+ half corresponds to the `"chosen_ids"` and the second half to the `"rejected_ids"` (matching the layout of
+ [`~trl.trainer.dpo_trainer.DataCollatorForPreference`]).
+ - `"attention_mask"`: Tensor of attention mask, padded to the maximum length of the batch.
+ - `"completion_mask"`: Tensor indicating the positions of the completion tokens, padded to the maximum length of
+ the batch.
+
+ Args:
+ pad_token_id (`int`):
+ Token ID to use for padding.
+ max_length (`int`, *optional*):
+ Maximum length of the sequences after concatenation. Sequences longer than `max_length` are truncated
+ before padding, which avoids allocating oversized tensors for batches containing very long sequences.
+ truncation_mode (`str`, *optional*, defaults to `"keep_start"`):
+ Truncation mode when a concatenated sequence exceeds `max_length`. Possible values are `"keep_end"` and
+ `"keep_start"`.
+ pad_to_multiple_of (`int`, *optional*):
+ If set, the sequences will be padded to a multiple of this value.
+ return_tensors (`str`, *optional*, defaults to `"pt"`):
+ Type of Tensor to return. Only `"pt"` is currently supported.
+ include_reference (`bool`, *optional*, defaults to `True`):
+ Whether to include the `"reference_ids"` branch in the collated batch. When `False`, the collator emits
+ only the chosen/rejected halves and skips the gold-response sequences entirely, which matches the behavior
+ expected when `tpo_alpha=0.0` (no NLL term).
+
+ Examples:
+ ```python
+ >>> from trl.experimental.tpo.tpo_trainer import DataCollatorForTriplePreference
+
+ >>> collator = DataCollatorForTriplePreference(pad_token_id=0)
+ >>> examples = [
+ ... {"prompt_ids": [1, 2, 3], "chosen_ids": [4, 5], "rejected_ids": [6], "reference_ids": [7, 8]},
+ ... {"prompt_ids": [9, 10], "chosen_ids": [11], "rejected_ids": [12, 13], "reference_ids": [14]},
+ ... ]
+ >>> collator(examples)
+ {'input_ids': tensor([[ 1, 2, 3, 4, 5],
+ [ 9, 10, 11, 0, 0],
+ [ 1, 2, 3, 6, 0],
+ [ 9, 10, 12, 13, 0],
+ [ 1, 2, 3, 7, 8],
+ [ 9, 10, 14, 0, 0]]),
+ 'attention_mask': tensor([[1, 1, 1, 1, 1],
+ [1, 1, 1, 0, 0],
+ [1, 1, 1, 1, 0],
+ [1, 1, 1, 1, 0],
+ [1, 1, 1, 1, 1],
+ [1, 1, 1, 0, 0]]),
+ 'completion_mask': tensor([[0, 0, 0, 1, 1],
+ [0, 0, 1, 0, 0],
+ [0, 0, 0, 1, 0],
+ [0, 0, 1, 1, 0],
+ [0, 0, 0, 1, 1],
+ [0, 0, 1, 0, 0]])}
+ ```
+ """
+
+ pad_token_id: int
+ max_length: int | None = None
+ truncation_mode: str = "keep_start"
+ pad_to_multiple_of: int | None = None
+ return_tensors: str = "pt"
+ include_reference: bool = True
+
+ def torch_call(self, examples: list[dict[str, Any]]) -> dict[str, Any]:
+ prompt_chosen_ids = [example["prompt_ids"] + example["chosen_ids"] for example in examples]
+ prompt_rejected_ids = [example["prompt_ids"] + example["rejected_ids"] for example in examples]
+ chosen_mask = [[0] * len(example["prompt_ids"]) + [1] * len(example["chosen_ids"]) for example in examples]
+ rejected_mask = [[0] * len(example["prompt_ids"]) + [1] * len(example["rejected_ids"]) for example in examples]
+ if self.include_reference:
+ prompt_reference_ids = [example["prompt_ids"] + example["reference_ids"] for example in examples]
+ reference_mask = [
+ [0] * len(example["prompt_ids"]) + [1] * len(example["reference_ids"]) for example in examples
+ ]
+
+ if self.max_length is not None:
+ if self.truncation_mode == "keep_start":
+ sl = slice(None, self.max_length)
+ elif self.truncation_mode == "keep_end":
+ sl = slice(-self.max_length, None)
+ else:
+ raise ValueError(
+ f"Unsupported truncation mode: {self.truncation_mode}, expected 'keep_start' or 'keep_end'"
+ )
+ prompt_chosen_ids = [ids[sl] for ids in prompt_chosen_ids]
+ prompt_rejected_ids = [ids[sl] for ids in prompt_rejected_ids]
+ chosen_mask = [m[sl] for m in chosen_mask]
+ rejected_mask = [m[sl] for m in rejected_mask]
+ if self.include_reference:
+ prompt_reference_ids = [ids[sl] for ids in prompt_reference_ids]
+ reference_mask = [m[sl] for m in reference_mask]
+
+ chosen_attention_mask = [[1] * len(ids) for ids in prompt_chosen_ids]
+ rejected_attention_mask = [[1] * len(ids) for ids in prompt_rejected_ids]
+ input_ids = prompt_chosen_ids + prompt_rejected_ids
+ attention_mask = chosen_attention_mask + rejected_attention_mask
+ completion_mask = chosen_mask + rejected_mask
+ if self.include_reference:
+ reference_attention_mask = [[1] * len(ids) for ids in prompt_reference_ids]
+ input_ids = input_ids + prompt_reference_ids
+ attention_mask = attention_mask + reference_attention_mask
+ completion_mask = completion_mask + reference_mask
+
+ # Convert to tensor
+ input_ids = [torch.tensor(ids) for ids in input_ids]
+ attention_mask = [torch.tensor(m, dtype=torch.long) for m in attention_mask]
+ completion_mask = [torch.tensor(m, dtype=torch.long) for m in completion_mask]
+
+ # Pad
+ output = {}
+ output["input_ids"] = pad(
+ input_ids,
+ padding_value=self.pad_token_id,
+ padding_side="right",
+ pad_to_multiple_of=self.pad_to_multiple_of,
+ )
+ output["attention_mask"] = pad(
+ attention_mask,
+ padding_value=0,
+ padding_side="right",
+ pad_to_multiple_of=self.pad_to_multiple_of,
+ )
+ output["completion_mask"] = pad(
+ completion_mask,
+ padding_value=0,
+ padding_side="right",
+ pad_to_multiple_of=self.pad_to_multiple_of,
+ )
+ return output
+
+
+class TPOTrainer(_BaseTrainer):
+ """
+ Trainer for Triple Preference Optimization (TPO) method. This algorithm was initially proposed in the paper [Triple
+ Preference Optimization: Achieving Better Alignment using a Single Step
+ Optimization](https://huggingface.co/papers/2405.16681). This class is a wrapper around the
+ [`~transformers.Trainer`] class and inherits all of its attributes and methods.
+
+ Args:
+ model (`str` or [`~transformers.PreTrainedModel`] or [`~peft.PeftModel`]):
+ Model to be trained. Can be either:
+
+ - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a
+ path to a *directory* containing model weights saved using
+ [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded
+ using `.from_pretrained` (where `` is derived from the model
+ config) with the keyword arguments in `args.model_init_kwargs`.
+ - A [`~transformers.PreTrainedModel`] object. Only causal language models are supported.
+ - A [`~peft.PeftModel`] object. Only causal language models are supported.
+ args ([`experimental.tpo.TPOConfig`], *optional*):
+ Configuration for this trainer. If `None`, a default configuration is used.
+ data_collator ([`~transformers.DataCollator`], *optional*):
+ Function to use to form a batch from a list of elements of the processed `train_dataset` or `eval_dataset`.
+ Will default to [`~trl.experimental.tpo.tpo_trainer.DataCollatorForTriplePreference`]. Custom collators
+ must truncate sequences before padding; the trainer does not apply post-collation truncation.
+ train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]):
+ Dataset to use for training. TPO requires a *triple-preference* dataset: each sample must contain a
+ `"chosen"`, a `"rejected"` and a `"reference"` (gold) completion. The format of the samples can be either:
+
+ - [Standard](dataset_formats#standard): Each sample contains plain text.
+ - [Conversational](dataset_formats#conversational): Each sample contains structured messages (e.g., role
+ and content).
+ eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`):
+ Dataset to use for evaluation. It must meet the same requirements as `train_dataset`.
+ processing_class ([`~transformers.PreTrainedTokenizerBase`], *optional*):
+ Processing class used to process the data. If `None`, the processing class is loaded from the model's name
+ with [`~transformers.AutoProcessor.from_pretrained`]. A padding token, `tokenizer.pad_token`, must be set.
+ If the processing class has not set a padding token, `tokenizer.eos_token` will be used as the default.
+ compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*):
+ The function that will be used to compute metrics at evaluation. Must take a
+ [`~transformers.EvalPrediction`] and return a dictionary string to metric values.
+ callbacks (list of [`~transformers.TrainerCallback`], *optional*):
+ List of callbacks to customize the training loop. Will add those to the list of default callbacks detailed
+ in [here](https://huggingface.co/docs/transformers/main_classes/callback).
+
+ If you want to remove one of the default callbacks used, use the [`~transformers.Trainer.remove_callback`]
+ method.
+ optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *optional*, defaults to `(None, None)`):
+ A tuple containing the optimizer and the scheduler to use. Will default to an instance of `AdamW` on your
+ model and a scheduler given by [`~transformers.get_linear_schedule_with_warmup`] controlled by `args`.
+ peft_config ([`~peft.PeftConfig`], *optional*):
+ PEFT configuration used to wrap the model. If `None`, the model is not wrapped.
+ """
+
+ _tag_names = ["trl", "tpo"]
+ _name = "TPO"
+ _paper = {
+ "title": "Triple Preference Optimization: Achieving Better Alignment using a Single Step Optimization",
+ "id": "2405.16681",
+ # docstyle-ignore
+ "citation": textwrap.dedent("""\
+ @misc{saeidi2025triplepreferenceoptimizationachieving,
+ title = {{Triple Preference Optimization: Achieving Better Alignment using a Single Step Optimization}},
+ author = {Amir Saeidi and Shivanshu Verma and Aswin RRV and Kashif Rasul and Chitta Baral},
+ year = 2025,
+ eprint = {2405.16681},
+ archivePrefix= {arXiv},
+ primaryClass = {cs.CL},
+ url = {https://arxiv.org/abs/2405.16681},
+ }"""),
+ }
+
+ def __init__(
+ self,
+ model: "str | PreTrainedModel | PeftModel",
+ args: TPOConfig | None = None,
+ data_collator: DataCollator | None = None,
+ train_dataset: Dataset | IterableDataset | None = None,
+ eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None,
+ processing_class: PreTrainedTokenizerBase | None = None,
+ compute_metrics: Callable[[EvalPrediction], dict] | None = None,
+ callbacks: list[TrainerCallback] | None = None,
+ optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None),
+ peft_config: "PeftConfig | None" = None,
+ ):
+ # Args
+ if args is None:
+ model_name = model if isinstance(model, str) else get_config_model_id(model.config)
+ model_name = model_name.split("/")[-1]
+ args = TPOConfig(f"{model_name}-TPO")
+
+ if train_dataset is None:
+ raise ValueError("`train_dataset` is required")
+ elif isinstance(train_dataset, IterableDataset):
+ # IterableDataset requires dispatch_batches=False because Accelerate's dispatch mode may try to concatenate
+ # batches from multiple processes, leading to mismatch errors.
+ if args.accelerator_config.dispatch_batches is True:
+ logger.warning(
+ "You are using an `IterableDataset` for training with `dispatch_batches=True`. `dispatch_batches` "
+ "is forced to `False` when using an `IterableDataset`. To remove this warning, unset "
+ "`dispatch_batches` in `TPOConfig` or set it to `False`."
+ )
+ args.accelerator_config.dispatch_batches = False
+
+ # Model
+ if isinstance(model, str):
+ model_init_kwargs = args.model_init_kwargs or {}
+ # Distributed training requires device_map=None ("auto" fails)
+ if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]:
+ model_init_kwargs["device_map"] = None
+ model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+ model = create_model_from_path(model, **model_init_kwargs)
+ else:
+ if args.model_init_kwargs is not None:
+ logger.warning(
+ "You passed `model_init_kwargs` to the `TPOConfig`, but your model is already instantiated. "
+ "The `model_init_kwargs` will be ignored."
+ )
+
+ # Processing class
+ if processing_class is None:
+ processing_class = AutoProcessor.from_pretrained(
+ get_config_model_id(model.config), trust_remote_code=args.trust_remote_code
+ )
+ if not isinstance(processing_class, PreTrainedTokenizerBase):
+ raise TypeError(
+ "The `processing_class` must be a `PreTrainedTokenizerBase`. `TPOTrainer` does not currently "
+ "support vision-language models."
+ )
+ self._tokenizer = processing_class
+
+ if self._tokenizer.pad_token is None:
+ self._tokenizer.pad_token = self._tokenizer.eos_token
+
+ # PEFT
+ if peft_config is not None:
+ if not is_peft_available():
+ raise ImportError(
+ "You passed `peft_config` but the `peft` library is not installed. "
+ "Install it with `pip install trl[peft]`."
+ )
+ if not isinstance(peft_config, PeftConfig):
+ raise TypeError(
+ f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), "
+ f"got {type(peft_config).__name__}."
+ )
+ if is_peft_model(model):
+ raise ValueError(
+ "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first merge "
+ "and unload the existing adapter, save the resulting base model, and then pass that base model along "
+ "with the new `peft_config` to the trainer."
+ )
+ # Create PEFT model
+ model = get_peft_model(model, peft_config)
+
+ # When using gradient checkpointing with PEFT, we need to enable input gradients. transformers.Trainer normally
+ # handles this, but a bug currently prevents it; see https://github.com/huggingface/transformers/issues/42489
+ if is_peft_model(model) and args.gradient_checkpointing:
+ model.enable_input_require_grads()
+
+ # Data collator. When `tpo_alpha=0.0`, the NLL term on the gold response is disabled, so we can drop the
+ # reference branch from the batch entirely — this spares the model from computing logits for a third of
+ # each step.
+ if data_collator is None:
+ data_collator = DataCollatorForTriplePreference(
+ pad_token_id=self._tokenizer.pad_token_id,
+ max_length=args.max_length,
+ truncation_mode=args.truncation_mode,
+ pad_to_multiple_of=args.pad_to_multiple_of,
+ include_reference=args.tpo_alpha != 0.0,
+ )
+
+ # Training arguments
+ self.beta = args.beta
+ self.loss_type = args.loss_type
+ self.label_smoothing = args.label_smoothing
+ self.tpo_alpha = args.tpo_alpha
+ self.tpo_l_gamma = args.tpo_l_gamma
+ if self.loss_type in ["hinge", "ipo"] and self.label_smoothing > 0:
+ logger.warning(
+ f"You are using the {self.loss_type} loss type that does not support label smoothing. The "
+ "`label_smoothing` parameter will be ignored. Set `label_smoothing` to `0.0` to remove this warning."
+ )
+
+ # Dataset
+ train_dataset = self._prepare_dataset(train_dataset, processing_class, args, "train")
+ if eval_dataset is not None:
+ if isinstance(eval_dataset, dict):
+ eval_dataset = {
+ key: self._prepare_dataset(dataset, processing_class, args, key)
+ for key, dataset in eval_dataset.items()
+ }
+ else:
+ eval_dataset = self._prepare_dataset(eval_dataset, processing_class, args, "eval")
+
+ # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was
+ # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream
+ # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we
+ # default to the recommended non-reentrant behavior here, while preserving any user-provided value.
+ if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"):
+ args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {}
+ args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False)
+
+ super().__init__(
+ model=model,
+ args=args,
+ data_collator=data_collator,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=processing_class,
+ compute_metrics=compute_metrics,
+ callbacks=callbacks,
+ optimizers=optimizers,
+ )
+
+ # Disable dropout in the model
+ if args.disable_dropout:
+ disable_dropout_in_model(model)
+
+ # Initialize the metrics
+ self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)}
+ self._total_train_tokens = 0
+
+ # Add tags to the model
+ self.model.add_model_tags(self._tag_names)
+
+ def _tokenize(
+ self,
+ processing_class: PreTrainedTokenizerBase,
+ input: str | list,
+ **kwargs,
+ ) -> dict[str, list]:
+ """Tokenize a single example for dataset preprocessing.
+
+ Dispatches to `apply_chat_template` for conversational input (list of message dicts) and to `__call__` for
+ non-conversational input (str).
+
+ Args:
+ processing_class ([`~transformers.PreTrainedTokenizerBase`]):
+ The tokenizer to use.
+ input (`str` or `list`):
+ A string for non-conversational input, or a list of message dicts for conversational input.
+ **kwargs:
+ Forwarded to `apply_chat_template` (e.g. `add_generation_prompt`).
+
+ Returns:
+ `dict` with at least an `"input_ids"` key mapping to a flat `list[int]`.
+ """
+ if isinstance(input, list): # conversational: list of message dicts
+ return processing_class.apply_chat_template(input, tokenize=True, return_dict=True, **kwargs)
+ # non-conversational: plain text string
+ return processing_class(text=input)
+
+ def _prepare_dataset(
+ self,
+ dataset: Dataset | IterableDataset,
+ processing_class: PreTrainedTokenizerBase,
+ args: TPOConfig,
+ dataset_name: str,
+ ) -> Dataset | IterableDataset:
+ # Validate that the triple-preference columns are present
+ first_example = next(iter(dataset))
+ if "chosen" not in first_example or "rejected" not in first_example:
+ raise ValueError(
+ "TPO requires a triple-preference dataset with `chosen`, `rejected` and `reference` columns, but the "
+ f"dataset is missing `chosen` or `rejected`. Got columns: {list(first_example.keys())}."
+ )
+ if "reference" not in first_example:
+ raise ValueError(
+ "TPO requires a triple-preference dataset with `chosen`, `rejected` and `reference` columns, but the "
+ f"dataset is missing the `reference` (gold) column. Got columns: {list(first_example.keys())}."
+ )
+
+ # Build the kwargs for the `map` function
+ map_kwargs = {}
+ if isinstance(dataset, Dataset): # IterableDataset does not support num_proc
+ map_kwargs["num_proc"] = args.dataset_num_proc
+
+ with PartialState().main_process_first():
+ # Extract the prompt if needed. Unlike DPO, we must also strip the extracted prompt from the reference
+ # column (see `_extract_triple_prompt`), which assumes the reference shares the same implicit prompt.
+ first_example = next(iter(dataset))
+ if "prompt" not in first_example:
+ if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc`
+ map_kwargs["desc"] = f"Extracting prompt from {dataset_name} dataset"
+ dataset = dataset.map(_extract_triple_prompt, **map_kwargs)
+
+ # Add EOS to completions for non-conversational data
+ first_example = next(iter(dataset))
+ if not is_conversational(first_example):
+ if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc`
+ map_kwargs["desc"] = f"Adding EOS to {dataset_name} dataset"
+
+ def add_eos(example, eos_token):
+ if not example["chosen"].endswith(eos_token):
+ example["chosen"] = example["chosen"] + eos_token
+ if not example["rejected"].endswith(eos_token):
+ example["rejected"] = example["rejected"] + eos_token
+ if not example["reference"].endswith(eos_token):
+ example["reference"] = example["reference"] + eos_token
+ return example
+
+ dataset = dataset.map(add_eos, fn_kwargs={"eos_token": processing_class.eos_token}, **map_kwargs)
+
+ # Tokenize the dataset
+ if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc`
+ map_kwargs["desc"] = f"Tokenizing {dataset_name} dataset"
+
+ def tokenize_fn(example, processing_class):
+ tools = example.get("tools")
+ tools = json.loads(tools) if isinstance(tools, str) else tools
+ output = {}
+ if is_conversational(example):
+ prompt_ids = self._tokenize(
+ processing_class,
+ example["prompt"],
+ tools=tools,
+ add_generation_prompt=True,
+ **example.get("chat_template_kwargs", {}),
+ )["input_ids"]
+ prompt_chosen_ids = self._tokenize(
+ processing_class,
+ example["prompt"] + example["chosen"],
+ tools=tools,
+ **example.get("chat_template_kwargs", {}),
+ )["input_ids"]
+ prompt_rejected_ids = self._tokenize(
+ processing_class,
+ example["prompt"] + example["rejected"],
+ tools=tools,
+ **example.get("chat_template_kwargs", {}),
+ )["input_ids"]
+ prompt_reference_ids = self._tokenize(
+ processing_class,
+ example["prompt"] + example["reference"],
+ tools=tools,
+ **example.get("chat_template_kwargs", {}),
+ )["input_ids"]
+ else:
+ prompt_ids = self._tokenize(processing_class, example["prompt"])["input_ids"]
+ prompt_chosen_ids = self._tokenize(processing_class, example["prompt"] + example["chosen"])[
+ "input_ids"
+ ]
+ prompt_rejected_ids = self._tokenize(processing_class, example["prompt"] + example["rejected"])[
+ "input_ids"
+ ]
+ prompt_reference_ids = self._tokenize(processing_class, example["prompt"] + example["reference"])[
+ "input_ids"
+ ]
+
+ # Check if the tokenized prompt starts with the tokenized prompt+completion
+ if not prompt_chosen_ids[: len(prompt_ids)] == prompt_ids:
+ logger.warning(
+ "Mismatch between tokenized prompt and the start of tokenized prompt+chosen. "
+ "This may be due to unexpected tokenizer behavior, whitespace issues, or special "
+ "token handling. Verify that the tokenizer is processing text consistently."
+ )
+ if not prompt_rejected_ids[: len(prompt_ids)] == prompt_ids:
+ logger.warning(
+ "Mismatch between tokenized prompt and the start of tokenized prompt+rejected. "
+ "This may be due to unexpected tokenizer behavior, whitespace issues, or special "
+ "token handling. Verify that the tokenizer is processing text consistently."
+ )
+ if not prompt_reference_ids[: len(prompt_ids)] == prompt_ids:
+ logger.warning(
+ "Mismatch between tokenized prompt and the start of tokenized prompt+reference. "
+ "This may be due to unexpected tokenizer behavior, whitespace issues, or special "
+ "token handling. Verify that the tokenizer is processing text consistently."
+ )
+
+ output["prompt_ids"] = prompt_ids
+ output["chosen_ids"] = prompt_chosen_ids[len(prompt_ids) :]
+ output["rejected_ids"] = prompt_rejected_ids[len(prompt_ids) :]
+ output["reference_ids"] = prompt_reference_ids[len(prompt_ids) :]
+ return output
+
+ dataset = dataset.map(tokenize_fn, fn_kwargs={"processing_class": processing_class}, **map_kwargs)
+
+ return dataset
+
+ def _set_signature_columns_if_needed(self):
+ # If `self.args.remove_unused_columns` is True, non-signature columns are removed.
+ # By default, this method sets `self._signature_columns` to the model's expected inputs (usually, "input_ids"
+ # and "attention_mask").
+ if self._signature_columns is None:
+ self._signature_columns = ["prompt_ids", "chosen_ids", "rejected_ids", "reference_ids"]
+
+ def _compute_loss(self, model, inputs, return_outputs):
+ mode = "train" if self.model.training else "eval"
+
+ # When `tpo_alpha=0.0` the NLL term is disabled and the collator drops the reference branch, so the batch
+ # is laid out as `[chosen, rejected]` (n_branches=2). Otherwise it is `[chosen, rejected, reference]`
+ # (n_branches=3).
+ n_branches = 3 if self.tpo_alpha != 0.0 else 2
+
+ _non_model_keys = {"completion_mask"}
+ model_kwargs = {k: v for k, v in inputs.items() if k not in _non_model_keys}
+ model_kwargs["use_cache"] = False
+ outputs = model(**model_kwargs)
+
+ input_ids = inputs["input_ids"]
+ completion_mask = inputs["completion_mask"]
+ shift_logits = outputs.logits[..., :-1, :]
+ shift_labels = input_ids[..., 1:]
+ shift_completion_mask = completion_mask[..., 1:]
+ per_token_logps = selective_log_softmax(shift_logits, shift_labels)
+ per_token_logps[shift_completion_mask == 0] = 0.0 # mask out non-completion tokens
+
+ # Length-normalized for IPO and TPO-L (matches the SimPO-style implicit reward used by the TPO paper);
+ # summed otherwise.
+ if self.loss_type in ("ipo", "tpo-l"):
+ completion_lengths = shift_completion_mask.sum(dim=1).clamp(min=1)
+ logps = per_token_logps.sum(dim=1) / completion_lengths
+ else:
+ logps = per_token_logps.sum(dim=1)
+ logps_chunks = logps.chunk(n_branches, dim=0)
+ chosen_logps, rejected_logps = logps_chunks[0], logps_chunks[1]
+
+ # Contrastive loss between chosen and rejected. Unlike DPO, TPO does not subtract reference-model log-probs:
+ # the "reference" in TPO is a gold response used in the NLL term below, not a separate reference policy.
+ delta_score = chosen_logps - rejected_logps
+
+ if self.loss_type == "sigmoid":
+ per_sequence_loss = (
+ -F.logsigmoid(self.beta * delta_score) * (1 - self.label_smoothing)
+ - F.logsigmoid(-self.beta * delta_score) * self.label_smoothing
+ )
+
+ elif self.loss_type == "hinge":
+ per_sequence_loss = torch.relu(1 - self.beta * delta_score)
+
+ elif self.loss_type == "ipo":
+ # (Eq. 17) of the IPO paper where beta is the regularization parameter for the IPO loss, denoted by τ.
+ per_sequence_loss = (delta_score - 1 / (2 * self.beta)) ** 2
+
+ elif self.loss_type == "tpo-l":
+ # Length-normalized TPO-L variant: subtract a target reward margin γ/β before the sigmoid.
+ gamma_logratios = self.tpo_l_gamma / self.beta
+ shifted_delta = delta_score - gamma_logratios
+ per_sequence_loss = (
+ -F.logsigmoid(self.beta * shifted_delta) * (1 - self.label_smoothing)
+ - F.logsigmoid(-self.beta * shifted_delta) * self.label_smoothing
+ )
+
+ else:
+ raise ValueError(
+ f"Unknown loss type: {self.loss_type}. Should be one of ['sigmoid', 'hinge', 'ipo', 'tpo-l']"
+ )
+
+ loss = per_sequence_loss.mean()
+
+ # NLL loss on the gold (`reference`) response. Mirrors the `"sft"` loss branch of `DPOTrainer._compute_loss`:
+ # we restrict the cross-entropy to the completion tokens of the reference sequence and let `F.cross_entropy`
+ # average over them. The NLL contribution is folded into the main `loss` (matching DPO/SFT convention: the
+ # individual NLL term is not logged separately).
+ if n_branches == 3:
+ _, _, ref_logits = shift_logits.chunk(3, dim=0)
+ _, _, ref_labels = shift_labels.chunk(3, dim=0)
+ _, _, ref_mask = shift_completion_mask.chunk(3, dim=0)
+ ref_mask = ref_mask.bool()
+ nll_loss = F.cross_entropy(ref_logits[ref_mask], ref_labels[ref_mask])
+ loss = loss + self.tpo_alpha * nll_loss
+
+ # Log the metrics
+ # Entropy
+ per_token_entropy = entropy_from_logits(shift_logits.detach())
+ entropy = per_token_entropy[shift_completion_mask.bool()].mean()
+ entropy = self.accelerator.gather_for_metrics(entropy).mean().item()
+ self._metrics[mode]["entropy"].append(entropy)
+
+ # Number of tokens
+ if mode == "train":
+ num_tokens_in_batch = self.accelerator.gather_for_metrics(inputs["attention_mask"].sum()).sum().item()
+ self._total_train_tokens += num_tokens_in_batch
+ self._metrics[mode]["num_tokens"] = [self._total_train_tokens]
+
+ # Average logits for chosen and rejected completions
+ logits_chunks = shift_logits.detach().chunk(n_branches, dim=0)
+ mask_chunks = shift_completion_mask.chunk(n_branches, dim=0)
+ labels_chunks = shift_labels.chunk(n_branches, dim=0)
+ chosen_logits, rejected_logits = logits_chunks[0], logits_chunks[1]
+ chosen_mask, rejected_mask = mask_chunks[0], mask_chunks[1]
+ chosen_labels = labels_chunks[0]
+ total_chosen_logits = chosen_logits[chosen_mask.bool()].mean(-1).sum()
+ total_chosen_tokens = chosen_mask.sum()
+ total_rejected_logits = rejected_logits[rejected_mask.bool()].mean(-1).sum()
+ total_rejected_tokens = rejected_mask.sum()
+ total_chosen_logits = self.accelerator.gather_for_metrics(total_chosen_logits).sum().item()
+ total_chosen_tokens = self.accelerator.gather_for_metrics(total_chosen_tokens).sum().item()
+ total_rejected_logits = self.accelerator.gather_for_metrics(total_rejected_logits).sum().item()
+ total_rejected_tokens = self.accelerator.gather_for_metrics(total_rejected_tokens).sum().item()
+ avg_chosen_logits = total_chosen_logits / total_chosen_tokens if total_chosen_tokens > 0 else 0.0
+ avg_rejected_logits = total_rejected_logits / total_rejected_tokens if total_rejected_tokens > 0 else 0.0
+ self._metrics[mode]["logits/chosen"].append(avg_chosen_logits)
+ self._metrics[mode]["logits/rejected"].append(avg_rejected_logits)
+
+ # Token accuracy for the chosen completions
+ predictions = chosen_logits.argmax(dim=-1)
+ chosen_bool_mask = chosen_mask.bool()
+ correct_predictions = (predictions == chosen_labels) & chosen_bool_mask
+ total_tokens = chosen_bool_mask.sum()
+ correct_tokens = correct_predictions.sum()
+ correct_tokens = self.accelerator.gather_for_metrics(correct_tokens)
+ total_tokens = self.accelerator.gather_for_metrics(total_tokens)
+ total_sum = total_tokens.sum()
+ accuracy = (correct_tokens.sum() / total_sum).item() if total_sum > 0 else 0.0
+ self._metrics[mode]["mean_token_accuracy"].append(accuracy)
+
+ # Rewards for chosen and rejected completions (β · log π_θ as in the SimPO/TPO implicit reward)
+ chosen_rewards = self.beta * chosen_logps.detach()
+ rejected_rewards = self.beta * rejected_logps.detach()
+ agg_chosen_rewards = self.accelerator.gather(chosen_rewards)
+ agg_rejected_rewards = self.accelerator.gather(rejected_rewards)
+ self._metrics[mode]["rewards/chosen"].append(agg_chosen_rewards.mean().item())
+ self._metrics[mode]["rewards/rejected"].append(agg_rejected_rewards.mean().item())
+
+ # Reward accuracy
+ reward_accuracies = (chosen_rewards > rejected_rewards).float()
+ agg_reward_accuracies = self.accelerator.gather(reward_accuracies)
+ self._metrics[mode]["rewards/accuracies"].append(agg_reward_accuracies.mean().item())
+
+ # Reward margins
+ margins = chosen_rewards - rejected_rewards
+ agg_margins = self.accelerator.gather(margins)
+ self._metrics[mode]["rewards/margins"].append(agg_margins.mean().item())
+
+ # Average log probabilities for chosen and rejected completions
+ self._metrics[mode]["logps/chosen"].append(self.accelerator.gather(chosen_logps).mean().item())
+ self._metrics[mode]["logps/rejected"].append(self.accelerator.gather(rejected_logps).mean().item())
+
+ return (loss, outputs) if return_outputs else loss
+
+ def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
+ return self._compute_loss(model, inputs, return_outputs)
+
+ def log(self, logs: dict[str, float], start_time: float | None = None) -> None:
+ mode = "train" if self.model.training else "eval"
+ metrics = {key: sum(val) / len(val) for key, val in self._metrics[mode].items()} # average the metrics
+
+ # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs`
+ # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format.
+ if mode == "eval":
+ metrics = {f"eval_{key}": val for key, val in metrics.items()}
+
+ logs.update(metrics)
+ super().log(logs, start_time)
+ self._metrics[mode].clear()
+
+ # During eval, Trainer calls prediction_step. If no labels are present in the inputs, it only runs forward and
+ # returns logits. We override prediction_step to force compute_loss, because this trainer doesn't involve labels.
+ def prediction_step(self, model, inputs, prediction_loss_only, ignore_keys: list[str] | None = None):
+ inputs = self._prepare_inputs(inputs)
+ with torch.no_grad(), self.compute_loss_context_manager():
+ if prediction_loss_only:
+ loss = self.compute_loss(model, inputs, return_outputs=False)
+ logits, labels = None, None
+ else:
+ loss, outputs = self.compute_loss(model, inputs, return_outputs=True)
+ logits, labels = outputs.logits, inputs["input_ids"]
+ return loss, logits, labels
+
+ # Ensure the model card is saved along with the checkpoint
+ def _save_checkpoint(self, model, trial):
+ if self.args.hub_model_id is None:
+ model_name = Path(self.args.output_dir).name
+ else:
+ model_name = self.args.hub_model_id.split("/")[-1]
+ self.create_model_card(model_name=model_name)
+ super()._save_checkpoint(model, trial)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/utils.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..db784a7f4894897e2d3ea249362c1419c45d127b
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/utils.py
@@ -0,0 +1,858 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This file contains utility classes and functions that are used across more than one experimental trainer or feature.
+
+import inspect
+import logging
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any
+
+import pyarrow as pa
+import pyarrow.types
+import torch
+from accelerate.utils import is_peft_model
+from packaging.version import Version
+from pyarrow import compute as pc
+from torch import nn
+from torch.nn.utils.rnn import pad_sequence
+from transformers import PreTrainedModel, PreTrainedTokenizerBase, TrainingArguments
+from transformers.integrations.deepspeed import is_deepspeed_zero3_enabled
+from transformers.utils import (
+ is_peft_available,
+ is_torch_mlu_available,
+ is_torch_mps_available,
+ is_torch_npu_available,
+ is_torch_xpu_available,
+)
+
+from ..data_utils import DatasetType, _get_dataset_format
+from ..trainer.utils import pad
+
+
+if is_peft_available():
+ import peft
+ from peft import PeftConfig, PeftModel, get_peft_model
+
+
+@dataclass
+class DPODataCollatorWithPadding:
+ r"""
+ DPO DataCollator class that pads the tokenized inputs to the maximum length of the batch.
+
+ Args:
+ pad_token_id (`int` defaults to 0):
+ The tokenizer's pad_token_id.
+ is_encoder_decoder (`bool` or `None`, `optional`, defaults to `None`):
+ Whether you model has an encoder_decoder architecture.
+ """
+
+ pad_token_id: int = 0
+ is_encoder_decoder: bool | None = False
+
+ def __call__(self, features: list[dict[str, Any]]) -> dict[str, Any]:
+ # first, pad everything to the same length
+ padded_batch = {}
+ for k in features[0].keys():
+ if k.endswith(("_input_ids", "_attention_mask", "_labels", "_pixel_values")):
+ if self.is_encoder_decoder:
+ to_pad = [torch.LongTensor(ex[k]) for ex in features]
+
+ if (k.startswith("prompt")) and (k.endswith("input_ids")):
+ if self.pad_token_id is None:
+ raise ValueError(
+ "Padding is enabled, but the tokenizer is not configured with a padding token."
+ " Explicitly set `tokenizer.pad_token` (e.g. `tokenizer.pad_token = tokenizer.eos_token`)"
+ " before calling the trainer."
+ )
+ padding_value = self.pad_token_id
+ elif k.endswith("_attention_mask"):
+ padding_value = 0
+ elif k.startswith(("chosen", "rejected", "completion")) or ("decoder" in k):
+ padding_value = -100
+ else:
+ raise ValueError(f"Unexpected key in batch '{k}'")
+ padded_batch[k] = pad_sequence(to_pad, batch_first=True, padding_value=padding_value)
+ else:
+ # Set padding value based on the key
+ if k.endswith("_input_ids"):
+ if self.pad_token_id is None:
+ raise ValueError(
+ "Padding is enabled, but the tokenizer is not configured with a padding token."
+ " Explicitly set `tokenizer.pad_token` (e.g. `tokenizer.pad_token = tokenizer.eos_token`)"
+ " before calling the trainer."
+ )
+ padding_value = self.pad_token_id
+ elif k.endswith("_labels"):
+ padding_value = -100
+ elif k.endswith("_attention_mask"):
+ padding_value = 0
+ elif k.endswith("_pixel_values"):
+ padding_value = 0 # TODO: check if this is correct
+ else:
+ raise ValueError(f"Unexpected key in batch '{k}'")
+
+ # Set padding side based on the key
+ if k in ["prompt_input_ids", "prompt_attention_mask"]:
+ padding_side = "left"
+ else:
+ padding_side = "right"
+
+ # Set the dtype
+ if k.endswith("_pixel_values"):
+ dtype = torch.float32 # will be downcasted if necessary by the Trainer
+ else:
+ dtype = torch.int64
+
+ # Convert to tensor and pad
+ to_pad = [torch.tensor(ex[k], dtype=dtype) for ex in features]
+ padded_batch[k] = pad(to_pad, padding_value=padding_value, padding_side=padding_side)
+ elif k.endswith("_logps"):
+ # the cached reference model logprobs
+ padded_batch[k] = torch.tensor([ex[k] for ex in features])
+ else:
+ padded_batch[k] = [ex[k] for ex in features]
+
+ return padded_batch
+
+
+def pad_byte_offsets(offsets: list[tuple[int, int]], target_length: int, padding_side: str) -> torch.Tensor:
+ """Build a ``[target_length, 2]`` long tensor from ``(start, end)`` byte-offset tuples,
+ padding with ``(0, 0)`` on the requested side."""
+ offs = torch.tensor(offsets, dtype=torch.long).reshape(-1, 2)
+ pad_len = target_length - offs.size(0)
+ if pad_len <= 0:
+ return offs
+ pad_block = torch.zeros(pad_len, 2, dtype=torch.long)
+ return torch.cat([pad_block, offs], dim=0) if padding_side == "left" else torch.cat([offs, pad_block], dim=0)
+
+
+def is_byte_level_tokenizer(backend) -> bool:
+ """Whether ``backend`` is a ByteLevel BPE tokenizer (Llama-3 family, SmolLM, Qwen, \u2026) \u2014 its pieces are in
+ byte\u2192unicode space, one char per source byte. Detected via the pre-tokenizer / decoder repr."""
+ return "ByteLevel" in repr(backend.pre_tokenizer) or "ByteLevel" in repr(backend.decoder)
+
+
+def piece_byte_len(piece: str) -> int:
+ """UTF-8 byte length of a ByteLevel BPE token piece \u2014 each char maps 1:1 to one source byte.
+
+ Cross-tokenizer ULD targets ByteLevel BPE pairs (Llama-3, Qwen, SmolLM, Phi, Mistral v0.3+, \u2026); SentencePiece
+ students are out of scope here and would need the loss-level projection from X-Token to align."""
+ return len(piece)
+
+
+def _bytes_to_unicode() -> dict[int, str]:
+ bs = list(range(ord("!"), ord("~") + 1)) + list(range(ord("\u00a1"), ord("\u00ac") + 1))
+ bs += list(range(ord("\u00ae"), ord("\u00ff") + 1))
+ cs = bs[:]
+ n = 0
+ for b in range(256):
+ if b not in bs:
+ bs.append(b)
+ cs.append(256 + n)
+ n += 1
+ return dict(zip(bs, [chr(n) for n in cs], strict=True))
+
+
+_BYTE_LEVEL_DECODER = {ch: b for b, ch in _bytes_to_unicode().items()}
+
+
+def _byte_level_piece_len(piece: str, text_bytes: bytes, start: int) -> int | None:
+ piece_bytes = []
+ for ch in piece:
+ if ch not in _BYTE_LEVEL_DECODER:
+ return None
+ piece_bytes.append(_BYTE_LEVEL_DECODER[ch])
+ if piece_bytes and piece_bytes[0] == ord(" ") and text_bytes[start : start + 1] != b" ":
+ piece_bytes = piece_bytes[1:]
+ return len(piece_bytes)
+
+
+def _split_repeated_byte_offsets(byte_offsets: list[tuple[int, int]], tokens: list[str]) -> list[tuple[int, int]]:
+ """Split repeated char-derived spans for byte-fallback or byte-level tokens."""
+ normalized = list(byte_offsets)
+ i = 0
+ while i < len(byte_offsets):
+ j = i + 1
+ while j < len(byte_offsets) and byte_offsets[j] == byte_offsets[i]:
+ j += 1
+
+ if j - i > 1:
+ start, end = byte_offsets[i]
+ piece_lengths = [piece_byte_len(token) for token in tokens[i:j]]
+ if sum(piece_lengths) == end - start:
+ cursor = start
+ for offset_idx, length in enumerate(piece_lengths, start=i):
+ normalized[offset_idx] = (cursor, cursor + length)
+ cursor += length
+
+ i = j
+ return normalized
+
+
+def _normalize_byte_offsets(
+ byte_offsets: list[tuple[int, int]], tokens: list[str], text_bytes: bytes
+) -> list[tuple[int, int]]:
+ byte_offsets = _split_repeated_byte_offsets(byte_offsets, tokens)
+ normalized = []
+ cursor = 0
+
+ for idx, (start, end) in enumerate(byte_offsets):
+ if start == end:
+ normalized.append((cursor, cursor))
+ continue
+
+ piece_len = _byte_level_piece_len(tokens[idx], text_bytes, start)
+ next_start = byte_offsets[idx + 1][0] if idx + 1 < len(byte_offsets) else None
+ has_overlap = start < cursor or (next_start is not None and next_start < end)
+
+ if piece_len is not None and (has_overlap or piece_len == end - start):
+ candidate_start = max(start, cursor)
+ candidate_end = candidate_start + piece_len
+ if candidate_end <= end:
+ start = candidate_start
+ end = candidate_end
+
+ if start < cursor or end < start:
+ raise ValueError(
+ "Tokenizer produced overlapping byte offsets that could not be normalized. "
+ "Cross-tokenizer ULD requires monotonic byte offsets."
+ )
+
+ normalized.append((start, end))
+ cursor = end
+
+ return normalized
+
+
+def encode_with_byte_offsets(backend, texts: list[str], add_special_tokens: bool = False):
+ """Encode ``texts`` and return per-text ``(ids, byte_offsets)`` pairs.
+
+ Byte offsets are derived from the fast tokenizer's character offsets via an O(N) char-to-byte cumulative table.
+ Overlapping spans from byte-level and byte-fallback tokens are split across their byte pieces."""
+ if not is_byte_level_tokenizer(backend):
+ raise NotImplementedError(
+ "Cross-tokenizer ULD currently supports only ByteLevel BPE tokenizers "
+ "(Llama-3, Qwen, SmolLM, Phi, Mistral v0.3+, …). The given tokenizer is not ByteLevel."
+ )
+ encs = backend.encode_batch(texts, add_special_tokens=add_special_tokens)
+ out = []
+ for text, enc in zip(texts, encs, strict=True):
+ char_to_byte = [0]
+ for ch in text:
+ char_to_byte.append(char_to_byte[-1] + len(ch.encode("utf-8")))
+ byte_offsets = [(char_to_byte[s], char_to_byte[e]) for s, e in enc.offsets]
+ byte_offsets = _normalize_byte_offsets(byte_offsets, enc.tokens, text.encode("utf-8"))
+ out.append((list(enc.ids), byte_offsets))
+ return out
+
+
+@dataclass
+class DataCollatorForChatML:
+ """
+ Data collator for ChatML format datasets.
+ """
+
+ tokenizer: PreTrainedTokenizerBase
+ ignore_index: int = -100
+ max_length: int = None
+ prompt_key: str = "prompt"
+ messages_key: str = "messages"
+
+ def __post_init__(self):
+ if self.tokenizer.pad_token_id is None:
+ raise ValueError("The tokenizer does not have a pad token. Please set `pad_token_id` in the tokenizer.")
+ if self.max_length is None:
+ # set a sensible default
+ self.max_length = min(self.tokenizer.model_max_length, 1024)
+
+ def __call__(self, examples: list[dict[str, Any]]) -> dict[str, torch.Tensor]:
+ input_ids = []
+ attention_mask = []
+ prompts_input_ids = []
+ prompt_attention_mask = []
+ labels = []
+ byte_offsets: list[list[tuple[int, int]]] = []
+
+ for example in examples:
+ formatted_prompt = example.get(self.prompt_key, example.get("original_prompt_text", None))
+ if formatted_prompt is None:
+ prompt = example[self.messages_key][:-1]
+ formatted_prompt = self.tokenizer.apply_chat_template(
+ prompt, add_generation_prompt=True, tokenize=False
+ )
+
+ if "input_ids" not in example:
+ message = example[self.messages_key]
+ formatted_message = self.tokenizer.apply_chat_template(
+ message, add_generation_prompt=False, tokenize=False
+ )
+ if is_byte_level_tokenizer(self.tokenizer.backend_tokenizer):
+ [(message_input_ids_full, full_offs)] = encode_with_byte_offsets(
+ self.tokenizer.backend_tokenizer, [formatted_message], add_special_tokens=False
+ )
+ prompt_byte_len = len(formatted_prompt.encode("utf-8"))
+ completion_start_idx_full = next(
+ (idx for idx, (start, _) in enumerate(full_offs) if start >= prompt_byte_len),
+ len(message_input_ids_full),
+ )
+ else:
+ # Non-ByteLevel tokenizer: byte offsets are unnecessary (cross-tokenizer ULD requires ByteLevel
+ # anyway). Fall back to plain tokenization so GKD / non-ULD trainers with SentencePiece or
+ # Unigram tokenizers still work through this collator.
+ message_input_ids_full = self.tokenizer(
+ formatted_message, add_special_tokens=False, return_tensors=None
+ )["input_ids"]
+ completion_start_idx_full = len(
+ self.tokenizer(formatted_prompt, add_special_tokens=False, return_tensors=None)["input_ids"]
+ )
+ full_offs = [(0, 0)] * len(message_input_ids_full)
+ prompt_byte_len = 0
+
+ # Keep the last max_length tokens — drops oldest prompt context first,
+ # never drops from the END (the model's recent context).
+ if self.max_length is not None and len(message_input_ids_full) > self.max_length:
+ sample_ids = message_input_ids_full[-self.max_length :]
+ sample_offs = full_offs[-self.max_length :]
+ current_prompt_len = max(
+ 0, completion_start_idx_full - (len(message_input_ids_full) - self.max_length)
+ )
+ else:
+ sample_ids = message_input_ids_full
+ sample_offs = full_offs
+ current_prompt_len = completion_start_idx_full
+
+ # Make completion-relative: prompt positions zeroed, completion offsets shifted. If truncation
+ # ate into the completion (no prompt tokens kept and the first kept token is mid-completion),
+ # rebase to byte 0 of the kept completion so teacher/student share the same coordinate system.
+ kept_completion_offs = sample_offs[current_prompt_len:]
+ base = (
+ kept_completion_offs[0][0] if kept_completion_offs and current_prompt_len == 0 else prompt_byte_len
+ )
+ completion_offs = [(s - base, e - base) for s, e in kept_completion_offs]
+ sample_offs = [(0, 0)] * current_prompt_len + completion_offs
+
+ input_ids.append(sample_ids)
+ attention_mask.append([1] * len(sample_ids))
+ current_prompt_ids = sample_ids[:current_prompt_len]
+ byte_offsets.append(sample_offs)
+ else:
+ sample_ids = example["input_ids"]
+ input_ids.append(sample_ids)
+ attention_mask.append(example.get("attention_mask", [1] * len(sample_ids)))
+ completion_mask = example.get("completion_mask")
+ if completion_mask is not None:
+ # Use the tracked boundary directly: no re-tokenization, survives truncation.
+ prompt_len = completion_mask.index(1) if 1 in completion_mask else len(sample_ids)
+ current_prompt_ids = sample_ids[:prompt_len]
+ else:
+ # No tracked boundary: tokenize the prompt and cap with a slice (avoid `truncation=True`,
+ # which would persist on the shared backend used by `encode_with_byte_offsets`).
+ tokenized_prompt = self.tokenizer(
+ formatted_prompt,
+ padding=False,
+ return_tensors=None,
+ add_special_tokens=False,
+ )
+ current_prompt_ids = tokenized_prompt["input_ids"][: len(sample_ids)]
+ byte_offsets.append(example.get("byte_offsets", [(0, 0)] * len(sample_ids)))
+
+ prompts_input_ids.append(current_prompt_ids)
+ prompt_attention_mask.append([1] * len(current_prompt_ids))
+
+ label = [self.ignore_index] * len(sample_ids)
+ label[len(current_prompt_ids) :] = sample_ids[len(current_prompt_ids) :]
+ labels.append(label)
+
+ input_ids = pad(
+ [torch.tensor(x, dtype=torch.long) for x in input_ids],
+ padding_side="left",
+ padding_value=self.tokenizer.pad_token_id,
+ )
+ attention_mask = pad(
+ [torch.tensor(x, dtype=torch.long) for x in attention_mask], padding_side="left", padding_value=0
+ )
+ labels = pad(
+ [torch.tensor(x, dtype=torch.long) for x in labels], padding_side="left", padding_value=self.ignore_index
+ )
+ prompts_input_ids = pad(
+ [torch.tensor(x, dtype=torch.long) for x in prompts_input_ids],
+ padding_side="left",
+ padding_value=self.tokenizer.pad_token_id,
+ )
+ prompt_attention_mask = pad(
+ [torch.tensor(x, dtype=torch.long) for x in prompt_attention_mask], padding_side="left", padding_value=0
+ )
+
+ target_len = input_ids.size(1)
+ byte_offsets_tensor = torch.stack(
+ [pad_byte_offsets(offs, target_len, padding_side="left") for offs in byte_offsets], dim=0
+ )
+
+ out = {
+ "input_ids": input_ids,
+ "attention_mask": attention_mask,
+ "labels": labels,
+ "prompts": prompts_input_ids,
+ "prompt_attention_mask": prompt_attention_mask,
+ "byte_offsets": byte_offsets_tensor,
+ }
+ # Forward source text for cross-tokenizer ULD, when the dataset has it.
+ if "original_prompt_text" in examples[0] and "original_completion_text" in examples[0]:
+ out["original_prompt_text"] = [ex["original_prompt_text"] for ex in examples]
+ out["original_completion_text"] = [ex["original_completion_text"] for ex in examples]
+ return out
+
+
+def truncate_right(
+ input_ids: torch.Tensor, stop_token_id: int, pad_token_id: int
+) -> tuple[torch.Tensor, torch.Tensor]:
+ """
+ Truncates the input tensor from the right side after the first occurrence of the stop token.
+
+ Args:
+ input_ids (`torch.Tensor`):
+ The tensor containing the responses to be truncated
+ stop_token_id (`int`):
+ The token ID representing the stop token where truncation occurs
+ pad_token_id (`int`):
+ The token ID representing the pad token used to fill the truncated responses
+
+ Returns:
+ tuple:
+ - `output_ids` (`torch.Tensor`):
+ The truncated responses tensor with pad tokens filled after the stop token
+ - `mask` (`torch.Tensor`):
+ The mask tensor to indicate the padding tokens
+ """
+ trunc_idxs = first_true_indices(input_ids == stop_token_id).unsqueeze(-1)
+ new_size = [1] * (len(input_ids.size()) - 1) + [input_ids.shape[1]]
+ idxs = torch.arange(input_ids.shape[1], device=input_ids.device).view(*new_size)
+ output_ids = torch.masked_fill(input_ids, idxs > trunc_idxs, pad_token_id)
+ mask = torch.masked_fill(torch.ones_like(input_ids), idxs > trunc_idxs, 0)
+ return output_ids, mask
+
+
+def add_bos_token_if_needed(
+ bos_token_id: int | None,
+ prompt_len_input_ids: int,
+ prompt_tokens: dict[str, list[int]],
+ chosen_prompt_len_input_ids: int,
+ chosen_tokens: dict[str, list[int]],
+ rejected_prompt_len_input_ids: int,
+ rejected_tokens: dict[str, list[int]],
+):
+ if bos_token_id is not None:
+ if prompt_len_input_ids == 0 or bos_token_id != prompt_tokens["prompt_input_ids"][0]:
+ prompt_tokens["prompt_input_ids"] = [bos_token_id] + prompt_tokens["prompt_input_ids"]
+ prompt_tokens["prompt_attention_mask"] = [1] + prompt_tokens["prompt_attention_mask"]
+ if chosen_prompt_len_input_ids == 0 or bos_token_id != chosen_tokens["prompt_input_ids"][0]:
+ chosen_tokens["prompt_input_ids"] = [bos_token_id] + chosen_tokens["prompt_input_ids"]
+ chosen_tokens["prompt_attention_mask"] = [1] + chosen_tokens["prompt_attention_mask"]
+ if rejected_prompt_len_input_ids == 0 or bos_token_id != rejected_tokens["prompt_input_ids"][0]:
+ rejected_tokens["prompt_input_ids"] = [bos_token_id] + rejected_tokens["prompt_input_ids"]
+ rejected_tokens["prompt_attention_mask"] = [1] + rejected_tokens["prompt_attention_mask"]
+ return prompt_tokens, chosen_tokens, rejected_tokens
+
+
+def add_eos_token_if_needed(
+ eos_token_id: int, chosen_tokens: dict[str, list[int]], rejected_tokens: dict[str, list[int]]
+):
+ if len(chosen_tokens["input_ids"]) == 0 or eos_token_id != chosen_tokens["input_ids"][-1]:
+ chosen_tokens["input_ids"].append(eos_token_id)
+ chosen_tokens["attention_mask"].append(1)
+ if len(rejected_tokens["input_ids"]) == 0 or eos_token_id != rejected_tokens["input_ids"][-1]:
+ rejected_tokens["input_ids"].append(eos_token_id)
+ rejected_tokens["attention_mask"].append(1)
+ return chosen_tokens, rejected_tokens
+
+
+def first_true_indices(bools: torch.Tensor, dtype=torch.long) -> torch.Tensor:
+ """
+ Takes an N-dimensional bool tensor and returns an (N-1)-dimensional tensor of integers giving the position of the
+ first True in each "row".
+
+ Returns the length of the rows (bools.size(-1)) if no element is True in a given row.
+
+ Args:
+ bools (`torch.Tensor`):
+ An N-dimensional boolean tensor.
+ dtype (`torch.dtype`, *optional*):
+ The desired data type of the output tensor. Defaults to `torch.long`.
+
+ Returns:
+ `torch.Tensor`:
+ An (N-1)-dimensional tensor of integers indicating the position of the first True in each row. If no True
+ value is found in a row, returns the length of the row.
+ """
+ row_len = bools.size(-1)
+ zero_or_index = row_len * (~bools).type(dtype) + torch.arange(row_len, dtype=dtype, device=bools.device)
+ return torch.min(zero_or_index, dim=-1).values
+
+
+def get_reward(
+ model: torch.nn.Module, query_responses: torch.Tensor, pad_token_id: int, context_length: int
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ """
+ Computes the reward logits and the rewards for a given model and query responses.
+
+ Args:
+ model (`torch.nn.Module`):
+ The model used to compute the reward logits.
+ query_responses (`torch.Tensor`):
+ The tensor containing the query responses.
+ pad_token_id (`int`):
+ The token ID representing the pad token.
+ context_length (`int`):
+ The length of the context in the query responses.
+
+ Returns:
+ tuple:
+ - `reward_logits` (`torch.Tensor`):
+ The logits for the reward model.
+ - `final_rewards` (`torch.Tensor`):
+ The final rewards for each query response.
+ - `sequence_lengths` (`torch.Tensor`):
+ The lengths of the sequences in the query responses.
+ """
+ attention_mask = query_responses != pad_token_id
+ position_ids = attention_mask.cumsum(1) - attention_mask.long() # exclusive cumsum
+ lm_backbone = getattr(model, model.base_model_prefix)
+ input_ids = torch.masked_fill(query_responses, ~attention_mask, 0)
+ output = lm_backbone(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ return_dict=True,
+ output_hidden_states=True,
+ use_cache=False, # otherwise mistral-based RM would error out
+ )
+ reward_logits = model.score(output.hidden_states[-1])
+ sequence_lengths = first_true_indices(query_responses[:, context_length:] == pad_token_id) - 1 + context_length
+ # https://github.com/huggingface/transformers/blob/dc68a39c8111217683bf49a4912d0c9018bab33d/src/transformers/models/gpt2/modeling_gpt2.py#L1454
+ return (
+ reward_logits,
+ reward_logits[
+ torch.arange(reward_logits.size(0), device=reward_logits.device),
+ sequence_lengths,
+ ].squeeze(-1),
+ sequence_lengths,
+ )
+
+
+def prepare_model_for_kbit_training(model, use_gradient_checkpointing=True, gradient_checkpointing_kwargs=None):
+ r"""
+ Prepare a k-bit quantized transformers model for training (PEFT/QLoRA).
+ """
+ loaded_in_kbit = getattr(model, "is_loaded_in_8bit", False) or getattr(model, "is_loaded_in_4bit", False)
+ quant_methods = ["gptq", "aqlm", "eetq", "torchao", "hqq"]
+ is_quantized = getattr(model, "quantization_method", None) in quant_methods or getattr(
+ model, "hqq_quantized", False
+ )
+
+ if gradient_checkpointing_kwargs is None:
+ gradient_checkpointing_kwargs = {}
+
+ for _, param in model.named_parameters():
+ # freeze all parameters
+ param.requires_grad = False
+
+ # Enable gradient checkpointing if needed
+ if (loaded_in_kbit or is_quantized) and use_gradient_checkpointing:
+ if hasattr(model, "enable_input_require_grads"):
+ model.enable_input_require_grads()
+ else:
+ # backward-compatible hook
+ def make_inputs_require_grad(module, input, output):
+ output.requires_grad_(True)
+
+ model.get_input_embeddings().register_forward_hook(make_inputs_require_grad)
+
+ supports_gc_kwargs = "gradient_checkpointing_kwargs" in list(
+ inspect.signature(model.gradient_checkpointing_enable).parameters
+ )
+ gc_kwargs = {"gradient_checkpointing_kwargs": gradient_checkpointing_kwargs} if supports_gc_kwargs else {}
+ model.gradient_checkpointing_enable(**gc_kwargs)
+
+ return model
+
+
+def enable_gradient_checkpointing(
+ model: PreTrainedModel, gradient_checkpointing_kwargs: dict | None
+) -> PreTrainedModel:
+ """Enables gradient checkpointing for the model."""
+ # Enable gradient checkpointing on the base model for PEFT
+ if is_peft_model(model):
+ model.base_model.gradient_checkpointing_enable()
+ # Enable gradient checkpointing for non-PEFT models
+ else:
+ model.gradient_checkpointing_enable()
+
+ gradient_checkpointing_kwargs = gradient_checkpointing_kwargs or {}
+ use_reentrant = (
+ "use_reentrant" not in gradient_checkpointing_kwargs or gradient_checkpointing_kwargs["use_reentrant"]
+ )
+
+ if use_reentrant:
+ if hasattr(model, "enable_input_require_grads"):
+ model.enable_input_require_grads()
+ else:
+
+ def make_inputs_require_grad(module, input, output):
+ output.requires_grad_(True)
+
+ model.get_input_embeddings().register_forward_hook(make_inputs_require_grad)
+
+ return model
+
+
+def prepare_peft_model(
+ model: PreTrainedModel, peft_config: "PeftConfig | None", args: TrainingArguments
+) -> PreTrainedModel:
+ """Prepares a model for PEFT training."""
+ if not is_peft_available():
+ raise ImportError("PEFT is required to use a peft model. Run `pip install peft`.")
+
+ if isinstance(model, PeftModel) and peft_config is not None:
+ raise ValueError(
+ "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first merge and "
+ "unload the existing adapter, save the resulting base model, and then pass that base model along with the "
+ "new `peft_config` to the trainer."
+ )
+
+ # Handle quantized models (QLoRA)
+ is_qlora = getattr(model, "is_loaded_in_4bit", False) or getattr(model, "is_loaded_in_8bit", False)
+
+ is_sharded_qlora = False
+ if getattr(model, "is_loaded_in_4bit", False):
+ # Check if model is sharded (FSDP/DS-Zero3)
+ for _, param in model.named_parameters():
+ if param.__class__.__name__ == "Params4bit":
+ is_sharded_qlora = param.data.device.type in {"cpu", "meta"}
+ break
+
+ # Prepare model for kbit training if needed
+ if is_qlora and not is_sharded_qlora and not isinstance(model, PeftModel):
+ model = prepare_model_for_kbit_training(
+ model,
+ use_gradient_checkpointing=args.gradient_checkpointing,
+ gradient_checkpointing_kwargs=args.gradient_checkpointing_kwargs or {},
+ )
+ # Disable gradient checkpointing as it's handled by prepare_model_for_kbit_training
+ args.gradient_checkpointing = False
+ elif args.gradient_checkpointing:
+ model = enable_gradient_checkpointing(model, args.gradient_checkpointing_kwargs)
+
+ # Create PEFT model
+ if peft_config is not None:
+ if (
+ Version(peft.__version__) >= Version("0.12") # autocast_adapter_dtype introduced in 0.12
+ and getattr(model, "is_loaded_in_4bit", False)
+ and is_sharded_qlora
+ ):
+ model = get_peft_model(model, peft_config, autocast_adapter_dtype=False)
+ else:
+ model = get_peft_model(model, peft_config)
+
+ # Handle bf16 casting for 4-bit models
+ if args.bf16 and getattr(model, "is_loaded_in_4bit", False) and not is_sharded_qlora:
+ peft_module_casting_to_bf16(model)
+
+ return model
+
+
+def pad_to_length(tensor: torch.Tensor, length: int, pad_value: int | float, dim: int = -1) -> torch.Tensor:
+ if tensor.size(dim) >= length:
+ return tensor
+ else:
+ pad_size = list(tensor.shape)
+ pad_size[dim] = length - tensor.size(dim)
+ return torch.cat(
+ [
+ tensor,
+ pad_value * torch.ones(*pad_size, dtype=tensor.dtype, device=tensor.device),
+ ],
+ dim=dim,
+ )
+
+
+def empty_cache() -> None:
+ """Empties the cache of the available torch device.
+
+ This function checks for the availability of different torch devices (CUDA, MLU, MPS, NPU, XPU) and empties the
+ cache of the first available device it finds.
+
+ If none of the specific devices are available, it defaults to emptying the CUDA cache.
+ """
+ if is_torch_mlu_available():
+ torch.mlu.empty_cache()
+ elif is_torch_mps_available():
+ torch.mps.empty_cache()
+ elif is_torch_npu_available():
+ torch.npu.empty_cache()
+ elif is_torch_xpu_available():
+ torch.xpu.empty_cache()
+ else:
+ torch.cuda.empty_cache()
+
+
+def peft_module_casting_to_bf16(model):
+ for name, module in model.named_modules():
+ if isinstance(module, torch.nn.LayerNorm) or "norm" in name:
+ module = module.to(torch.float32)
+ elif any(x in name for x in ["lm_head", "embed_tokens", "wte", "wpe"]):
+ if hasattr(module, "weight"):
+ if module.weight.dtype == torch.float32:
+ module = module.to(torch.bfloat16)
+
+
+LAYER_PATTERNS = [
+ "transformer.h.{layer}",
+ "model.decoder.layers.{layer}",
+ "gpt_neox.layers.{layer}",
+ "model.layers.{layer}",
+]
+
+
+def create_reference_model(
+ model: nn.Module, num_shared_layers: int | None = None, pattern: str | None = None
+) -> nn.Module:
+ """
+ Creates a static reference copy of a model. Note that model will be in `.eval()` mode.
+
+ Args:
+ model ([`nn.Module`]): The model to be copied.
+ num_shared_layers (`int`, *optional*):
+ The number of initial layers that are shared between both models and kept frozen. Shared layers reference
+ the same storage as the source model, so they are not duplicated in memory.
+ pattern (`str`, *optional*): The shared layers are selected with a string pattern
+ (e.g. "transformer.h.{layer}" for GPT2) and if a custom pattern is necessary it can be passed here.
+
+ Returns:
+ [`nn.Module`]
+ """
+ if is_deepspeed_zero3_enabled():
+ raise ValueError(
+ "DeepSpeed ZeRO-3 is enabled and is not compatible with `create_reference_model()`. Please instantiate your reference model directly with `AutoModelForCausalLM.from_pretrained()`."
+ )
+
+ parameter_names = [n for n, _ in model.named_parameters()]
+ ref_model = deepcopy(model)
+
+ # if no layers are shared, return copy of model
+ if num_shared_layers is None:
+ for param_name in parameter_names:
+ param = ref_model.get_parameter(param_name)
+ param.requires_grad = False
+ return ref_model.eval()
+
+ # identify layer name pattern
+ if pattern is not None:
+ pattern = pattern.format(layer=num_shared_layers)
+ else:
+ for pattern_candidate in LAYER_PATTERNS:
+ pattern_candidate = pattern_candidate.format(layer=num_shared_layers)
+ if any(pattern_candidate in name for name in parameter_names):
+ pattern = pattern_candidate
+ break
+
+ if pattern is None:
+ raise ValueError("Layer pattern could not be matched.")
+
+ # divide parameters in shared and unshared parameter lists
+ shared_param_list = []
+ unshared_param_list = []
+
+ shared_parameter = True
+ for name, _param in model.named_parameters():
+ if pattern in name:
+ shared_parameter = False
+ if shared_parameter:
+ shared_param_list.append(name)
+ else:
+ unshared_param_list.append(name)
+
+ # Freeze the shared layers in the source model, then point the reference parameter at the same
+ # storage instead of keeping the `deepcopy` duplicate. The shared (frozen) layers are thus held in
+ # memory only once; because they are frozen in the model, the reference stays static during training.
+ for param_name in shared_param_list:
+ param = model.get_parameter(param_name)
+ param.requires_grad = False
+
+ ref_param = ref_model.get_parameter(param_name)
+ ref_param.data = param.data
+ ref_param.requires_grad = False
+
+ # for all other parameters just make sure they don't use gradients
+ for param_name in unshared_param_list:
+ param = ref_model.get_parameter(param_name)
+ param.requires_grad = False
+
+ if pattern is not None and len(unshared_param_list) == 0:
+ logging.warning("Pattern passed or found, but no layers matched in the model. Check for a typo.")
+
+ return ref_model.eval()
+
+
+def truncate_dataset(
+ dataset: DatasetType,
+ max_length: int,
+ map_kwargs: dict[str, Any] | None = None,
+) -> DatasetType:
+ r"""
+ Truncate sequences in a dataset to a specified `max_length`.
+
+ Args:
+ dataset ([`~datasets.Dataset`] or [`~datasets.DatasetDict`]):
+ Dataset to truncate.
+ max_length (`int`):
+ Maximum sequence length to truncate to.
+ map_kwargs (`dict`, *optional*):
+ Additional keyword arguments to pass to the dataset's map method when truncating examples.
+
+ Returns:
+ [`~datasets.Dataset`] or [`~datasets.DatasetDict`]: The dataset with truncated sequences.
+
+ Example:
+ ```python
+ >>> from datasets import Dataset
+
+ >>> examples = {
+ ... "input_ids": [[1, 2, 3], [4, 5, 6, 7], [8]],
+ ... "attention_mask": [[0, 1, 1], [0, 0, 1, 1], [1]],
+ ... }
+ >>> dataset = Dataset.from_dict(examples)
+ >>> truncated_dataset = truncate_dataset(dataset, max_length=2)
+ >>> truncated_dataset[:]
+ {'input_ids': [[1, 2], [4, 5], [8]],
+ 'attention_mask': [[0, 1], [0, 0], [1]]}
+ ```
+ """
+ if map_kwargs is None:
+ map_kwargs = {}
+
+ def truncate(examples):
+ truncated_columns = []
+ for column in examples.columns:
+ if pyarrow.types.is_list(column.type) or pyarrow.types.is_large_list(column.type):
+ column = pc.list_slice(column, 0, max_length)
+ truncated_columns.append(column)
+ return pa.Table.from_arrays(truncated_columns, names=examples.column_names)
+
+ format = _get_dataset_format(dataset)
+ dataset = dataset.with_format("arrow")
+ dataset = dataset.map(truncate, batched=True, **map_kwargs)
+ dataset = dataset.with_format(**format)
+ return dataset
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/xpo/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/xpo/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2fc35384cd4246001ac14d1bd126430cce00b122
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/xpo/__init__.py
@@ -0,0 +1,19 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .xpo_config import XPOConfig
+from .xpo_trainer import XPOTrainer
+
+
+__all__ = ["XPOConfig", "XPOTrainer"]
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/xpo/xpo_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/xpo/xpo_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..243545084617bdc8f384289cb76883d22fcfaf54
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/xpo/xpo_config.py
@@ -0,0 +1,44 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+
+from ..online_dpo import OnlineDPOConfig
+
+
+@dataclass
+class XPOConfig(OnlineDPOConfig):
+ r"""
+ Configuration class for the [`experimental.xpo.XPOTrainer`].
+
+ Subclass of [`experimental.online_dpo.OnlineDPOConfig`] we can use all its arguments and add the following:
+
+ Parameters:
+ alpha (`float` or `list[float]`, *optional*, defaults to `1e-5`):
+ Weight of the XPO loss term. If a list of floats is provided then the alpha is selected for each new epoch
+ and the last alpha is used for the rest of the epochs.
+ """
+
+ alpha: list[float] = field(
+ default_factory=lambda: [1e-5],
+ metadata={
+ "help": "Weight of the XPO loss term. If a list of floats is provided then the alpha is selected for each "
+ "new epoch and the last alpha is used for the rest of the epochs."
+ },
+ )
+
+ def __post_init__(self):
+ super().__post_init__()
+ if hasattr(self.alpha, "__len__") and len(self.alpha) == 1:
+ self.alpha = self.alpha[0]
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/xpo/xpo_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/xpo/xpo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..5edbbc3dc2022802816fba8ea8b52f486745d3a1
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/experimental/xpo/xpo_trainer.py
@@ -0,0 +1,506 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import textwrap
+from collections.abc import Callable
+from typing import Any
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from datasets import Dataset, IterableDataset
+from transformers import (
+ BaseImageProcessor,
+ FeatureExtractionMixin,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+ ProcessorMixin,
+ TrainerCallback,
+)
+from transformers.trainer_utils import EvalPrediction
+from transformers.training_args import OptimizerNames
+from transformers.utils import is_peft_available
+
+from ...data_utils import maybe_apply_chat_template
+from ...models.utils import unwrap_model_for_generation
+from ...trainer.utils import selective_log_softmax
+from ..online_dpo import OnlineDPOTrainer
+from ..utils import empty_cache, get_reward, truncate_right
+from .xpo_config import XPOConfig
+
+
+if is_peft_available():
+ from peft import PeftConfig, PeftModel
+
+
+class XPOTrainer(OnlineDPOTrainer):
+ """
+ Trainer for Exploratory Preference Optimization (XPO).
+
+ It is implemented as a subclass of [`experimental.online_dpo.OnlineDPOTrainer`].
+
+ Args:
+ model ([`~transformers.PreTrainedModel`]):
+ The model to train, preferably an `AutoModelForCausalLM`.
+ ref_model ([`~transformers.PreTrainedModel`]):
+ Hugging Face transformer model with a casual language modelling head. Used for implicit reward computation
+ and loss. If no reference model is provided, the trainer will create a reference model with the same
+ architecture as the model to be optimized.
+ reward_funcs ([`~transformers.PreTrainedModel`]):
+ The reward model to score completions with, preferably an
+ [`~transformers.AutoModelForSequenceClassification`].
+ args ([`experimental.xpo.XPOConfig`]):
+ The XPO config arguments to use for training.
+ data_collator ([`~transformers.DataCollator`]):
+ The data collator to use for training. If None is specified, the default data collator
+ ([`experimental.utils.DPODataCollatorWithPadding`]) will be used which will pad the sequences to the
+ maximum length of the sequences in the batch, given a dataset of paired sequences.
+ train_dataset ([`~datasets.Dataset`]):
+ The dataset to use for training.
+ eval_dataset ([`~datasets.Dataset`]):
+ The dataset to use for evaluation.
+ processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.BaseImageProcessor`], [`~transformers.FeatureExtractionMixin`] or [`~transformers.ProcessorMixin`], *optional*):
+ Processing class used to process the data. If provided, will be used to automatically process the inputs
+ for the model, and it will be saved along the model to make it easier to rerun an interrupted training or
+ reuse the fine-tuned model.
+ reward_processing_classes ([`~transformers.PreTrainedTokenizerBase`] or `list[PreTrainedTokenizerBase]`, *optional*):
+ Processing classes corresponding to the reward functions specified in `reward_funcs`. Can be either:
+
+ - A single processing class: Used when `reward_funcs` contains only one reward function.
+ - A list of processing classes: Must match the order and length of the reward functions in `reward_funcs`.
+
+ If set to `None`, the tokenizer for each model-based reward function is automatically loaded using
+ [`~transformers.AutoTokenizer.from_pretrained`].
+ peft_config ([`~peft.PeftConfig`], *optional*):
+ The peft config to use for training.
+ compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*):
+ The function to use to compute the metrics. Must take a `EvalPrediction` and return a dictionary string to
+ metric values.
+ callbacks (`list[transformers.TrainerCallback]`):
+ The callbacks to use for training.
+ optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`):
+ The optimizer and scheduler to use for training.
+ preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`):
+ The function to use to preprocess the logits before computing the metrics.
+ """
+
+ _tag_names = ["trl", "xpo"]
+ _name = "XPO"
+ _paper = {
+ "title": "Exploratory Preference Optimization: Harnessing Implicit Q*-Approximation for Sample-Efficient RLHF",
+ "id": "2405.21046",
+ # docstyle-ignore
+ "citation": textwrap.dedent("""\
+ @article{jung2024binary,
+ title = {{Exploratory Preference Optimization: Harnessing Implicit Q*-Approximation for Sample-Efficient RLHF}},
+ author = {Tengyang Xie and Dylan J. Foster and Akshay Krishnamurthy and Corby Rosset and Ahmed Awadallah and Alexander Rakhlin},
+ year = 2024,
+ eprint = {arXiv:2405.21046}
+ }"""),
+ }
+
+ def __init__(
+ self,
+ model: PreTrainedModel | nn.Module = None,
+ ref_model: PreTrainedModel | nn.Module = None,
+ reward_funcs: nn.Module | None = None,
+ args: XPOConfig | None = None,
+ data_collator: Callable | None = None,
+ train_dataset: Dataset | IterableDataset | None = None,
+ eval_dataset: Dataset | dict[str, Dataset] | None = None,
+ processing_class: PreTrainedTokenizerBase
+ | BaseImageProcessor
+ | FeatureExtractionMixin
+ | ProcessorMixin
+ | None = None,
+ reward_processing_classes: PreTrainedTokenizerBase | list[PreTrainedTokenizerBase] | None = None,
+ peft_config: "PeftConfig | None" = None,
+ compute_metrics: Callable[[EvalPrediction], dict] | None = None,
+ callbacks: list[TrainerCallback] | None = None,
+ optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None),
+ preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None,
+ ) -> None:
+ super().__init__(
+ model=model,
+ ref_model=ref_model,
+ reward_funcs=reward_funcs,
+ args=args,
+ data_collator=data_collator,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=processing_class,
+ reward_processing_classes=reward_processing_classes,
+ peft_config=peft_config,
+ compute_metrics=compute_metrics,
+ callbacks=callbacks,
+ optimizers=optimizers,
+ preprocess_logits_for_metrics=preprocess_logits_for_metrics,
+ )
+
+ self._alpha = self.args.alpha
+
+ # Overwrite the stats dictionary to include XPO specific statistics
+ self.stats = {
+ # Remove "non_score_reward", "rlhf_reward", "scores"
+ # Add "loss/dpo", "loss/xpo"
+ "loss/dpo": [],
+ "loss/xpo": [],
+ "objective/kl": [],
+ "objective/entropy": [],
+ "rewards/chosen": [],
+ "rewards/rejected": [],
+ "rewards/accuracies": [],
+ "rewards/margins": [],
+ "logps/chosen": [],
+ "logps/rejected": [],
+ # Replace "contain_eos_token" by "model_contain_eos_token" and "ref_contain_eos_token"
+ "val/model_contain_eos_token": [],
+ "val/ref_contain_eos_token": [],
+ "objective/model_scores": [],
+ "objective/ref_scores": [],
+ "objective/scores_margin": [],
+ "alpha": [],
+ "beta": [],
+ }
+ if len(self.reward_funcs) != 1:
+ raise ValueError("XPOTrainer only supports one reward function/model.")
+ self.reward_funcs = self.reward_funcs[0]
+
+ @property
+ def alpha(self):
+ if isinstance(self._alpha, list):
+ epoch = self.state.epoch
+ return self._alpha[epoch] if epoch < len(self._alpha) else self._alpha[-1]
+ else:
+ return self._alpha
+
+ def _generate_completions(self, prompts, model):
+ with (
+ unwrap_model_for_generation(
+ model,
+ self.accelerator,
+ generation_kwargs=self.generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762
+ ) as unwrapped_policy_model_for_gen,
+ ):
+ model_output = unwrapped_policy_model_for_gen.generate(
+ input_ids=prompts["input_ids"],
+ attention_mask=prompts["attention_mask"],
+ generation_config=self.generation_config,
+ )
+
+ actual_model_for_ref_generation: torch.nn.Module
+ if self.ref_model is None:
+ unwrapped_main_model_for_ref_logic = self.accelerator.unwrap_model(model)
+
+ if is_peft_available() and isinstance(unwrapped_main_model_for_ref_logic, PeftModel):
+ actual_model_for_ref_generation = unwrapped_main_model_for_ref_logic.get_base_model()
+ else:
+ actual_model_for_ref_generation = unwrapped_main_model_for_ref_logic
+ else:
+ actual_model_for_ref_generation = self.accelerator.unwrap_model(self.ref_model)
+
+ with (
+ unwrap_model_for_generation(
+ actual_model_for_ref_generation,
+ self.accelerator,
+ generation_kwargs=self.generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762
+ ) as final_ref_model_for_gen,
+ ):
+ ref_output = final_ref_model_for_gen.generate(
+ input_ids=prompts["input_ids"],
+ attention_mask=prompts["attention_mask"],
+ generation_config=self.generation_config,
+ )
+
+ return model_output, ref_output
+
+ def _process_completions(self, model_output, ref_output, prompts):
+ context_length = prompts["input_ids"].shape[1]
+
+ # Process model completions
+ model_completion_ids = model_output[:, context_length:]
+ model_completion_ids, model_completion_mask = truncate_right(
+ model_completion_ids, self.processing_class.eos_token_id, self.processing_class.pad_token_id
+ )
+ model_data = {
+ "input_ids": torch.cat((prompts["input_ids"], model_completion_ids), dim=1),
+ "attention_mask": torch.cat((prompts["attention_mask"], model_completion_mask), dim=1),
+ "raw": prompts["raw"],
+ }
+
+ # Process reference model completions
+ ref_completion_ids = ref_output[:, context_length:]
+ ref_completion_ids, ref_completion_mask = truncate_right(
+ ref_completion_ids, self.processing_class.eos_token_id, self.processing_class.pad_token_id
+ )
+ ref_data = {
+ "input_ids": torch.cat((prompts["input_ids"], ref_completion_ids), dim=1),
+ "attention_mask": torch.cat((prompts["attention_mask"], ref_completion_mask), dim=1),
+ "raw": prompts["raw"],
+ }
+
+ return model_data, ref_data
+
+ def _compute_rewards(self, model_data, ref_data, context_length):
+ with torch.no_grad():
+ _, model_scores, _ = get_reward(
+ self.reward_funcs, model_data["input_ids"], self.processing_class.pad_token_id, context_length
+ )
+ _, ref_scores, _ = get_reward(
+ self.reward_funcs, ref_data["input_ids"], self.processing_class.pad_token_id, context_length
+ )
+
+ # Apply EOS penalty if needed
+ if self.args.missing_eos_penalty is not None:
+ model_contain_eos = torch.any(model_data["input_ids"] == self.processing_class.eos_token_id, dim=-1)
+ ref_contain_eos = torch.any(ref_data["input_ids"] == self.processing_class.eos_token_id, dim=-1)
+ model_scores[~model_contain_eos] -= self.args.missing_eos_penalty
+ ref_scores[~ref_contain_eos] -= self.args.missing_eos_penalty
+
+ return model_scores, ref_scores
+
+ def _compute_logprobs(self, model, model_data, ref_data, context_length):
+ def compute_logprobs_for_data(m, data):
+ output = m(data["input_ids"], attention_mask=data["attention_mask"])
+ logits = output.logits[:, context_length - 1 : -1]
+ token_logprobs = selective_log_softmax(logits, data["input_ids"][:, context_length:])
+ return token_logprobs
+
+ # Compute logprobs for model completions
+ model_logprobs_model_data = compute_logprobs_for_data(model, model_data)
+ # Compute logprobs for model on reference completions (for XPO loss)
+ model_logprobs_ref_data = compute_logprobs_for_data(model, ref_data)
+
+ # Compute logprobs for reference model completions
+ with torch.no_grad():
+ if self.ref_model is None:
+ with model.disable_adapter():
+ ref_logprobs_model_data = compute_logprobs_for_data(model, model_data)
+ ref_logprobs_ref_data = compute_logprobs_for_data(model, ref_data)
+ else:
+ ref_logprobs_model_data = compute_logprobs_for_data(self.ref_model, model_data)
+ ref_logprobs_ref_data = compute_logprobs_for_data(self.ref_model, ref_data)
+
+ # Mask padding tokens
+ model_padding_mask = model_data["attention_mask"][:, context_length:] == 0
+ ref_padding_mask = ref_data["attention_mask"][:, context_length:] == 0
+ model_logprobs_model_data = model_logprobs_model_data.masked_fill(model_padding_mask, 0.0)
+ model_logprobs_ref_data = model_logprobs_ref_data.masked_fill(ref_padding_mask, 0.0)
+ ref_logprobs_ref_data = ref_logprobs_ref_data.masked_fill(ref_padding_mask, 0.0)
+ ref_logprobs_model_data = ref_logprobs_model_data.masked_fill(model_padding_mask, 0.0)
+
+ return model_logprobs_model_data, model_logprobs_ref_data, ref_logprobs_ref_data, ref_logprobs_model_data
+
+ def _compute_losses(
+ self,
+ model_logprobs_model_data,
+ model_logprobs_ref_data,
+ ref_logprobs_ref_data,
+ ref_logprobs_model_data,
+ chosen_mask,
+ ):
+ # Compute log probs
+ model_logprobs_model_data_sum = model_logprobs_model_data.sum(1)
+ model_logprobs_ref_data_sum = model_logprobs_ref_data.sum(1)
+ ref_logprobs_ref_data_sum = ref_logprobs_ref_data.sum(1)
+ ref_logprobs_model_data_sum = ref_logprobs_model_data.sum(1)
+
+ chosen_model_logprobs = torch.where(chosen_mask, model_logprobs_model_data_sum, model_logprobs_ref_data_sum)
+ chosen_ref_logprobs = torch.where(chosen_mask, ref_logprobs_model_data_sum, ref_logprobs_ref_data_sum)
+ chosen_log_ratios = chosen_model_logprobs - chosen_ref_logprobs
+
+ rejected_model_logprobs = torch.where(~chosen_mask, model_logprobs_model_data_sum, model_logprobs_ref_data_sum)
+ rejected_ref_logprobs = torch.where(~chosen_mask, ref_logprobs_model_data_sum, ref_logprobs_ref_data_sum)
+ rejected_log_ratios = rejected_model_logprobs - rejected_ref_logprobs
+
+ # Compute logits as the difference between chosen and rejected log ratios
+ logits = chosen_log_ratios - rejected_log_ratios
+
+ if self.args.loss_type == "sigmoid":
+ dpo_losses = -F.logsigmoid(self.beta * logits)
+ elif self.args.loss_type == "ipo":
+ dpo_losses = (logits - 1 / (2 * self.beta)) ** 2
+ else:
+ raise NotImplementedError(f"invalid loss type {self.args.loss_type}")
+
+ # Compute XPO specific loss
+ xpo_losses = self.alpha * model_logprobs_ref_data_sum
+
+ # Total loss
+ loss = (dpo_losses + xpo_losses).mean()
+
+ return loss, dpo_losses, xpo_losses
+
+ def _log_statistics(
+ self,
+ model_data,
+ ref_data,
+ model_logprobs_model_data,
+ model_logprobs_ref_data,
+ ref_logprobs_ref_data,
+ ref_logprobs_model_data,
+ chosen_mask,
+ dpo_losses,
+ xpo_losses,
+ context_length,
+ model_scores,
+ ref_scores,
+ ):
+ # Helper function to gather and compute mean
+ def gather_mean(tensor):
+ return self.accelerator.gather_for_metrics(tensor).mean().item()
+
+ # Log losses
+ self.stats["loss/dpo"].append(gather_mean(dpo_losses))
+ self.stats["loss/xpo"].append(gather_mean(xpo_losses))
+
+ # Log scores
+ self.stats["objective/model_scores"].append(gather_mean(model_scores))
+ self.stats["objective/ref_scores"].append(gather_mean(ref_scores))
+ self.stats["objective/scores_margin"].append(gather_mean(model_scores - ref_scores))
+
+ # Log logprobs
+ model_logprobs_model_data_sum = model_logprobs_model_data.sum(1)
+ model_logprobs_ref_data_sum = model_logprobs_ref_data.sum(1)
+ ref_logprobs_ref_data_sum = ref_logprobs_ref_data.sum(1)
+ ref_logprobs_model_data_sum = ref_logprobs_model_data.sum(1)
+
+ chosen_model_logprobs = torch.where(chosen_mask, model_logprobs_model_data_sum, model_logprobs_ref_data_sum)
+ chosen_ref_logprobs = torch.where(chosen_mask, ref_logprobs_model_data_sum, ref_logprobs_ref_data_sum)
+ chosen_log_ratios = chosen_model_logprobs - chosen_ref_logprobs
+
+ rejected_model_logprobs = torch.where(~chosen_mask, model_logprobs_model_data_sum, model_logprobs_ref_data_sum)
+ rejected_ref_logprobs = torch.where(~chosen_mask, ref_logprobs_model_data_sum, ref_logprobs_ref_data_sum)
+ rejected_log_ratios = rejected_model_logprobs - rejected_ref_logprobs
+
+ self.stats["logps/chosen"].append(gather_mean(chosen_model_logprobs.mean() + chosen_ref_logprobs.mean()))
+ self.stats["logps/rejected"].append(gather_mean(rejected_model_logprobs.mean() + rejected_ref_logprobs.mean()))
+
+ # Log rewards
+ # Compute various statistics
+ chosen_rewards = chosen_log_ratios * self.beta
+ rejected_rewards = rejected_log_ratios * self.beta
+ self.stats["rewards/chosen"].append(gather_mean(chosen_rewards.mean()))
+ self.stats["rewards/rejected"].append(gather_mean(rejected_rewards.mean()))
+
+ # Calculate KL divergence for model and ref data
+ kl_model_data = model_logprobs_model_data - ref_logprobs_model_data
+ kl_ref_data = model_logprobs_ref_data - ref_logprobs_ref_data
+ mean_kl = (kl_model_data.sum(1) + kl_ref_data.sum(1)).mean() / 2
+ self.stats["objective/kl"].append(gather_mean(mean_kl))
+
+ # Calculate entropy for model and ref data
+ entropy_model_data = -model_logprobs_model_data.sum(1)
+ entropy_ref_data = -model_logprobs_ref_data.sum(1)
+ mean_entropy = (entropy_model_data.mean() + entropy_ref_data.mean()) / 2
+ self.stats["objective/entropy"].append(gather_mean(mean_entropy))
+
+ # Calculate margins
+ margin = chosen_rewards - rejected_rewards
+ self.stats["rewards/margins"].append(gather_mean(margin.mean()))
+
+ # Calculate accuracy
+ accuracy = (margin > 0).float()
+ self.stats["rewards/accuracies"].append(gather_mean(accuracy.mean()))
+
+ # Log EOS token statistics
+ model_eos = (model_data["input_ids"][:, context_length:] == self.processing_class.eos_token_id).any(dim=1)
+ ref_eos = (ref_data["input_ids"][:, context_length:] == self.processing_class.eos_token_id).any(dim=1)
+ self.stats["val/model_contain_eos_token"].append(gather_mean(model_eos.float()))
+ self.stats["val/ref_contain_eos_token"].append(gather_mean(ref_eos.float()))
+
+ # Log alpha and beta
+ self.stats["alpha"].append(self.alpha)
+ self.stats["beta"].append(self.beta)
+
+ def training_step(
+ self, model: nn.Module, inputs: dict[str, torch.Tensor | Any], num_items_in_batch: int | None = None
+ ) -> torch.Tensor:
+ model.train()
+
+ # Apply chat template and tokenize the input
+ batch_size = len(next(iter(inputs.values())))
+ prompts = inputs["prompt"]
+ inputs = [{k: v[i] for k, v in inputs.items()} for i in range(batch_size)]
+ inputs = [maybe_apply_chat_template(x, self.processing_class) for x in inputs]
+ inputs = [self.tokenize_row(x, self.model.config.is_encoder_decoder, self.processing_class) for x in inputs]
+ inputs = self.data_collator(inputs)
+
+ # need the prompt_ only
+ inputs = self._prepare_inputs(inputs)
+ context_length = inputs["prompt_input_ids"].shape[1]
+ prompts = {
+ "input_ids": inputs["prompt_input_ids"],
+ "attention_mask": inputs["prompt_attention_mask"],
+ "raw": prompts,
+ }
+ del inputs
+
+ # Sample completions from both the model and the reference model
+ model_output, ref_output = self._generate_completions(prompts, model)
+
+ # Process model completions
+ model_data, ref_data = self._process_completions(model_output, ref_output, prompts)
+
+ # Compute rewards
+ model_scores, ref_scores = self._compute_rewards(model_data, ref_data, context_length)
+ chosen_mask = model_scores >= ref_scores
+
+ # Compute logprobs
+ model_logprobs_model_data, model_logprobs_ref_data, ref_logprobs_ref_data, ref_logprobs_model_data = (
+ self._compute_logprobs(model, model_data, ref_data, context_length)
+ )
+
+ # Compute loss
+ loss, dpo_losses, xpo_losses = self._compute_losses(
+ model_logprobs_model_data,
+ model_logprobs_ref_data,
+ ref_logprobs_ref_data,
+ ref_logprobs_model_data,
+ chosen_mask,
+ )
+
+ # Log everything
+ self._log_statistics(
+ model_data,
+ ref_data,
+ model_logprobs_model_data.detach(),
+ model_logprobs_ref_data.detach(),
+ ref_logprobs_ref_data,
+ ref_logprobs_model_data,
+ chosen_mask,
+ dpo_losses.detach(),
+ xpo_losses.detach(),
+ context_length,
+ model_scores,
+ ref_scores,
+ )
+
+ if (
+ self.args.torch_empty_cache_steps is not None
+ and self.state.global_step % self.args.torch_empty_cache_steps == 0
+ ):
+ empty_cache()
+
+ kwargs = {}
+ # For LOMO optimizers you need to explicitly use the learning rate
+ if self.args.optim in [OptimizerNames.LOMO, OptimizerNames.ADALOMO]:
+ kwargs["learning_rate"] = self._get_learning_rate()
+
+ if self.args.n_gpu > 1:
+ loss = loss.mean() # mean() to average on multi-gpu parallel training
+
+ self.accelerator.backward(loss, **kwargs)
+
+ return loss.detach() / self.args.gradient_accumulation_steps
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/extras/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/extras/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d2777dd0eb21a0ea67dce8775337a27ea8499da2
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/extras/__init__.py
@@ -0,0 +1,13 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/extras/dataset_formatting.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/extras/dataset_formatting.py
new file mode 100644
index 0000000000000000000000000000000000000000..6dd89493a33263bda1506f67f661947ac69a3690
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/extras/dataset_formatting.py
@@ -0,0 +1,32 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import datasets
+from datasets import Value
+from packaging.version import Version
+
+
+if Version(datasets.__version__) >= Version("4.0.0"):
+ from datasets import List
+
+ FORMAT_MAPPING = {
+ "chatml": List({"content": Value(dtype="string", id=None), "role": Value(dtype="string", id=None)}),
+ "instruction": {"completion": Value(dtype="string", id=None), "prompt": Value(dtype="string", id=None)},
+ }
+else:
+ FORMAT_MAPPING = {
+ "chatml": [{"content": Value(dtype="string", id=None), "role": Value(dtype="string", id=None)}],
+ "instruction": {"completion": Value(dtype="string", id=None), "prompt": Value(dtype="string", id=None)},
+ }
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/extras/profiling.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/extras/profiling.py
new file mode 100644
index 0000000000000000000000000000000000000000..01a7b62212cfa141ebccd145e722430ce5590c61
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/extras/profiling.py
@@ -0,0 +1,224 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import functools
+import time
+from collections.abc import Callable
+
+from transformers import Trainer
+from transformers.integrations import is_mlflow_available, is_trackio_available, is_wandb_available
+
+
+if is_wandb_available():
+ import wandb
+
+if is_mlflow_available():
+ import mlflow
+
+if is_trackio_available():
+ import trackio
+
+
+class ProfilingContext:
+ """
+ Context manager for profiling code blocks with configurable logging.
+
+ This class handles timing of code execution and logging metrics to various backends (Weights & Biases, MLflow,
+ Trackio) without being coupled to the Trainer class.
+
+ Args:
+ name (`str`):
+ Name of the profiling context. Used in the metric name.
+ report_to (`list` of `str`):
+ List of integrations to report metrics to (e.g., ["wandb", "mlflow", "trackio"]).
+ is_main_process (`bool`, *optional*, defaults to `True`):
+ Whether this is the main process in distributed training. Metrics are only logged from the main process.
+ step (`int` or `None`, *optional*):
+ Training step to associate with the logged metrics.
+ metric_prefix (`str`, *optional*, defaults to `"profiling/Time taken"`):
+ Prefix for the metric name in logs.
+
+ Example:
+ ```python
+ # Direct usage
+ from trl.extras.profiling import ProfilingContext
+
+ with ProfilingContext(
+ name="MyClass.expensive_operation",
+ report_to=["wandb"],
+ is_main_process=True,
+ step=100,
+ ):
+ # Code to profile
+ result = expensive_computation()
+
+ # With Trainer (backwards compatible via profiling_context function)
+ from transformers import Trainer
+ from trl.extras.profiling import profiling_context
+
+
+ class MyTrainer(Trainer):
+ def some_method(self):
+ with profiling_context(self, "matrix_multiplication"):
+ result = matrix_multiply()
+ ```
+ """
+
+ def __init__(
+ self,
+ name: str,
+ report_to: list[str],
+ is_main_process: bool = True,
+ step: int | None = None,
+ metric_prefix: str = "profiling/Time taken",
+ ):
+ self.name = name
+ self.report_to = report_to
+ self.is_main_process = is_main_process
+ self.step = step
+ self.metric_prefix = metric_prefix
+ self._start_time = None
+
+ def __enter__(self):
+ """Start timing when entering the context."""
+ self._start_time = time.perf_counter()
+ return self
+
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ """Stop timing and log metrics when exiting the context."""
+ if self._start_time is not None:
+ duration = time.perf_counter() - self._start_time
+ self._log_metrics(duration)
+ return False
+
+ def _log_metrics(self, duration: float) -> None:
+ """
+ Log profiling metrics to configured backends.
+
+ Args:
+ duration (`float`):
+ Execution time in seconds.
+ """
+ if not self.is_main_process:
+ return
+
+ metric_name = f"{self.metric_prefix}: {self.name}"
+ metrics = {metric_name: duration}
+
+ # Log to Weights & Biases if configured
+ if "wandb" in self.report_to and is_wandb_available() and wandb.run is not None:
+ wandb.log(metrics)
+
+ # Log to MLflow if configured
+ if "mlflow" in self.report_to and is_mlflow_available() and mlflow.active_run() is not None:
+ mlflow.log_metrics(metrics, step=self.step)
+
+ # Log to Trackio if configured
+ if "trackio" in self.report_to and is_trackio_available():
+ trackio.log(metrics, step=self.step)
+
+
+def profiling_context(trainer: Trainer, name: str) -> ProfilingContext:
+ """
+ Factory function to create a ProfilingContext from a Trainer instance.
+
+ This function maintains backwards compatibility with existing code while using the decoupled ProfilingContext class
+ internally.
+
+ Args:
+ trainer (`~transformers.Trainer`):
+ Trainer object containing configuration for logging.
+ name (`str`):
+ Name of the block to be profiled. Will be prefixed with the trainer class name.
+
+ Returns:
+ `ProfilingContext`: A configured profiling context manager.
+
+ Example:
+ ```python
+ from transformers import Trainer
+ from trl.extras.profiling import profiling_context
+
+
+ class MyTrainer(Trainer):
+ def some_method(self):
+ A = np.random.rand(1000, 1000)
+ B = np.random.rand(1000, 1000)
+ with profiling_context(self, "matrix_multiplication"):
+ # Code to profile: simulate a computationally expensive operation
+ result = A @ B # Matrix multiplication
+ ```
+ """
+ context_name = f"{trainer.__class__.__name__}.{name}"
+ step = trainer.state.global_step
+
+ return ProfilingContext(
+ name=context_name,
+ report_to=trainer.args.report_to,
+ is_main_process=trainer.accelerator.is_main_process,
+ step=step,
+ )
+
+
+def profiling_decorator(func: Callable) -> Callable:
+ """
+ Decorator to profile a function and log execution time using [`extras.profiling.profiling_context`].
+
+ This decorator works with methods that have access to a trainer instance (typically as `self`). For non-Trainer
+ objects that have an `accelerator` attribute, it will use that for logging configuration.
+
+ Args:
+ func (`Callable`):
+ Function to be profiled.
+
+ Returns:
+ `Callable`: Wrapped function that profiles execution time.
+
+ Example:
+ ```python
+ from transformers import Trainer
+ from trl.extras.profiling import profiling_decorator
+
+
+ class MyTrainer(Trainer):
+ @profiling_decorator
+ def some_method(self):
+ A = np.random.rand(1000, 1000)
+ B = np.random.rand(1000, 1000)
+ # Code to profile: simulate a computationally expensive operation
+ result = A @ B
+ ```
+ """
+
+ @functools.wraps(func)
+ def wrapper(self, *args, **kwargs):
+ # Check if self is a Trainer-like object with required attributes
+ if hasattr(self, "state") and hasattr(self, "args"):
+ with profiling_context(self, func.__name__):
+ return func(self, *args, **kwargs)
+ # For non-Trainer objects (e.g., VLLMGeneration), use ProfilingContext directly
+ elif hasattr(self, "accelerator"):
+ context_name = f"{self.__class__.__name__}.{func.__name__}"
+ with ProfilingContext(
+ name=context_name,
+ report_to=[], # No reporting for non-Trainer objects without args
+ is_main_process=self.accelerator.is_main_process,
+ step=None,
+ ):
+ return func(self, *args, **kwargs)
+ else:
+ # No profiling available, just run the function
+ return func(self, *args, **kwargs)
+
+ return wrapper
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/generation/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/generation/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..22e7cf6d88463c5b6774725e2b66ee1496bddd22
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/generation/__init__.py
@@ -0,0 +1,25 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Generation backends for TRL trainers."""
+
+from ..import_utils import is_vllm_available
+
+
+__all__ = []
+
+if is_vllm_available():
+ from .vllm_generation import VLLMGeneration
+
+ __all__.append("VLLMGeneration")
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/generation/vllm_client.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/generation/vllm_client.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb05ae5a551365f76b97f0edd54337bc976c57a3
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/generation/vllm_client.py
@@ -0,0 +1,764 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import atexit
+import base64
+import copy
+import logging
+import socket
+import time
+from io import BytesIO
+from urllib.parse import urlparse
+
+import torch
+import torch.distributed.distributed_c10d as c10d
+from requests.adapters import HTTPAdapter
+from torch import nn
+from transformers import is_torch_xpu_available
+from transformers.utils import get_json_schema
+from urllib3.util.retry import Retry
+
+from ..import_utils import is_requests_available, is_vllm_ascend_available, is_vllm_available
+
+
+if is_requests_available():
+ import requests
+ from requests import ConnectionError
+
+
+if is_vllm_available():
+ from vllm.distributed.device_communicators.pynccl import PyNcclCommunicator
+ from vllm.distributed.utils import StatelessProcessGroup
+
+ if is_vllm_ascend_available():
+ from vllm_ascend.distributed.device_communicators.pyhccl import PyHcclCommunicator as PyNcclCommunicator
+
+
+logger = logging.getLogger(__name__)
+
+
+def pil_to_base64(image):
+ buffer = BytesIO()
+ image.save(buffer, format="PNG")
+ img_bytes = buffer.getvalue()
+ return base64.b64encode(img_bytes).decode("utf-8")
+
+
+class VLLMClient:
+ """
+ A client class to interact with a vLLM server.
+
+ This class provides methods to generate completions, initialize and manage weight update groups, and update model
+ weights in a distributed setting. Before using it, start the vLLM server with `trl vllm-serve`.
+
+ Args:
+ base_url (`str`, *optional*):
+ Base URL for the vLLM server (e.g., `"http://localhost:8000"`). If provided, `host` and `server_port` are
+ ignored.
+ host (`str`, *optional*, defaults to `"0.0.0.0"`):
+ IP address of the vLLM server. Ignored if `base_url` is provided.
+ server_port (`int`, *optional*, defaults to `8000`):
+ Port number of the vLLM server. Ignored if `base_url` is provided.
+ group_port (`int`, *optional*, defaults to `51216`):
+ Port number for the weight update group.
+ connection_timeout (`float`, *optional*, defaults to `0.0`):
+ Total timeout duration in seconds to wait for the server to be up. If the server is not up after the
+ timeout, a `ConnectionError` is raised.
+
+ Examples:
+ Run the vLLM server with the model `Qwen/Qwen2.5-7B`:
+
+ ```
+ $ trl vllm-serve --model Qwen/Qwen2.5-7B
+ ...
+ INFO: Application startup complete.
+ INFO: Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
+ ```
+
+ Use the client to generate completions and update model weights:
+
+ ```python
+ >>> from trl.generation.vllm_client import VLLMClient
+
+ >>> client = VLLMClient()
+ >>> client.generate(["Hello, AI!", "Tell me a joke"])
+ {'prompt_ids': [[9707, 11, 15235, 0],
+ [40451, 752, 264, 21646]],
+ 'completion_ids': [[2980, 498, 1492, 752, 448, 264, 13027, 8645, 30, 358, 2776, 4460, 311, 3270, 264, 2025],
+ [911, 98072, 2142, 624, 45, 51426, 2142, 374, 279, 16396, 429, 4302, 702, 36988, 7290, 476]],
+ 'logprobs': [[[-1.6612], [-0.0081], [-1.5189], [-0.0123], [-1.2045], [-0.6227], [-2.9791], [-2.8387], [-0.1267], [-0.0366], [-2.6528], [-0.3197], [-0.0001], [-1.8174], [-0.0251], [-1.473]],
+ [[-0.018], [-10.7331], [-0.1605], [-0.891], [-3.7945], [-0.0127], [-0.3073], [-1.1648], [-1.8025], [-0.409], [-0.0256], [-1.6127], [-2.2935], [-4.1785], [-0.6531], [-0.2629]]],
+ 'logprob_token_ids': [[[2980], [498], [1492], [752], [448], [264], [13027], [8645], [30], [358], [2776], [4460], [311], [3270], [264], [2025]],
+ [[911], [98072], [2142], [624], [45], [51426], [2142], [374], [279], [16396], [429], [4302], [702], [36988], [7290], [476]]]}
+
+ >>> from transformers import AutoModelForCausalLM
+
+ >>> model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-7B", device_map="cuda")
+ >>> client.init_communicator(device="cuda")
+ >>> client.update_model_params(model)
+ ```
+
+ There are several ways to initialize the client:
+
+ ```python
+ VLLMClient(base_url="http://localhost:8000")
+ VLLMClient(base_url="http://192.168.1.100:8000")
+ VLLMClient(host="localhost", server_port=8000)
+ VLLMClient(host="192.168.1.100", server_port=8000)
+ ```
+ """
+
+ def __init__(
+ self,
+ base_url: str | None = None,
+ host: str = "0.0.0.0",
+ server_port: int = 8000,
+ group_port: int = 51216,
+ connection_timeout: float = 0.0,
+ ):
+ if not is_requests_available():
+ raise ImportError("requests is not installed. Please install it with `pip install requests`.")
+ if not is_vllm_available():
+ raise ImportError("vLLM is not installed. Please install it with `pip install trl[vllm]`.")
+
+ self.session = requests.Session()
+
+ # Configure retries for HTTP requests made through this session.
+ # This is not strictly required for correctness, but it helps make training more robust to rare, transient
+ # failures (network hiccups, temporary 5xx errors, overloaded servers). Without this, such failures could cause
+ # an otherwise healthy training run to fail.
+ retry_strategy = Retry(
+ total=5, # global cap on the total number of retries across all failure types
+ connect=5, # retry connection-level failures (DNS issues, refused connections, etc)
+ read=5, # retry failures while reading the response after the connection was successfully established
+ status=3, # retry a limited number of times when we receive certain HTTP error responses from the server
+ status_forcelist=[500, 502, 503], # only retry on server-side errors that are usually temporary
+ backoff_factor=2, # exponential backoff between retries (2s, 4s, 8s, ...)
+ allowed_methods=["POST", "GET"], # allow POST as well, even though we're not sure it's safe here
+ )
+
+ adapter = HTTPAdapter(max_retries=retry_strategy)
+ self.session.mount("http://", adapter)
+ self.session.mount("https://", adapter)
+
+ if base_url is not None:
+ # Parse the base_url to extract host and port
+ parsed_url = urlparse(base_url)
+ self.host = socket.gethostbyname(parsed_url.hostname)
+ scheme = parsed_url.scheme or "http"
+ self.base_url = f"{scheme}://{parsed_url.netloc}{parsed_url.path}"
+ else:
+ self.host = host
+ self.server_port = server_port
+ self.base_url = f"http://{self.host}:{self.server_port}"
+ self.group_port = group_port
+ self.check_server(connection_timeout) # check server and fail after timeout
+
+ def check_server(self, total_timeout: float = 0.0, retry_interval: float = 2.0):
+ """
+ Check server availability with retries on failure, within a total timeout duration. If the server is not up
+ after the total timeout duration, raise a `ConnectionError`.
+
+ Args:
+ retry_interval (`float`, *optional*, defaults to `2.0`):
+ Interval in seconds between retries.
+ total_timeout (`float`, *optional*, defaults to `0.0`):
+ Total timeout duration in seconds.
+ """
+ url = f"{self.base_url}/health/"
+ start_time = time.time() # Record the start time
+
+ while True:
+ try:
+ response = requests.get(url)
+ except requests.exceptions.RequestException as exc:
+ # Check if the total timeout duration has passed
+ elapsed_time = time.time() - start_time
+ if elapsed_time >= total_timeout:
+ raise ConnectionError(
+ f"The vLLM server can't be reached at {self.base_url} after {total_timeout} seconds. Make "
+ "sure the server is running by running `trl vllm-serve`."
+ ) from exc
+ else:
+ if response.status_code == 200:
+ if "X-Forwarded-For" in response.headers:
+ self.host = response.headers["X-Forwarded-For"]
+ logger.info("Server is up!")
+ return None
+
+ # Retry logic: wait before trying again
+ logger.info(f"Server is not up yet. Retrying in {retry_interval} seconds...")
+ time.sleep(retry_interval)
+
+ def generate(
+ self,
+ prompts: list[str] | list[list[int]],
+ images: list | None = None,
+ n: int = 1,
+ repetition_penalty: float = 1.0,
+ temperature: float = 1.0,
+ top_p: float = 1.0,
+ top_k: int = 0,
+ min_p: float = 0.0,
+ max_tokens: int = 16,
+ logprobs: int | None = 0,
+ structured_outputs_regex: str | None = None,
+ generation_kwargs: dict | None = None,
+ ) -> dict[str, list[list[int]]]:
+ """
+ Generates model completions for the provided prompts.
+
+ Args:
+ prompts (`list[str]` or `list[list[int]]`):
+ List of text prompts or list of token ID lists for which the model will generate completions.
+ images (`list[list[PIL.Image] | None]`, *optional*):
+ List of image lists for VLM support. Each element is a list of PIL images for the corresponding prompt,
+ or `None` if no images for that prompt.
+ n (`int`, *optional*, defaults to `1`):
+ Number of completions to generate for each prompt.
+ repetition_penalty (`float`, *optional*, defaults to `1.0`):
+ Parameter for repetition penalty. 1.0 means no penalty.
+ temperature (`float`, *optional*, defaults to `1.0`):
+ Temperature parameter for sampling. Higher values increase diversity.
+ top_p (`float`, *optional*, defaults to `1.0`):
+ Top-p sampling parameter.`1.0` means no truncation.
+ top_k (`int`, *optional*, defaults to `0`):
+ Top-k sampling parameter. `0` means no truncation.
+ min_p (`float`, *optional*, defaults to `0.0`):
+ Minimum probability for sampling.
+ max_tokens (`int`, *optional*, defaults to `16`):
+ Maximum number of tokens to generate for each prompt.
+ logprobs (`int` or `None`, *optional*, defaults to `0`):
+ Number of top logprobs to return per token. When 0, only the sampled token's logprob is returned. When
+ N>0, returns up to N+1 logprobs sorted by descending probability, because vLLM always includes the
+ sampled token's logprob (which may fall outside the top-N).
+ structured_outputs_regex (`str`, *optional*):
+ Regular expression to guide the decoding process.
+ generation_kwargs (`dict`, *optional*):
+ Additional generation parameters to pass to the vLLM `SamplingParams`. This can include parameters like
+ `seed`, `frequency_penalty`, etc. If it contains keys that conflict with the other parameters, they
+ will override them.
+
+ Returns:
+ `dict` with keys:
+ - `prompt_ids` (`list[list[int]]`):
+ List of lists of token IDs representing the tokenized input prompts.
+ - `completion_ids` (`list[list[int]]`):
+ List of lists of token IDs representing the model-generated completions for each prompt.
+ - `logprobs` (`list[list[list[float]]]`):
+ Per-token logprobs of shape (num_sequences, seq_len, num_logprobs), sorted by descending
+ probability.
+ - `logprob_token_ids` (`list[list[list[int]]]`):
+ Token IDs corresponding to each logprob, same shape as `logprobs`.
+ """
+ url = f"{self.base_url}/generate/"
+
+ # Convert PIL images to base64 strings. Each element is a list of images for the corresponding prompt,
+ # or None if no images for that prompt.
+ if images:
+ images = [
+ [pil_to_base64(img) for img in img_list] if img_list is not None else None for img_list in images
+ ]
+
+ response = self.session.post(
+ url,
+ json={
+ "prompts": prompts,
+ "images": images,
+ "n": n,
+ "repetition_penalty": repetition_penalty,
+ "temperature": temperature,
+ "top_p": top_p,
+ "top_k": top_k,
+ "min_p": min_p,
+ "max_tokens": max_tokens,
+ "logprobs": logprobs,
+ "structured_outputs_regex": structured_outputs_regex,
+ "generation_kwargs": generation_kwargs or {},
+ },
+ )
+ if response.status_code == 200:
+ json_response = response.json()
+ return {
+ "prompt_ids": json_response["prompt_ids"],
+ "completion_ids": json_response["completion_ids"],
+ "logprobs": json_response["logprobs"],
+ "logprob_token_ids": json_response["logprob_token_ids"],
+ }
+ else:
+ raise Exception(f"Request failed: {response.status_code}, {response.text}")
+
+ def chat(
+ self,
+ messages: list[list[dict]],
+ n: int = 1,
+ repetition_penalty: float = 1.0,
+ temperature: float = 1.0,
+ top_p: float = 1.0,
+ top_k: int = 0,
+ min_p: float = 0.0,
+ max_tokens: int = 16,
+ logprobs: int | None = 0,
+ structured_outputs_regex: str | None = None,
+ generation_kwargs: dict | None = None,
+ chat_template_kwargs: dict | None = None,
+ tools: list | None = None,
+ chat_template: str | None = None,
+ ) -> dict[str, list[list[int]]]:
+ """
+ Generates model completions for the provided chat messages.
+
+ Args:
+ messages (`list[list[dict]]`):
+ List of message lists for which the model will generate completions. Each message is a dictionary with
+ keys like "role" and "content".
+ n (`int`, *optional*, defaults to `1`):
+ Number of completions to generate for each message list.
+ repetition_penalty (`float`, *optional*, defaults to `1.0`):
+ Parameter for repetition penalty. 1.0 means no penalty.
+ temperature (`float`, *optional*, defaults to `1.0`):
+ Temperature parameter for sampling. Higher values increase diversity.
+ top_p (`float`, *optional*, defaults to `1.0`):
+ Top-p sampling parameter.`1.0` means no truncation.
+ top_k (`int`, *optional*, defaults to `0`):
+ Top-k sampling parameter. `0` means no truncation.
+ min_p (`float`, *optional*, defaults to `0.0`):
+ Minimum probability for sampling.
+ max_tokens (`int`, *optional*, defaults to `16`):
+ Maximum number of tokens to generate for each message list.
+ logprobs (`int` or `None`, *optional*, defaults to `0`):
+ Number of top logprobs to return per token. When 0, only the sampled token's logprob is returned. When
+ N>0, returns up to N+1 logprobs sorted by descending probability, because vLLM always includes the
+ sampled token's logprob (which may fall outside the top-N).
+ structured_outputs_regex (`str`, *optional*):
+ Regular expression to guide the decoding process.
+ generation_kwargs (`dict`, *optional*):
+ Additional generation parameters to pass to the vLLM `SamplingParams`. This can include parameters like
+ `seed`, `frequency_penalty`, etc. If it contains keys that conflict with the other parameters, they
+ will override them.
+ chat_template_kwargs (`dict`, *optional*):
+ Additional keyword arguments to customize the chat template used by the model.
+ tools (`list[dict | Callable]`, *optional*):
+ List of tool functions available for tool calling during chat generation.
+ chat_template (`str`, *optional*):
+ Template to use for structuring the chat. If not provided, the model's default chat template will be
+ used.
+
+ Returns:
+ `dict` with keys:
+ - `prompt_ids` (`list[list[int]]`):
+ List of lists of token IDs representing the tokenized input messages.
+ - `completion_ids` (`list[list[int]]`):
+ List of lists of token IDs representing the model-generated completions for each message list.
+ - `logprobs` (`list[list[list[float]]]`):
+ Per-token logprobs of shape (num_sequences, seq_len, num_logprobs), sorted by descending
+ probability.
+ - `logprob_token_ids` (`list[list[list[int]]]`):
+ Token IDs corresponding to each logprob, same shape as `logprobs`.
+ """
+ if chat_template is not None:
+ raise NotImplementedError("Custom chat templates are not yet implemented in VLLMClient.chat().")
+
+ url = f"{self.base_url}/chat/"
+
+ # Convert PIL images to base64 strings
+ messages = copy.deepcopy(messages) # avoid modifying the original messages
+ for message_list in messages:
+ for message in message_list:
+ if isinstance(message["content"], list):
+ for part in message["content"]:
+ if part["type"] == "image_pil":
+ part["image_pil"] = pil_to_base64(part["image_pil"])
+
+ if isinstance(tools, list) and len(tools) > 0:
+ tools = [get_json_schema(tool) if callable(tool) else tool for tool in tools]
+
+ response = self.session.post(
+ url,
+ json={
+ "messages": messages,
+ "n": n,
+ "repetition_penalty": repetition_penalty,
+ "temperature": temperature,
+ "top_p": top_p,
+ "top_k": top_k,
+ "min_p": min_p,
+ "max_tokens": max_tokens,
+ "logprobs": logprobs,
+ "structured_outputs_regex": structured_outputs_regex,
+ "generation_kwargs": generation_kwargs or {},
+ "chat_template_kwargs": chat_template_kwargs or {},
+ "tools": tools,
+ },
+ )
+ if response.status_code == 200:
+ json_response = response.json()
+ return {
+ "prompt_ids": json_response["prompt_ids"],
+ "completion_ids": json_response["completion_ids"],
+ "logprobs": json_response["logprobs"],
+ "logprob_token_ids": json_response["logprob_token_ids"],
+ }
+ else:
+ raise Exception(f"Request failed: {response.status_code}, {response.text}")
+
+ def init_communicator(self, device: torch.device | str | int = 0):
+ """
+ Initializes the weight update group in a distributed setup for model synchronization.
+
+ Args:
+ device (`torch.device`, `str`, or `int`, *optional*, defaults to `0`):
+ Device of trainer main process. It's the device that will be used for the weights synchronization. Can
+ be a `torch.device` object, a string like `'cuda:0'`, or an integer device index.
+ """
+ # Get the world size from the server
+ url = f"{self.base_url}/get_world_size/"
+ response = requests.get(url)
+ if response.status_code == 200:
+ vllm_world_size = response.json()["world_size"]
+ else:
+ raise Exception(f"Request failed: {response.status_code}, {response.text}")
+
+ world_size = vllm_world_size + 1 # add the client to the world
+ self.rank = vllm_world_size # the client's rank is the last process
+
+ # Initialize weight update group
+ url = f"{self.base_url}/init_communicator/"
+ # Will simplify it after torch xpu 2.9 support get uuid.
+ if is_torch_xpu_available():
+ if hasattr(torch.xpu.get_device_properties(device), "uuid"):
+ client_device_uuid = str(torch.xpu.get_device_properties(device).uuid)
+ else:
+ client_device_uuid = "42"
+ else:
+ client_device_uuid = str(torch.cuda.get_device_properties(device).uuid)
+
+ # Set the weight update group's host to "0.0.0.0" so that
+ # clients from different IPs can send updated weights
+ response = self.session.post(
+ url,
+ json={
+ "host": "0.0.0.0",
+ "port": self.group_port,
+ "world_size": world_size,
+ "client_device_uuid": client_device_uuid,
+ },
+ )
+ if response.status_code != 200:
+ raise Exception(f"Request failed: {response.status_code}, {response.text}")
+
+ # Brief delay to allow server initialization. While not strictly required (client socket will retry on
+ # connection failure), this prevents log warnings like:
+ # [W416 23:24:57.460001114 socket.cpp:204] [c10d] The hostname of the client socket cannot be retrieved. err=-3
+ time.sleep(0.1)
+
+ # Set up the communication group for weight broadcasting
+ if is_torch_xpu_available():
+ store = torch.distributed.TCPStore(
+ host_name=self.host, port=self.group_port, world_size=world_size, is_master=(self.rank == 0)
+ )
+ prefixed_store = c10d.PrefixStore("client2server", store)
+ xccl_options = c10d.ProcessGroupXCCL.Options()
+ pg = c10d.ProcessGroupXCCL(
+ store=prefixed_store,
+ rank=self.rank,
+ size=world_size,
+ options=xccl_options,
+ )
+ self.communicator = pg
+ else:
+ pg = StatelessProcessGroup.create(
+ host=self.host, port=self.group_port, rank=self.rank, world_size=world_size
+ )
+ self.communicator = PyNcclCommunicator(pg, device=device)
+
+ # When the client object is deleted, close the weight update group
+ atexit.register(self.close_communicator)
+
+ def update_named_param(self, name: str, weights: torch.Tensor):
+ """
+ Updates a specific named parameter in the model and broadcasts it to other processes.
+
+ Args:
+ name (`str`):
+ Name of the layer whose weights are being updated.
+ weights (`torch.Tensor`):
+ Tensor containing the updated weights.
+ """
+ dtype, shape = str(weights.dtype), tuple(weights.shape)
+ url = f"{self.base_url}/update_named_param/"
+ response = self.session.post(url, json={"name": name, "dtype": dtype, "shape": shape})
+ if response.status_code != 200:
+ raise Exception(f"Request failed: {response.status_code}, {response.text}")
+
+ if is_torch_xpu_available():
+ # Use XCCL to broadcast the updated weights from the client (src) to all workers.
+ self.communicator.broadcast(weights, root=self.rank)
+ self.communicator.barrier()
+ else:
+ # Use NCCL to broadcast the updated weights from the client (src) to all workers.
+ self.communicator.broadcast(weights, src=self.rank)
+ self.communicator.group.barrier()
+
+ def update_model_params(self, model: nn.Module):
+ """
+ Updates all parameters of the given model by calling `update_named_param` for each parameter in the model.
+
+ Args:
+ model (`nn.Module`):
+ Model whose parameters (weights/biases) are to be updated.
+ """
+ for name, param in model.named_parameters():
+ # Update each parameter individually
+ self.update_named_param(name, param.data)
+
+ def get_sequence_logprobs(
+ self,
+ sequences: list[list[int]],
+ prompt_lengths: list[int],
+ top_logprobs: int = 100,
+ temperature: float = 1.0,
+ use_binary: bool = True,
+ chunk_size: int = 0,
+ max_concurrent_requests: int = 4,
+ ) -> dict[str, list]:
+ """
+ Computes teacher logprobs for existing token sequences without generating new tokens.
+
+ Sends full sequences (prompt + completion) to the vLLM server and retrieves per-token top-k logprobs for the
+ completion region only. This is used for knowledge distillation where the teacher model evaluates existing
+ sequences rather than generating new ones.
+
+ When `chunk_size > 0`, splits the batch into chunks and dispatches them concurrently via a thread pool, keeping
+ the server's data-parallel workers busy.
+
+ When `use_binary=True`, uses base64-encoded numpy arrays for fast serialization instead of nested JSON lists.
+
+ Args:
+ sequences (`list[list[int]]`):
+ List of full token ID sequences (prompt + completion).
+ prompt_lengths (`list[int]`):
+ Number of prompt tokens in each sequence. Logprobs are returned starting from this position.
+ top_logprobs (`int`, *optional*, defaults to `100`):
+ Number of top logprobs to return per token position.
+ temperature (`float`, *optional*, defaults to `1.0`):
+ Temperature used when scoring the teacher distribution.
+ use_binary (`bool`, *optional*, defaults to `True`):
+ Use binary (base64 numpy) response format for faster serialization.
+ chunk_size (`int`, *optional*, defaults to `0`):
+ If > 0, split batch into chunks of this size and dispatch concurrently. If 0, send the entire batch in
+ a single request.
+ max_concurrent_requests (`int`, *optional*, defaults to `4`):
+ Maximum number of concurrent requests when using chunked dispatch.
+
+ Returns:
+ `dict` with keys:
+ - `logprobs` (`list[list[list[float]]]`):
+ Per-token logprobs of shape (batch, completion_len, top_logprobs), sorted by descending
+ probability.
+ - `logprob_token_ids` (`list[list[list[int]]]`):
+ Token IDs corresponding to each logprob, same shape as `logprobs`.
+ """
+ from concurrent.futures import ThreadPoolExecutor, as_completed
+
+ if temperature <= 0:
+ raise ValueError(f"temperature must be positive, got {temperature}")
+
+ url = f"{self.base_url}/get_sequence_logprobs/"
+ response_format = "binary" if use_binary else "json"
+
+ if chunk_size > 0 and len(sequences) > chunk_size:
+ # Chunked concurrent dispatch
+ n = len(sequences)
+ chunks = []
+ for i in range(0, n, chunk_size):
+ chunks.append((sequences[i : i + chunk_size], prompt_lengths[i : i + chunk_size]))
+
+ responses = [None] * len(chunks)
+
+ def _send_chunk(idx, seqs, plens):
+ resp = self.session.post(
+ url,
+ json={
+ "sequences": seqs,
+ "prompt_lengths": plens,
+ "top_logprobs": top_logprobs,
+ "temperature": temperature,
+ "response_format": response_format,
+ },
+ )
+ if resp.status_code != 200:
+ raise Exception(f"Request failed: {resp.status_code}, {resp.text}")
+ return idx, resp.json()
+
+ with ThreadPoolExecutor(max_workers=min(max_concurrent_requests, len(chunks))) as executor:
+ futures = {
+ executor.submit(_send_chunk, idx, seqs, plens): idx for idx, (seqs, plens) in enumerate(chunks)
+ }
+ for future in as_completed(futures):
+ idx, result = future.result()
+ responses[idx] = result
+
+ # Merge results
+ if use_binary:
+ return self._merge_binary_responses(responses, top_logprobs)
+ else:
+ all_logprobs = []
+ all_token_ids = []
+ for resp in responses:
+ all_logprobs.extend(resp["logprobs"])
+ all_token_ids.extend(resp["logprob_token_ids"])
+ return {"logprobs": all_logprobs, "logprob_token_ids": all_token_ids}
+ else:
+ # Single request
+ response = self.session.post(
+ url,
+ json={
+ "sequences": sequences,
+ "prompt_lengths": prompt_lengths,
+ "top_logprobs": top_logprobs,
+ "temperature": temperature,
+ "response_format": response_format,
+ },
+ )
+ if response.status_code != 200:
+ raise Exception(f"Request failed: {response.status_code}, {response.text}")
+
+ json_response = response.json()
+ if use_binary:
+ return self._decode_binary_logprobs(json_response)
+ else:
+ return {
+ "logprobs": json_response["logprobs"],
+ "logprob_token_ids": json_response["logprob_token_ids"],
+ }
+
+ @staticmethod
+ def _decode_binary_logprobs(response: dict) -> dict[str, list]:
+ """Decode base64-encoded numpy arrays back to nested lists.
+
+ Returns a dict with:
+ ``logprobs`` / ``logprob_token_ids`` — teacher's sorted top-k logprobs and
+ token IDs (shape per sequence: ``(comp_len, top_k)``). Used for the forward KL term.
+ ``actual_logprobs`` / ``actual_token_ids`` — teacher logprob for the actual
+ token at each position (shape per sequence: ``(comp_len, 1)``). Used for the reverse KL term.
+ """
+ import numpy as np
+
+ shape = response["shape"] # [batch, max_comp_len, top_k]
+ comp_lengths = response["completion_lengths"]
+
+ logprobs_arr = np.frombuffer(base64.b64decode(response["logprobs_b64"]), dtype=np.float32).reshape(shape)
+ token_ids_arr = np.frombuffer(base64.b64decode(response["token_ids_b64"]), dtype=np.int32).reshape(shape)
+
+ # Convert back to nested lists, trimming padding
+ all_logprobs = []
+ all_token_ids = []
+ for i, comp_len in enumerate(comp_lengths):
+ all_logprobs.append(logprobs_arr[i, :comp_len, :].tolist())
+ all_token_ids.append(token_ids_arr[i, :comp_len, :].tolist())
+
+ result = {"logprobs": all_logprobs, "logprob_token_ids": all_token_ids}
+
+ # Decode actual-token logprobs (for reverse KL)
+ if "actual_logprobs_b64" in response:
+ actual_shape = [shape[0], shape[1], 1]
+ actual_lp = np.frombuffer(base64.b64decode(response["actual_logprobs_b64"]), dtype=np.float32).reshape(
+ actual_shape
+ )
+ actual_ids = np.frombuffer(base64.b64decode(response["actual_token_ids_b64"]), dtype=np.int32).reshape(
+ actual_shape
+ )
+ all_actual_lps = []
+ all_actual_ids = []
+ for i, comp_len in enumerate(comp_lengths):
+ all_actual_lps.append(actual_lp[i, :comp_len, :].tolist())
+ all_actual_ids.append(actual_ids[i, :comp_len, :].tolist())
+ result["actual_logprobs"] = all_actual_lps
+ result["actual_token_ids"] = all_actual_ids
+
+ return result
+
+ @staticmethod
+ def _merge_binary_responses(responses: list[dict], top_logprobs: int) -> dict[str, list]:
+ """Merge binary responses from multiple chunks into a single result."""
+
+ all_logprobs = []
+ all_token_ids = []
+ all_actual_lps = []
+ all_actual_ids = []
+ for resp in responses:
+ decoded = VLLMClient._decode_binary_logprobs(resp)
+ all_logprobs.extend(decoded["logprobs"])
+ all_token_ids.extend(decoded["logprob_token_ids"])
+ if "actual_logprobs" in decoded:
+ all_actual_lps.extend(decoded["actual_logprobs"])
+ all_actual_ids.extend(decoded["actual_token_ids"])
+
+ result = {"logprobs": all_logprobs, "logprob_token_ids": all_token_ids}
+ if all_actual_lps:
+ if len(all_actual_lps) != len(all_logprobs):
+ raise ValueError(
+ f"Inconsistent chunks: {len(all_actual_lps)} actual_logprobs entries "
+ f"but {len(all_logprobs)} logprobs entries."
+ )
+ result["actual_logprobs"] = all_actual_lps
+ result["actual_token_ids"] = all_actual_ids
+ return result
+
+ def reset_prefix_cache(self):
+ """
+ Resets the prefix cache for the model.
+ """
+ url = f"{self.base_url}/reset_prefix_cache/"
+ response = self.session.post(url)
+ if response.status_code != 200:
+ raise Exception(f"Request failed: {response.status_code}, {response.text}")
+
+ def close_communicator(self):
+ """
+ Closes the weight update group and cleans up the communication group.
+ """
+ url = f"{self.base_url}/close_communicator/"
+
+ try:
+ response = self.session.post(url)
+ except ConnectionError:
+ # The server might be already down, so we don't need to close the communicator
+ pass
+ else:
+ if response.status_code != 200:
+ raise Exception(f"Request failed: {response.status_code}, {response.text}")
+
+ if self.communicator is not None:
+ self.communicator = None
+
+
+# Example usage
+if __name__ == "__main__":
+ from vllm import SamplingParams
+
+ device = "xpu" if is_torch_xpu_available() else "cuda"
+ client = VLLMClient()
+ client.init_communicator(device=device)
+
+ # Generate completions
+ responses = client.generate(["Hello, AI!", "Tell me a joke"], n=4, max_tokens=32, sampling_params=SamplingParams())
+ print("Responses:", responses) # noqa
+
+ # Update model weights
+ from transformers import AutoModelForCausalLM
+
+ model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-7B").to(device)
+ client.update_model_params(model)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/generation/vllm_generation.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/generation/vllm_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c9cea9b586449e4a39471b3f766bc9bc2069b3f
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/generation/vllm_generation.py
@@ -0,0 +1,689 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""vLLM-based generation backend for TRL trainers."""
+
+import logging
+import math
+import os
+from contextlib import nullcontext
+from typing import TYPE_CHECKING
+
+import torch
+from accelerate.utils import broadcast_object_list, gather_object, is_peft_model
+from torch import nn
+from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+from transformers import PreTrainedModel, PreTrainedTokenizerBase, ProcessorMixin, is_bitsandbytes_available
+from transformers.utils import (
+ is_torch_mlu_available,
+ is_torch_mps_available,
+ is_torch_npu_available,
+ is_torch_xpu_available,
+)
+
+from ..distributed import DistributedBackend
+from ..extras.profiling import ProfilingContext
+from ..import_utils import is_vllm_available
+from ..trainer.utils import ensure_master_addr_port
+from .vllm_client import VLLMClient
+
+
+if is_vllm_available():
+ from vllm import LLM, RequestOutput, SamplingParams
+ from vllm.sampling_params import StructuredOutputsParams
+
+
+logger = logging.getLogger(__name__)
+
+
+def empty_cache() -> None:
+ """Empties the cache of the available torch device.
+
+ This function checks for the availability of different torch devices (CUDA, MLU, MPS, NPU, XPU) and empties the
+ cache of the first available device it finds.
+
+ If none of the specific devices are available, it defaults to emptying the CUDA cache.
+ """
+ if is_torch_mlu_available():
+ torch.mlu.empty_cache()
+ elif is_torch_mps_available():
+ torch.mps.empty_cache()
+ elif is_torch_npu_available():
+ torch.npu.empty_cache()
+ elif is_torch_xpu_available():
+ torch.xpu.empty_cache()
+ else:
+ torch.cuda.empty_cache()
+
+
+def extract_logprobs(all_outputs: list["RequestOutput"]):
+ """
+ Extract logprobs and token IDs from vLLM generation outputs.
+
+ Returns logprobs and token IDs sorted by rank (most probable first). Each returned list has shape (num_sequences,
+ seq_len, num_logprobs), where num_logprobs is determined by the `logprobs` parameter passed to vLLM (1 when
+ `logprobs=0`, up to N+1 when `logprobs=N`). NaN logprob values are replaced with `None`.
+
+ Args:
+ all_outputs (list of `RequestOutput`):
+ List of vLLM `RequestOutput` objects from generation.
+
+ Returns:
+ Tuple of (logprobs, logprob_token_ids), each of shape (num_sequences, seq_len, num_logprobs).
+ """
+ all_logprobs = []
+ all_token_ids = []
+ for outputs in all_outputs:
+ for output in outputs.outputs:
+ if output.logprobs is None:
+ return None, None
+ seq_logprobs = []
+ seq_token_ids = []
+ for lp in output.logprobs:
+ sorted_items = sorted(lp.items(), key=lambda x: x[1].rank)
+ seq_token_ids.append([token_id for token_id, _ in sorted_items])
+ seq_logprobs.append([None if math.isnan(item.logprob) else item.logprob for _, item in sorted_items])
+ all_logprobs.append(seq_logprobs)
+ all_token_ids.append(seq_token_ids)
+ return all_logprobs, all_token_ids
+
+
+if TYPE_CHECKING:
+ from accelerate import Accelerator
+ from peft import PeftModel
+
+
+if is_bitsandbytes_available():
+ import bitsandbytes as bnb
+
+
+class VLLMGeneration:
+ """Handles vLLM-based generation for trainers.
+
+ Extracts all vLLM-specific logic (initialization, generation, weight sync) from trainers into a separate, testable
+ class.
+
+ Args:
+ model ([`~transformers.PreTrainedModel`] or [`~peft.PeftModel`]):
+ Model to use for generation.
+ accelerator ([`~accelerate.Accelerator`]):
+ Accelerator for distributed training.
+ processing_class ([`~transformers.PreTrainedTokenizerBase`] or [`~transformers.ProcessorMixin`]):
+ Tokenizer or processor for the model.
+
+ > Parameters for vLLM:
+
+ mode (`str`, *optional*, defaults to `"colocate"`):
+ vLLM mode. Must be one of `"colocate"` or `"server"`.
+
+ - `"colocate"`: vLLM will run in the same process and share the training GPUs. This avoids the need for a
+ separate server but may cause resource contention with training.
+ - `"server"`: The trainer will send generation requests to a separate vLLM server. Make sure a TRL vLLM
+ server is running (start with `trl vllm-serve`).
+
+ structured_outputs_regex (`str`, *optional*):
+ Regex for vLLM structured outputs. If `None` (default), structured outputs is disabled.
+
+ > Parameters for "server" vLLM mode:
+
+ server_base_url (`str`, *optional*):
+ Base URL for the vLLM server (e.g., `"http://localhost:8000"`). If provided, `server_host` and
+ `server_port` are ignored.
+ server_host (`str`, *optional*, defaults to `"0.0.0.0"`):
+ Host of the vLLM server to connect to. Ignored if `server_base_url` is provided.
+ server_port (`int`, *optional*, defaults to `8000`):
+ Port of the vLLM server to connect to. Ignored if `server_base_url` is provided.
+ server_timeout (`float`, *optional*, defaults to `240.0`):
+ Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up after the
+ timeout, a `ConnectionError` is raised.
+ group_port (`int`, *optional*, defaults to `51216`):
+ Port number for the weight update group. This is used to communicate with the vLLM server. Unless the port
+ is occupied, there is no need to change it.
+
+ > Parameters for "colocate" vLLM mode:
+
+ tensor_parallel_size (`int`, *optional*, defaults to `1`):
+ The number of GPUs to use for distributed execution with tensor parallelism. This setting only applies when
+ `mode` is set to `"colocate"`. If you are using `mode="server"`, this parameter must be passed separately
+ when launching the vLLM server via the `--vllm_tensor_parallel_size` flag.
+ gpu_memory_utilization (`float`, *optional*, defaults to `0.9`):
+ Ratio (between 0 and 1) of GPU memory to reserve for the model weights, activations, and KV cache. Higher
+ values will increase the KV cache size and thus improve the model's throughput. However, if the value is
+ too high, it may cause out-of- memory (OOM) errors. This setting only applies when `mode` is set to
+ `"colocate"`. If you are using `mode="server"`, this parameter must be passed separately when launching the
+ vLLM server via the `--vllm_gpu_memory_utilization` flag.
+ max_model_length (`int`, *optional*):
+ Model context length (prompt and completion). Set it to at least the maximum prompt length in the dataset
+ plus `max_completion_length`; if omitted, it is inferred from the model config.
+ max_num_seqs (`int`, *optional*):
+ Maximum number of sequences to process in parallel, effectively capping the batch size.
+ enable_sleep_mode (`bool`, *optional*, defaults to `False`):
+ Whether to enable sleep mode for the engine to offload weights/cache during the optimizer step. Keeps GPU
+ memory usage low, but waking the engine adds host–device transfer latency.
+ model_impl (`str`, *optional*, defaults to `"auto"`):
+ Model implementation to use for vLLM.
+ - "auto" will try to use the vLLM implementation, if it exists, and fall back to the Transformers
+ implementation if no vLLM implementation is available.
+ - "vllm" will use the vLLM model implementation.
+ - "transformers" will use the Transformers model implementation.
+ - "terratorch" will use the TerraTorch model implementation.
+
+ > Parameters for generation:
+
+ repetition_penalty (`float`, *optional*, defaults to `1.0`):
+ Parameter for repetition penalty. It penalizes new tokens based on whether they appear in the prompt and
+ the generated text so far. Values > 1 encourage the model to use new tokens, while values < 1 encourage the
+ model to repeat tokens. Default `1.0` means no penalty.
+ temperature (`float`, *optional*, defaults to `1.0`):
+ Sampling temperature. It controls the randomness of the sampling. Lower values make the model more
+ deterministic, while higher values make the model more random and increase diversity.
+ top_p (`float`, *optional*, defaults to `1.0`):
+ Top-p sampling parameter. It controls the cumulative probability of the top tokens to consider. Defaults to
+ `1.0` to consider all tokens.
+ top_k (`int`, *optional*, defaults to `0`):
+ Top-k sampling parameter. It controls the number of top tokens to consider. Defaults to `0` to consider all
+ tokens.
+ min_p (`float`, *optional*, defaults to `0.0`):
+ Min-p sampling parameter. It represents the minimum probability for a token to be considered, relative to
+ the probability of the most likely token. Default `0.0` means min-p is disabled.
+ max_completion_length (`int`, *optional*, defaults to `16`):
+ Maximum number of tokens to generate for each prompt.
+ logprobs (`int` or `None`, *optional*, defaults to `0`):
+ Number of top logprobs to return per token. When 0 (default), only the sampled token's logprob is returned
+ (inner dimension = 1). When N>0, returns up to N+1 logprobs sorted by descending probability, because vLLM
+ always includes the sampled token's logprob alongside the top-N (the sampled token may or may not already
+ be in the top-N).
+ generation_kwargs (`dict`, *optional*):
+ Additional generation parameters to pass to the vLLM `SamplingParams`. This can include parameters like
+ `seed`, `frequency_penalty`, etc. If it contains keys that conflict with the other parameters, they will
+ override them.
+
+ > Parameters for chat/tools:
+
+ chat_template (`str`, *optional*):
+ Template to use for structuring the chat. If not provided, the model's default chat template will be used.
+ chat_template_kwargs (`dict`, *optional*):
+ Additional keyword arguments to customize the chat template used by the model.
+ tools (`list`, *optional*):
+ Tools available for tool calling during chat generation.
+ """
+
+ def __init__(
+ self,
+ model: "PreTrainedModel | PeftModel",
+ accelerator: "Accelerator",
+ processing_class: PreTrainedTokenizerBase | ProcessorMixin,
+ # vLLM configuration
+ mode: str = "colocate",
+ structured_outputs_regex: str | None = None,
+ # Server mode configuration
+ server_base_url: str | None = None,
+ server_host: str = "0.0.0.0",
+ server_port: int = 8000,
+ server_timeout: float = 240.0,
+ group_port: int = 51216,
+ # Colocate mode configuration
+ tensor_parallel_size: int = 1,
+ gpu_memory_utilization: float = 0.9,
+ max_model_length: int | None = None,
+ max_num_seqs: int | None = None,
+ enable_sleep_mode: bool = False,
+ model_impl: str = "auto",
+ # Generation configuration
+ repetition_penalty: float = 1.0,
+ temperature: float = 1.0,
+ top_p: float = 1.0,
+ top_k: int = 0,
+ min_p: float = 0.0,
+ max_completion_length: int = 16,
+ logprobs: int | None = 0,
+ generation_kwargs: dict | None = None,
+ ):
+ self.model = model
+ self.accelerator = accelerator
+ self._dist = DistributedBackend(accelerator)
+ self.processing_class = processing_class
+
+ # vLLM configuration
+ self.mode = mode
+ self.structured_outputs_regex = structured_outputs_regex
+
+ # Server mode configuration
+ self.server_base_url = server_base_url
+ self.server_host = server_host
+ self.server_port = server_port
+ self.group_port = group_port
+ self.server_timeout = server_timeout
+
+ # Colocate mode configuration
+ self.tensor_parallel_size = tensor_parallel_size
+ self.gpu_memory_utilization = gpu_memory_utilization
+ self.max_model_length = max_model_length
+ self.max_num_seqs = max_num_seqs
+ self.enable_sleep_mode = enable_sleep_mode
+ self.model_impl = model_impl
+
+ # Generation configuration
+ self.repetition_penalty = repetition_penalty
+ self.temperature = temperature
+ self.top_p = top_p
+ self.top_k = top_k
+ self.min_p = min_p
+ self.max_completion_length = max_completion_length
+ self.logprobs = logprobs
+ self.generation_kwargs = generation_kwargs or {}
+
+ self._init_vllm()
+
+ def _init_vllm(self):
+ """Initialize vLLM in server or colocate mode."""
+ model = self.model
+ accelerator = self.accelerator
+
+ if not is_vllm_available():
+ raise ImportError(
+ "vLLM is not available and `use_vllm` is set to True. Please install vLLM with "
+ "`pip install trl[vllm]` to use it."
+ )
+
+ if self.mode == "server":
+ if accelerator.is_main_process:
+ if self.server_base_url is not None:
+ base_url = self.server_base_url
+ else:
+ base_url = f"http://{self.server_host}:{self.server_port}"
+ self.vllm_client = VLLMClient(
+ base_url=base_url, group_port=self.group_port, connection_timeout=self.server_timeout
+ )
+ self.vllm_client.init_communicator(device=torch.cuda.current_device())
+
+ elif self.mode == "colocate":
+ # Make sure tensor_parallel_size group size evenly divides the world size - each group should have
+ # the same number of ranks
+ if not accelerator.num_processes % self.tensor_parallel_size == 0:
+ raise ValueError(
+ f"tensor_parallel_size ({self.tensor_parallel_size}) must divide world size "
+ f"({accelerator.num_processes}) evenly."
+ )
+
+ if self.tensor_parallel_size > 1:
+ # Create subgroups of ranks for TP, each group with `tensor_parallel_size` ranks.
+ # For example, if world_size=8 and tensor_parallel_size=2 → groups: [0,1], [2,3], [4,5], [6,7]
+ self.tp_group, _ = torch.distributed.new_subgroups_by_enumeration(
+ [
+ list(range(i * self.tensor_parallel_size, (i + 1) * self.tensor_parallel_size))
+ for i in range(accelerator.num_processes // self.tensor_parallel_size)
+ ]
+ )
+
+ # vLLM requires the environment variables to be set for distributed training.
+ os.environ["RANK"] = str(accelerator.process_index)
+ os.environ["LOCAL_RANK"] = str(accelerator.local_process_index)
+ os.environ["WORLD_SIZE"] = str(accelerator.num_processes)
+ # Ensure distributed rendezvous variables are set without colliding across concurrent runs
+ ensure_master_addr_port()
+
+ quantization = None
+ if is_bitsandbytes_available():
+ for _, module in model.named_modules():
+ if isinstance(module, bnb.nn.Linear4bit):
+ quantization = "bitsandbytes"
+ break
+ elif isinstance(module, bnb.nn.Linear8bitLt):
+ raise ValueError("vLLM does not support in-flight 8-bit quantization.")
+
+ # Build LLM initialization kwargs
+ self.llm = LLM(
+ model=model.name_or_path,
+ tensor_parallel_size=self.tensor_parallel_size,
+ gpu_memory_utilization=self.gpu_memory_utilization,
+ max_model_len=self.max_model_length,
+ max_num_seqs=self.max_num_seqs,
+ enable_sleep_mode=self.enable_sleep_mode,
+ model_impl=self.model_impl,
+ distributed_executor_backend="external_launcher",
+ # Feed identical seed for tp groups to ensure sampling results are the same across workers
+ seed=accelerator.process_index // self.tensor_parallel_size,
+ # Latest vLLM v1 memory profiler is misled by the high default value (i.e., 32768) - thinking there's not enough memory
+ max_num_batched_tokens=4096,
+ # Important so temperature scaling/logit tweaking affects the TIS log probs
+ logprobs_mode="processed_logprobs",
+ quantization=quantization,
+ )
+ if self.enable_sleep_mode:
+ self.llm.sleep(level=2)
+ else:
+ raise ValueError(f"vllm_mode must be either 'server' or 'colocate', got '{self.mode}'.")
+
+ # When using vLLM, the main process is responsible for loading the model weights. This can cause process
+ # desynchronization and seems to lead to DeepSpeed hanging during initialization. To prevent this, we
+ # synchronize all processes after vLLM has been fully initialized.
+ accelerator.wait_for_everyone()
+
+ def _fix_param_name_to_vllm(self, name: str, extra_prefixes: list[str] | None = None) -> str:
+ """Fix parameter name for vLLM compatibility."""
+ extra_prefixes = extra_prefixes or []
+ prefixes = ["_checkpoint_wrapped_module."] + extra_prefixes
+ for prefix in prefixes:
+ name = name.replace(prefix, "")
+ return name
+
+ def _push_param_to_vllm(self, name: str, param) -> None:
+ """Push a single parameter tensor to the vLLM engine (server or colocate mode)."""
+ if self.mode == "server" and self.accelerator.is_main_process:
+ self.vllm_client.update_named_param(name, param)
+ elif self.mode == "colocate":
+ self.llm.llm_engine.model_executor.driver_worker.model_runner.model.load_weights([(name, param)])
+
+ def _sync_fsdp1_params_to_vllm(self, module: nn.Module, prefix: str = "", visited: set[str] | None = None):
+ """Memory-efficient post-order traversal of FSDP modules to extract full parameters and sync with vLLM."""
+ # For FSDP1, we need to recurse into children and also use summon_full_params
+ if visited is None:
+ visited = set()
+ for child_name, child_module in module.named_children():
+ child_prefix = f"{prefix}.{child_name}" if prefix else child_name
+ self._sync_fsdp1_params_to_vllm(
+ child_module, prefix=child_prefix, visited=visited
+ ) # recurse into the child
+
+ if isinstance(module, FSDP):
+ with FSDP.summon_full_params(module, recurse=False, writeback=False):
+ for param_name, param in module.named_parameters():
+ full_name = f"{prefix}.{param_name}" if prefix else param_name
+ full_name = self._fix_param_name_to_vllm(full_name, extra_prefixes=["_fsdp_wrapped_module."])
+
+ if full_name in visited:
+ continue # skip FSDP subtrees already traversed
+ visited.add(full_name)
+
+ self._push_param_to_vllm(full_name, param.data)
+
+ def _sync_fsdp2_params_to_vllm(self, module: nn.Module):
+ """FSDP2-specific parameter synchronization."""
+ # For FSDP2, module.state_dict() already covers all parameters, so no need for recursion
+ for name, param in module.state_dict().items():
+ # When using PEFT, we need to recover the original parameter name
+ name = name.removeprefix("base_model.model.").replace(".base_layer", "")
+ # Skip PEFT layers: they don't exist in vLLM, and they are merged already.
+ if is_peft_model(module) and module.prefix in name:
+ continue
+ # When module to save, remove its prefix and discard the original module
+ if "original_module" in name:
+ continue
+ name = self._fix_param_name_to_vllm(name, extra_prefixes=["modules_to_save.default."])
+
+ if param.is_cpu:
+ param = param.to(torch.device("cuda"))
+ param = param.full_tensor()
+
+ self._push_param_to_vllm(name, param)
+
+ def _sync_fsdp_params_to_vllm(self, model: nn.Module):
+ """Dispatch FSDP weight sync to the version-appropriate method."""
+ if self._dist.fsdp_version == 1:
+ self._sync_fsdp1_params_to_vllm(model)
+ elif self._dist.fsdp_version == 2:
+ self._sync_fsdp2_params_to_vllm(model)
+
+ def sync_weights(self):
+ """Synchronize model weights to vLLM.
+
+ Handles FSDP, DeepSpeed, PEFT weight synchronization.
+ """
+ # Wake up vLLM weights before loading to ensure device memory is mapped. Without this, load_weights() writes to
+ # freed/unmapped memory when sleep mode is active, which crashes on backends with strict physical memory
+ # management (e.g., Ascend NPU). See https://github.com/huggingface/trl/issues/5142
+ if self.mode == "colocate" and self.enable_sleep_mode:
+ empty_cache() # required to avoid OOM in some cases
+ self.llm.wake_up(tags=["weights"])
+
+ model = self.model
+ accelerator = self.accelerator
+
+ if is_peft_model(model):
+ # With PEFT and FSDP/DeepSpeed ZeRO Stage 3, we must gather the full model at once before merging, as
+ # merging adapters in a sharded manner is not supported.
+ # TODO: does this work with FSDP?
+ with self._dist.gather_params(list(model.parameters())):
+ model.merge_adapter()
+
+ # Update vLLM weights while parameters are gathered
+ if self._dist.is_fsdp: # note if using FSDP, gather_params is a no-op
+ # For PEFT with FSDP we need to use the memory efficient post-order traversal
+ self._sync_fsdp_params_to_vllm(model)
+ else:
+ # DeepSpeed ZeRO-3 with PEFT
+ for name, param in model.named_parameters():
+ # When using PEFT, we need to recover the original parameter name
+ name = name.removeprefix("base_model.model.").replace(".base_layer", "")
+ # Skip PEFT layers: they don't exist in vLLM, and they are merged already.
+ if model.prefix in name:
+ continue
+ # When module to save, remove its prefix and discard the original module
+ if "original_module" in name:
+ continue
+ name = self._fix_param_name_to_vllm(name, extra_prefixes=["modules_to_save.default."])
+
+ self._push_param_to_vllm(name, param.data)
+ # Unmerge adapters while parameters are still gathered
+ model.unmerge_adapter()
+ # Parameters will automatically be repartitioned when exiting the context
+ else:
+ # For non-PEFT models, simply gather (if needed) and update each parameter individually.
+ if self._dist.is_fsdp:
+ self._sync_fsdp_params_to_vllm(model)
+ else:
+ for name, param in model.named_parameters():
+ name = self._fix_param_name_to_vllm(name)
+ with self._dist.gather_params([param]):
+ self._push_param_to_vllm(name, param.data)
+
+ # Reset cache on vLLM
+ if self.mode == "server" and accelerator.is_main_process:
+ self.vllm_client.reset_prefix_cache()
+ elif self.mode == "colocate":
+ self.llm.reset_prefix_cache()
+
+ def generate(
+ self,
+ prompts: list[list[int]],
+ images: list[list | None] | None,
+ num_generations: int,
+ profiler: ProfilingContext | None = None,
+ ) -> tuple:
+ """Generate completions using vLLM.
+
+ Args:
+ prompts: List of token ID lists, one per prompt (already tokenized).
+ images: Optional list of image lists for VLM support. Each element is a list of PIL images for the
+ corresponding prompt, or `None` if no images for that prompt. `None` if no images at all.
+ num_generations: Number of generations per prompt.
+ profiler: Optional profiler for performance tracking.
+
+ Returns:
+ Tuple of (prompt_ids, completion_ids, logprobs, logprob_token_ids).
+
+ - `prompt_ids`: `list[list[int]]` of shape `(batch_size, prompt_len)`.
+ - `completion_ids`: `list[list[int]]` of shape `(batch_size, completion_len)`.
+ - `logprobs`: `list[list[list[float | None]]]` of shape `(batch_size, completion_len, num_logprobs)`.
+ - `logprob_token_ids`: `list[list[list[int]]]` of shape `(batch_size, completion_len, num_logprobs)`.
+
+ `num_logprobs` is 1 when `logprobs=0`, or up to N+1 when `logprobs=N` (the sampled token is always included
+ and may fall outside the top-N).
+ """
+ profiler = profiler or nullcontext()
+ accelerator = self.accelerator
+ temperature = self.temperature
+ top_p = self.top_p
+ top_k = self.top_k
+ min_p = self.min_p
+ repetition_penalty = self.repetition_penalty
+ max_completion_length = self.max_completion_length
+
+ # Wake up colocated vLLM weights if needed (idempotent if already awake from sync_weights)
+ if self.mode == "colocate" and self.enable_sleep_mode:
+ empty_cache() # required to avoid OOM in some cases
+ self.llm.wake_up(tags=["weights"])
+ # Work around for https://github.com/vllm-project/vllm/issues/29341
+ try:
+ self.llm.collective_rpc("reload_weights")
+ except NotImplementedError:
+ # Non-CUDA vLLM backends (e.g., vllm-ascend's NPUWorkerV1), don't implement reload_weights
+ pass
+
+ # Generate completions using vLLM: gather all prompts and use them in a single call in the main process
+ if self.mode == "server":
+ all_prompts = gather_object(prompts)
+ # Always gather images (even when None) to avoid deadlock: images may be None on some ranks
+ # and non-None on others in mixed datasets, and gather_object is a collective operation.
+ all_images = gather_object(images if images is not None else [None] * len(prompts))
+ if all(img is None for img in all_images):
+ all_images = None
+
+ if accelerator.is_main_process:
+ # Since 'prompts' contains 'num_generations' duplicates, we first take unique prompts, and
+ # generate num_generations outputs for each one. This is faster than generating outputs for each
+ # duplicate prompt individually.
+ ordered_set_of_prompt_ids = all_prompts[::num_generations]
+ ordered_set_of_images = all_images[::num_generations] if all_images is not None else None
+
+ sampling_params = {
+ "n": num_generations,
+ "repetition_penalty": repetition_penalty,
+ "temperature": temperature,
+ "top_p": top_p,
+ "top_k": top_k,
+ "min_p": 0.0 if min_p is None else min_p,
+ "max_tokens": max_completion_length,
+ "logprobs": self.logprobs,
+ "structured_outputs_regex": self.structured_outputs_regex,
+ "generation_kwargs": self.generation_kwargs,
+ }
+ with profiler:
+ output = self.vllm_client.generate(
+ prompts=ordered_set_of_prompt_ids,
+ images=ordered_set_of_images,
+ **sampling_params,
+ )
+ payload = (
+ output["prompt_ids"],
+ output["completion_ids"],
+ output["logprobs"],
+ output.get("logprob_token_ids"),
+ )
+ else:
+ payload = None
+
+ # Broadcast the completions from the main process to all processes, ensuring each process receives its corresponding slice.
+ obj_list = [payload]
+ broadcast_object_list(obj_list, from_process=0)
+ all_prompt_ids, all_completion_ids, all_logprobs, all_logprob_token_ids = obj_list[0]
+
+ # vllm_client.generate(n=num_generations) returns num_generations completions per prompt.
+ # Duplicate prompt_ids to align with per-completion entries.
+ all_prompt_ids = [ids for ids in all_prompt_ids for _ in range(num_generations)]
+
+ process_slice = slice(
+ accelerator.process_index * len(prompts),
+ (accelerator.process_index + 1) * len(prompts),
+ )
+ prompt_ids = all_prompt_ids[process_slice]
+ completion_ids = all_completion_ids[process_slice]
+ logprobs = all_logprobs[process_slice] if all_logprobs is not None else None
+ logprob_token_ids = all_logprob_token_ids[process_slice] if all_logprob_token_ids is not None else None
+
+ # Generate completions using colocated vLLM instances: each device holds vLLM copy and work on their own batch of prompts
+ elif self.mode == "colocate":
+ generation_kwargs = {
+ "n": 1, # vLLM on each GPU generates only 1 in colocate mode
+ "repetition_penalty": repetition_penalty,
+ "temperature": temperature,
+ "top_p": top_p,
+ "top_k": top_k,
+ "min_p": 0.0 if min_p is None else min_p,
+ "max_tokens": max_completion_length,
+ "logprobs": self.logprobs,
+ }
+ generation_kwargs.update(self.generation_kwargs)
+
+ if self.structured_outputs_regex is not None:
+ if generation_kwargs.get("structured_outputs") is not None:
+ logger.warning(
+ "Both `structured_outputs_regex` and `generation_kwargs['structured_outputs']` are set; "
+ "`structured_outputs_regex` takes precedence."
+ )
+ generation_kwargs["structured_outputs"] = StructuredOutputsParams(regex=self.structured_outputs_regex)
+ elif isinstance(structured_outputs_kwargs := generation_kwargs.get("structured_outputs"), dict):
+ generation_kwargs["structured_outputs"] = StructuredOutputsParams(**structured_outputs_kwargs)
+ sampling_params = SamplingParams(**generation_kwargs)
+
+ if self.tensor_parallel_size > 1:
+ # Gather prompts from all ranks in the TP group and flatten.
+ # Each rank starts with its own prompts; after gathering, all ranks see the full group set.
+ orig_size = len(prompts)
+ gathered_prompts = [None for _ in range(self.tensor_parallel_size)]
+ torch.distributed.all_gather_object(gathered_prompts, prompts, group=self.tp_group)
+ all_prompts = [p for sublist in gathered_prompts for p in sublist]
+ # Always gather images (even when None) to avoid deadlock: images may be None on some
+ # ranks and non-None on others in mixed datasets, and all_gather_object is collective.
+ local_images = images if images is not None else [None] * len(prompts)
+ gathered_images = [None for _ in range(self.tensor_parallel_size)]
+ torch.distributed.all_gather_object(gathered_images, local_images, group=self.tp_group)
+ all_images = [img for sublist in gathered_images for img in sublist]
+ if all(img is None for img in all_images):
+ all_images = None
+ else:
+ all_prompts = prompts
+ all_images = images
+
+ if self.enable_sleep_mode:
+ self.llm.wake_up(tags=["kv_cache"])
+
+ # Build vLLM-compatible prompt inputs with token IDs and optional multi-modal data
+ vllm_prompts = []
+ if all_images is not None:
+ for ids, img_list in zip(all_prompts, all_images, strict=True):
+ row = {"prompt_token_ids": ids}
+ if img_list is not None:
+ row["multi_modal_data"] = {"image": img_list if len(img_list) > 1 else img_list[0]}
+ vllm_prompts.append(row)
+ else:
+ vllm_prompts = [{"prompt_token_ids": ids} for ids in all_prompts]
+
+ with profiler:
+ all_outputs = self.llm.generate(vllm_prompts, sampling_params=sampling_params, use_tqdm=False)
+
+ all_prompt_ids = [output.prompt_token_ids for output in all_outputs]
+ all_completion_ids = [output.token_ids for outputs in all_outputs for output in outputs.outputs]
+ all_logprobs, all_logprob_token_ids = extract_logprobs(all_outputs)
+
+ if self.tensor_parallel_size > 1:
+ # Slice completions for this rank within its TP group.
+ # Each rank generates all outputs — we keep only our share.
+ local_rank_in_group = torch.distributed.get_rank(group=self.tp_group)
+ tp_slice = slice(local_rank_in_group * orig_size, (local_rank_in_group + 1) * orig_size)
+ prompt_ids = all_prompt_ids[tp_slice]
+ completion_ids = all_completion_ids[tp_slice]
+ logprobs = all_logprobs[tp_slice] if all_logprobs is not None else None
+ logprob_token_ids = all_logprob_token_ids[tp_slice] if all_logprob_token_ids is not None else None
+ else:
+ prompt_ids = all_prompt_ids
+ completion_ids = all_completion_ids
+ logprobs = all_logprobs
+ logprob_token_ids = all_logprob_token_ids
+
+ if self.enable_sleep_mode:
+ self.llm.sleep(level=2)
+
+ return prompt_ids, completion_ids, logprobs, logprob_token_ids
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/import_utils.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/import_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..832dbf0844d5429eaf74e8abbfe11c94fc94dfd8
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/import_utils.py
@@ -0,0 +1,149 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import importlib
+import importlib.metadata
+import importlib.util
+import warnings
+from contextlib import contextmanager
+
+from packaging.version import Version
+
+
+LIGER_KERNEL_MIN_VERSION = "0.8.0"
+PACKAGE_DISTRIBUTION_MAPPING = importlib.metadata.packages_distributions()
+
+
+# From transformers: https://github.com/huggingface/transformers/blob/556312cd45a5e619c41b0f8adf680eab0d334324/src/transformers/utils/import_utils.py#L48-L77
+def _is_package_available(pkg_name: str, return_version: bool = False) -> tuple[bool, str] | bool:
+ """Check if `pkg_name` exist, and optionally try to get its version"""
+ spec = importlib.util.find_spec(pkg_name)
+ package_exists = spec is not None
+ package_version = "N/A"
+ if package_exists and return_version:
+ try:
+ # importlib.metadata works with the distribution package, which may be different from the import
+ # name (e.g. `PIL` is the import name, but `pillow` is the distribution name)
+ distributions = PACKAGE_DISTRIBUTION_MAPPING[pkg_name]
+ # Per PEP 503, underscores and hyphens are equivalent in package names.
+ # Prefer the distribution that matches the (normalized) package name.
+ normalized_pkg_name = pkg_name.replace("_", "-")
+ if normalized_pkg_name in distributions:
+ distribution_name = normalized_pkg_name
+ elif pkg_name in distributions:
+ distribution_name = pkg_name
+ else:
+ distribution_name = distributions[0]
+ package_version = importlib.metadata.version(distribution_name)
+ except (importlib.metadata.PackageNotFoundError, KeyError):
+ # If we cannot find the metadata (because of editable install for example), try to import directly.
+ # Note that this branch will almost never be run, so we do not import packages for nothing here
+ package = importlib.import_module(pkg_name)
+ package_version = getattr(package, "__version__", "N/A")
+ if return_version:
+ return package_exists, package_version
+ else:
+ return package_exists
+
+
+def is_deepspeed_available() -> bool:
+ return _is_package_available("deepspeed")
+
+
+def is_fastapi_available() -> bool:
+ return _is_package_available("fastapi")
+
+
+def is_harbor_available() -> bool:
+ return _is_package_available("harbor")
+
+
+def is_jmespath_available() -> bool:
+ return _is_package_available("jmespath")
+
+
+def is_joblib_available() -> bool:
+ return _is_package_available("joblib")
+
+
+def is_liger_kernel_available(min_version: str = LIGER_KERNEL_MIN_VERSION) -> bool:
+ _liger_kernel_available, _liger_kernel_version = _is_package_available("liger_kernel", return_version=True)
+ return _liger_kernel_available and Version(_liger_kernel_version) >= Version(min_version)
+
+
+def is_math_verify_available() -> bool:
+ return _is_package_available("math_verify")
+
+
+def is_mergekit_available() -> bool:
+ return _is_package_available("mergekit")
+
+
+def is_openreward_available() -> bool:
+ return _is_package_available("openreward")
+
+
+def is_pydantic_available() -> bool:
+ return _is_package_available("pydantic")
+
+
+def is_requests_available() -> bool:
+ return _is_package_available("requests")
+
+
+def is_unsloth_available() -> bool:
+ return _is_package_available("unsloth")
+
+
+def is_uvicorn_available() -> bool:
+ return _is_package_available("uvicorn")
+
+
+def is_vllm_available(min_version: str | None = None) -> bool:
+ _vllm_available, _vllm_version = _is_package_available("vllm", return_version=True)
+ if _vllm_available:
+ if not (Version("0.13.0") <= Version(_vllm_version) <= Version("0.22.1")):
+ warnings.warn(
+ f"TRL currently supports vLLM versions from 0.13.0 to 0.22.1. You have version {_vllm_version} "
+ "installed. We recommend installing a supported version to avoid compatibility issues.",
+ stacklevel=2,
+ )
+ if min_version is not None and Version(_vllm_version) < Version(min_version):
+ return False
+ return _vllm_available
+
+
+def is_vllm_ascend_available() -> bool:
+ return _is_package_available("vllm_ascend")
+
+
+def is_weave_available() -> bool:
+ return _is_package_available("weave")
+
+
+class TRLExperimentalWarning(UserWarning):
+ """Warning for using the 'trl.experimental' submodule."""
+
+ pass
+
+
+@contextmanager
+def suppress_warning(category):
+ with warnings.catch_warnings():
+ warnings.simplefilter("ignore", category=category)
+ yield
+
+
+def suppress_experimental_warning():
+ return suppress_warning(TRLExperimentalWarning)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/models/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/models/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f84d989c2825020b0b69c4b31f0285fdcdf54b41
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/models/__init__.py
@@ -0,0 +1,32 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import TYPE_CHECKING
+
+from .._lazy_module import _LazyModule
+
+
+_import_structure = {
+ "activation_offloading": ["get_act_offloading_ctx_manager"],
+ "utils": ["create_reference_model", "prepare_deepspeed", "prepare_fsdp", "unwrap_model_for_generation"],
+}
+
+
+if TYPE_CHECKING:
+ from .activation_offloading import get_act_offloading_ctx_manager
+ from .utils import create_reference_model, prepare_deepspeed, prepare_fsdp, unwrap_model_for_generation
+else:
+ import sys
+
+ sys.modules[__name__] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/models/activation_offloading.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/models/activation_offloading.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e3faecada84e17fb63935967dae333f81f367a8
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/models/activation_offloading.py
@@ -0,0 +1,762 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of https://github.com/pytorch/torchtune.
+
+
+import sys
+
+import psutil
+import torch
+from accelerate.logging import get_logger
+from accelerate.utils.versions import is_torch_version
+from torch import nn
+from torch.autograd.graph import saved_tensors_hooks
+from transformers import is_torch_npu_available
+
+
+if is_torch_npu_available():
+ import torch_npu # noqa: F401
+
+# Import DTensor for FSDP v2 support with version-aware import path
+DTensor = None
+if torch.distributed.is_available():
+ try:
+ if is_torch_version(">=", "2.5.0"):
+ from torch.distributed.tensor import DTensor
+ else:
+ # from torch 2.0.0 (oldest supported accelerate torch version), DTensor is in torch.distributed._tensor
+ from torch.distributed._tensor import DTensor
+ except (ImportError, AttributeError):
+ DTensor = None
+
+logger = get_logger(__name__)
+
+
+def _get_unique_tensor_key(tensor: torch.Tensor) -> tuple:
+ """
+ Get a unique key for a tensor based on its storage pointer and dtype. This allows deduplication of tensors that
+ share the same underlying storage. From:
+ https://github.com/volcengine/verl/blob/main/verl/utils/activation_offload.py
+
+ Args:
+ tensor: The tensor to get the key for
+
+ Returns:
+ A tuple of (storage_pointer, dtype) that uniquely identifies the tensor's storage
+ """
+ # Handle special tensor types - primarily for FSDP v2 DTensor
+ actual_tensor = tensor
+
+ # For DTensor (FSDP v2), extract the local tensor
+ if DTensor is not None and isinstance(tensor, DTensor) and hasattr(tensor, "_local_tensor"):
+ actual_tensor = tensor._local_tensor
+
+ # Try to get storage pointer, but fall back to tensor id if not accessible
+ try:
+ storage_ptr = actual_tensor.untyped_storage().data_ptr() + actual_tensor.storage_offset()
+ except (RuntimeError, AttributeError):
+ # For tensors with invalid storage, use tensor id
+ # This won't enable deduplication for these tensors, but allows offloading to work
+ storage_ptr = id(actual_tensor)
+
+ return (storage_ptr, actual_tensor.dtype)
+
+
+class OffloadActivations(saved_tensors_hooks):
+ """
+ Context manager under which activation tensors created in the forward pass will be offloaded.
+
+ Enable the memory efficiency technique of activation offloading, where activations bigger than `min_offload_size`
+ bytes will be offloaded to CPU in the forward and brought back in the backward. This is in contrast to maintaining
+ the activation on GPU VRAM throughout the program.
+
+ This manager contains the option of using one additional CUDA stream to handle the communication between CUDA and
+ CPU, which is intended to overlap with the default computation stream to improve runtime. We designed
+ synchronization with a few heuristics for optimizing the tradeoff between runtime vs memory usage.
+
+ Args:
+ use_pin_memory (`bool`, *optional*, defaults to `True`):
+ Whether to offloaded Tensor will be placed in pinned memory on the CPU. Pinned memory allows the Tensor to
+ be moved back onto GPU more quickly but is a limited resource.
+ use_streams (`bool`, *optional*, defaults to `True`):
+ Whether to use streams for performance optimization where the communications get overlapped with the
+ computation. Requires a torch build after torch-2.5.0.
+ min_offload_size (`int`, *optional*, defaults to `1024`):
+ Minimum number of bytes a Tensor must be in order to qualify for offloading. If the tensor is too small, we
+ do not want to waste bandwidth and resources moving it to CPU and back.
+ max_fwd_stash_size (`int`, *optional*, defaults to `5`):
+ Maximum size of the forward stash, or the maximum number of consecutive activations to keep alive during
+ the forward pass. This number must be at least 1. Keeping alive more activations will potentially allow
+ more overlap between the communication and compute streams at the cost of increasing memory usage. Keeping
+ alive fewer activations will conserve memory, but may cause poor overlap between the streams, increasing
+ runtime.
+
+ Raises:
+ ValueError: if `max_fwd_stash_size` is not at least `1`.
+
+ Example:
+ ```python
+ >>> with OffloadActivations():
+ ... outputs = model(inputs, labels=labels)
+ >>> loss = outputs.loss
+ >>> loss.backward()
+ ```
+ """
+
+ def __init__(
+ self,
+ use_pin_memory: bool = True,
+ use_streams: bool = True,
+ min_offload_size: int = 1024,
+ max_fwd_stash_size: int = 5,
+ ) -> None:
+ self.use_streams = use_streams
+
+ self.min_tensor_size_bytes = min_offload_size # we don't want to bother with small tensors
+ self.tracker = {} # tensor_id => (new_tensor, if_modified) ---> track what saved/offloaded tensors are where
+ self.tensor_id = 0
+ self.is_first_forward_call = True
+ self.is_first_backward_call = True
+ self.is_first_forward_pass = True
+
+ # Storage deduplication: maps storage key to tensor_id to avoid offloading same storage multiple times
+ self.storage_to_tensor_id = {}
+
+ # Parameter filtering: track parameter storage pointers to skip them during offloading
+ self.param_storages = set()
+
+ # Managing cpu memory
+ self.use_pin_memory = use_pin_memory
+ self.virtual_memory_safe_pct = 60 # we should not exceed this percentage of memory
+
+ self.accelerator_type = (
+ torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+ )
+ # NOTE: xpu doesn't have `default_stream` API, use `current_stream` instead
+ if self.accelerator_type == "xpu": # comp stream
+ self.s0 = torch.xpu.current_stream()
+ elif is_torch_npu_available() and self.accelerator_type == "npu":
+ self.s0 = torch.npu.current_stream()
+ else:
+ self.s0 = torch.cuda.default_stream()
+
+ # For streaming
+ if self.use_streams:
+ if self.accelerator_type == "xpu": # comms stream
+ self.s1 = torch.xpu.Stream()
+ elif self.accelerator_type == "npu":
+ self.s1 = torch.npu.Stream()
+ else:
+ self.s1 = torch.cuda.Stream()
+ self.fwd_stash = {} # tensor_id => (activation, ev1)
+ if max_fwd_stash_size < 1:
+ raise ValueError(f"max_fwd_stash_size should be at least 1 but is {max_fwd_stash_size}")
+ self.max_fwd_stash_size = max_fwd_stash_size
+ self.bwd_tensor_stash = {} # tensor_id => activation
+ self.bwd_ev_stash = {} # tensor_id => ev0
+ self.curr_graph_id = None
+ self.curr_autograd_node = None
+
+ # -------- platform util functions -------- #
+ def verify_sufficient_virtual_memory():
+ curr_pct = get_cpu_ram_pct()
+ if curr_pct > self.virtual_memory_safe_pct:
+ logger.warning(f"{curr_pct=}% > {self.virtual_memory_safe_pct=}% of virtual memory used")
+
+ def get_cpu_ram_pct() -> float:
+ # get the percentage of memory used by the system
+ return psutil.virtual_memory().percent
+
+ def get_tensor_id() -> int:
+ # create a unique id for each tensor we are managing
+ self.tensor_id += 1
+ return self.tensor_id
+
+ def get_num_bytes_tensor(x: torch.Tensor) -> int:
+ # get the number of bytes in a tensor, for memory management purposes
+ return x.element_size() * x.nelement() # x.element_size() * x._base_storage().nbytes()
+
+ # -------- core pack / unpack work -------- #
+ def pack_tensor(activation: torch.Tensor) -> int:
+ # activations are passed in during forward pass - from here we take over and return a unique id
+ if self.is_first_forward_call:
+ if len(self.tracker) != 0:
+ raise ValueError("Backward pass should have cleared tracker of all tensors")
+
+ # set training phase trackers
+ self.is_first_forward_call = False
+ self.is_first_backward_call = True
+ # Reset deduplication map for new forward pass
+ self.storage_to_tensor_id = {}
+
+ # query for basic tensor info
+ num_bytes = get_num_bytes_tensor(activation)
+ tensor_id = get_tensor_id()
+
+ # Check for tensor deduplication using storage pointer
+ # If this storage is already being tracked, we still create a new tensor_id
+ # but don't offload again (just keep the tensor in GPU)
+ storage_key = _get_unique_tensor_key(activation)
+ if storage_key in self.storage_to_tensor_id:
+ # Storage already offloaded - don't offload again, just track the reference
+ self.tracker[tensor_id] = (activation, False, None, None, None) # Keep on GPU, don't offload
+ return tensor_id
+
+ # Check if tensor is on CPU (skip offloading)
+ if activation.device.type not in ["cuda", "xpu", "npu"]:
+ self.tracker[tensor_id] = (activation, False, None, None, None)
+ return tensor_id
+
+ # Check if tensor is too small
+ if num_bytes < self.min_tensor_size_bytes:
+ self.tracker[tensor_id] = (activation, False, None, None, None)
+ return tensor_id
+
+ # Check if tensor is a parameter or buffer
+ if isinstance(activation, torch.nn.Parameter) or (
+ hasattr(torch.nn, "Buffer") and isinstance(activation, torch.nn.Buffer)
+ ):
+ self.tracker[tensor_id] = (activation, False, None, None, None)
+ return tensor_id
+
+ # Check if tensor is an FP8 tensor (TorchAO) - skip offloading as they're already compressed
+ tensor_class_name = type(activation).__name__
+ if tensor_class_name in ["Float8TrainingTensor", "ScaledMMConfig", "LinearMMConfig"]:
+ self.tracker[tensor_id] = (activation, False, None, None, None)
+ return tensor_id
+
+ # Check if tensor storage is a model parameter (for FSDP compatibility)
+ try:
+ # Extract actual tensor for DTensor
+ check_tensor = activation
+ if DTensor is not None and isinstance(activation, DTensor) and hasattr(activation, "_local_tensor"):
+ check_tensor = activation._local_tensor
+
+ if check_tensor.untyped_storage().data_ptr() in self.param_storages:
+ self.tracker[tensor_id] = (activation, False, None, None, None)
+ return tensor_id
+ except (RuntimeError, AttributeError):
+ # If we can't get data_ptr, skip this check
+ pass
+
+ # Tensor qualifies for offloading
+ if self.use_streams:
+ # First, sync back and dereference previously offloaded tensors
+ # as the offloading should be done sufficiently long ago.
+ for id in list(self.fwd_stash.keys()):
+ if id <= tensor_id - self.max_fwd_stash_size:
+ _, ev = self.fwd_stash[id]
+ self.s0.wait_event(ev)
+ del self.fwd_stash[id]
+ else:
+ break
+
+ # Sync in, offload, and add an event to sync back later
+ self.s1.wait_stream(self.s0)
+
+ stream = self.s1 if self.use_streams else self.s0
+ if self.accelerator_type == "xpu":
+ stream_ctx = torch.xpu.stream(stream)
+ elif self.accelerator_type == "npu":
+ stream_ctx = torch.npu.stream(stream)
+ else:
+ stream_ctx = torch.cuda.stream(stream)
+ with stream_ctx:
+ # Save original stride and shape information
+ original_stride = activation.stride()
+ original_storage_offset = activation.storage_offset()
+ original_shape = activation.size()
+
+ # Check if tensor has broadcast dimensions (stride == 0)
+ # If so, copy the underlying storage directly instead of materializing the broadcast
+ has_broadcast = 0 in original_stride
+
+ if has_broadcast:
+ # Copy only the actual underlying storage, not the materialized broadcast
+ # Create CPU tensor with same storage size as original
+ storage_size = activation.untyped_storage().size()
+ cpu_storage = torch.empty(
+ storage_size // activation.element_size(),
+ dtype=activation.dtype,
+ pin_memory=self.use_pin_memory,
+ device="cpu",
+ )
+ # Copy the raw storage
+ cpu_storage_view = torch.as_strided(
+ activation, size=(storage_size // activation.element_size(),), stride=(1,), storage_offset=0
+ )
+ cpu_storage.copy_(cpu_storage_view, non_blocking=True)
+ cpu_tensor = cpu_storage
+ else:
+ # No broadcast - use normal contiguous copy
+ # .contiguous() can be a no-op for contiguous views with
+ # non-zero storage_offset. Force a clone for those views
+ # so later as_strided reconstruction stays in bounds.
+ if not activation.is_contiguous() or activation.storage_offset() != 0:
+ if activation.storage_offset() != 0:
+ activation = activation.clone(memory_format=torch.contiguous_format)
+ else:
+ activation = activation.contiguous()
+ original_stride = activation.stride()
+ original_storage_offset = activation.storage_offset()
+ cpu_tensor = torch.empty_like(activation, pin_memory=self.use_pin_memory, device="cpu")
+ cpu_tensor.copy_(activation, non_blocking=True)
+
+ # Store CPU tensor along with stride information
+ self.tracker[tensor_id] = (
+ cpu_tensor,
+ True, # True = (in future) modified
+ original_stride, # Save original GPU stride
+ original_storage_offset, # Save original storage offset
+ original_shape, # Save original shape for broadcast restoration
+ )
+
+ if self.use_streams:
+ event = self.s1.record_event()
+
+ # Stash to keep activation alive til s1 is done
+ self.fwd_stash[tensor_id] = (activation, event)
+
+ # Track this storage for deduplication
+ self.storage_to_tensor_id[storage_key] = tensor_id
+
+ return tensor_id
+
+ def unpack_tensor_single_stream(unpack_tensor_id: int) -> torch.Tensor:
+ # backward pass - we are called with the tensor_id, which
+ # we will use to retrieve the saved/offloaded tensor
+ if self.is_first_backward_call:
+ if self.is_first_forward_pass:
+ self.is_first_forward_pass = False
+ if self.use_pin_memory:
+ verify_sufficient_virtual_memory()
+
+ self.is_first_backward_call = False
+
+ if unpack_tensor_id not in self.tracker:
+ raise ValueError(f"Untracked tensor with id {unpack_tensor_id}")
+
+ (
+ maybe_accelerator_tensor,
+ modified,
+ original_stride,
+ original_storage_offset,
+ original_shape,
+ ) = self.tracker[unpack_tensor_id]
+
+ if modified:
+ # Restore tensor to GPU
+ accelerator_tensor = maybe_accelerator_tensor.to(self.accelerator_type, non_blocking=True)
+ # Restore original stride if we saved it (handles both broadcast and non-broadcast cases)
+ if original_stride is not None:
+ accelerator_tensor = torch.as_strided(
+ accelerator_tensor,
+ size=original_shape,
+ stride=original_stride,
+ storage_offset=original_storage_offset,
+ )
+ maybe_accelerator_tensor = accelerator_tensor
+
+ # clear tensor from tracking
+ del self.tracker[unpack_tensor_id]
+ # Only set is_first_forward_call to True when all tensors have been unpacked
+ if len(self.tracker) == 0:
+ self.is_first_forward_call = True
+ return maybe_accelerator_tensor
+
+ def unpack_tensor_with_streams(unpack_tensor_id: int) -> torch.Tensor:
+ # backward pass - we are called with the tensor_id, which
+ # we will use to retrieve the saved/offloaded tensor
+ if self.is_first_backward_call:
+ self.curr_graph_id = torch._C._current_graph_task_id()
+
+ def wait_and_del_remaining_references() -> None:
+ for id in list(self.bwd_tensor_stash.keys()):
+ if id in self.bwd_ev_stash:
+ event = self.bwd_ev_stash[id]
+ self.s1.wait_event(event)
+ del self.bwd_tensor_stash[id]
+
+ # Register a callback to the end of autograd to clean everything up
+ torch.autograd.variable.Variable._execution_engine.queue_callback(wait_and_del_remaining_references)
+
+ if self.is_first_forward_pass:
+ self.is_first_forward_pass = False
+ if self.use_pin_memory:
+ verify_sufficient_virtual_memory()
+
+ self.is_first_backward_call = False
+
+ if unpack_tensor_id not in self.tracker:
+ raise ValueError(f"untracked tensor with id {unpack_tensor_id}")
+
+ (
+ maybe_accelerator_tensor,
+ modified,
+ original_stride,
+ original_storage_offset,
+ original_shape,
+ ) = self.tracker[unpack_tensor_id]
+
+ if modified:
+ # Get data on the current autograd node
+ graph_id = torch._C._current_graph_task_id()
+ node = torch._C._current_autograd_node()
+ prev_node_ids = []
+
+ # If we're on a new node, mark prev node's tensors to be freed later
+ if graph_id == self.curr_graph_id and self.curr_autograd_node != node:
+ self.curr_autograd_node = node
+ prev_node_ids = list(self.bwd_tensor_stash.keys())
+
+ brought_back_from_cpu = True
+ if unpack_tensor_id in self.fwd_stash:
+ maybe_accelerator_tensor = self.fwd_stash[unpack_tensor_id][0]
+ brought_back_from_cpu = False
+ else:
+ # Kick off the process to bring tensors back
+ if self.accelerator_type == "xpu":
+ stream_ctx = torch.xpu.stream(self.s1)
+ elif self.accelerator_type == "npu":
+ stream_ctx = torch.npu.stream(self.s1)
+ else:
+ stream_ctx = torch.cuda.stream(self.s1)
+ with stream_ctx:
+ # Restore tensor to GPU
+ accelerator_tensor = maybe_accelerator_tensor.to(self.accelerator_type, non_blocking=True)
+ # Restore original stride if we saved it (handles both broadcast and non-broadcast cases)
+ if original_stride is not None:
+ accelerator_tensor = torch.as_strided(
+ accelerator_tensor,
+ size=original_shape,
+ stride=original_stride,
+ storage_offset=original_storage_offset,
+ )
+ maybe_accelerator_tensor = accelerator_tensor
+
+ # Tell comp stream to wait for the info to be loaded before executing
+ self.s0.wait_stream(self.s1)
+
+ # Stash the tensor to keep memory alive until compute stream is complete
+ self.bwd_tensor_stash[unpack_tensor_id] = maybe_accelerator_tensor
+
+ # Note: [Track views of the unpacked]
+ # Why do we get the use count of the unpacked tensor here? We want an
+ # initial count to compare to later, during the post-hook of the
+ # backward node, when we need to decide whether we're allowed to free
+ # the tensor yet. In what obscure cases must we delay freeing the
+ # tensor (and thus call record_stream)?
+ # 1. Any of the outputs of the backward node is a view of the unpacked
+ # tensor.
+ # 2. In the case that this unpacked tensor will be used in a
+ # checkpointed region, if one of the recomputed saved tensors ends
+ # up as a view of the unpacked tensor.
+ # 3. The user abuses the system somehow and manually relies on the
+ # unpacked tensor to exist after the backward node has executed.
+ if self.accelerator_type == "npu":
+ storage_refcount = torch_npu._C._storage_Use_Count(
+ maybe_accelerator_tensor.untyped_storage()._cdata
+ )
+ else:
+ storage_refcount = torch._C._storage_Use_Count(
+ maybe_accelerator_tensor.untyped_storage()._cdata
+ )
+
+ def hook(outputs, inputs):
+ # create events for the current node inputs/outputs if they were streamed in
+ if brought_back_from_cpu:
+ # See Note: [Track views of the unpacked]
+ # IF any of the outputs is a view of the tensor, OR if a view of
+ # the tensor has been saved as a part of checkpoint's recompute
+ # process, OR the user has abusedly incurred a reference on the
+ # unpacked tensor, THEN the tensor might be used later and we
+ # cannot presume to delete it after only the current node is
+ # done! So we use our frenemy, record_stream, to ensure the
+ # Tensor stays unmessed with until it's done getting used in the
+ # compute stream (s0 here). Note that the con here is we introduce
+ # non-deterministic (thus higher) memory usage, but this case
+ # should not happen often.
+ # Check if tensor still exists (might have been cleaned up by a previous node)
+ if unpack_tensor_id in self.bwd_tensor_stash:
+ unpacked_tensor = self.bwd_tensor_stash[unpack_tensor_id]
+ if self.accelerator_type == "npu":
+ storage_count = torch_npu._C._storage_Use_Count(
+ unpacked_tensor.untyped_storage()._cdata
+ )
+ else:
+ storage_count = torch._C._storage_Use_Count(unpacked_tensor.untyped_storage()._cdata)
+ if storage_count > storage_refcount:
+ unpacked_tensor.record_stream(self.s0)
+ del self.bwd_tensor_stash[unpack_tensor_id]
+ else:
+ event = self.s0.record_event()
+ self.bwd_ev_stash[unpack_tensor_id] = event
+
+ # if there are still things in the fwd_stash, get rid of them as we're in bwd now
+ for id in list(self.fwd_stash.keys()):
+ _, ev = self.fwd_stash[id]
+ self.s0.wait_event(ev)
+ del self.fwd_stash[id]
+
+ # wait on prev node's events and del those
+ for id in prev_node_ids:
+ # Only wait on events that exist (some tensors may have used record_stream instead)
+ if id in self.bwd_ev_stash:
+ event = self.bwd_ev_stash[id]
+ self.s1.wait_event(event)
+ del self.bwd_ev_stash[id]
+ if id in self.bwd_tensor_stash:
+ del self.bwd_tensor_stash[id]
+
+ return outputs
+
+ node.register_hook(hook)
+
+ # clear tensor from tracking
+ del self.tracker[unpack_tensor_id]
+ # Only set is_first_forward_call to True when all tensors have been unpacked
+ if len(self.tracker) == 0:
+ self.is_first_forward_call = True
+ return maybe_accelerator_tensor
+
+ unpack_tensor = unpack_tensor_with_streams if self.use_streams else unpack_tensor_single_stream
+ super().__init__(pack_tensor, unpack_tensor)
+
+ def update_model_params(self, model: nn.Module):
+ """
+ Update the set of parameter storage pointers from the model. This allows filtering out model parameters during
+ offloading, which is especially important for FSDP models where parameters may not be detected by isinstance
+ checks.
+
+ For FSDP v2, this method handles DTensor parameters which may be sharded across ranks and not have valid local
+ storage on all ranks. We extract the local tensor from DTensors using _local_tensor when available.
+
+ Args:
+ model: The model whose parameters should be tracked
+ """
+ param_storages = set()
+
+ for p in model.parameters():
+ # For FSDP v2: extract local tensor from DTensor
+ actual_tensor = p
+ if DTensor is not None and isinstance(p, DTensor) and hasattr(p, "_local_tensor"):
+ actual_tensor = p._local_tensor
+
+ # Try to get storage pointer
+ try:
+ storage_ptr = actual_tensor.untyped_storage().data_ptr()
+ if storage_ptr != 0:
+ param_storages.add(storage_ptr)
+ except RuntimeError:
+ # Parameter doesn't have accessible storage (e.g., FSDP v2 sharded without local shard, FP8 parameters)
+ # These will be caught by other checks (isinstance for Parameter, class name for FP8)
+ continue
+
+ self.param_storages = param_storages
+
+ def __enter__(self):
+ """Clear stale state and release BNB buffers before entering.
+
+ By the time __enter__ is called, the previous forward/backward has already completed, so anything still in
+ tracker, storage_to_tensor_id, or the stashes is leaked and safe to drop.
+
+ Two leak paths are handled:
+ 1. MoE + sample_packing + torch.compile: dynamic expert routing may leave saved tensors on subgraphs whose
+ backward nodes never execute, so the unpack-then-delete logic never fires. tracker/stashes from the previous
+ step survive into the next.
+ 2. QLoRA BNB dequantization buffers: tracker retains references to tensors sharing allocator blocks with BNB
+ buffers, and the allocator cache is never flushed between steps (~0.6 GiB/step, OOM after 30-40).
+
+ Returns super().__enter__() to register pack/unpack hooks via saved_tensors_hooks (PyTorch autograd engine).
+ """
+ self.tracker.clear()
+ self.storage_to_tensor_id.clear()
+ self.tensor_id = 0
+ self.is_first_forward_call = True
+ self.is_first_backward_call = True
+ if self.use_streams:
+ self.bwd_tensor_stash.clear()
+ self.bwd_ev_stash.clear()
+ self.fwd_stash.clear()
+ if "bitsandbytes" in sys.modules:
+ if self.accelerator_type == "xpu":
+ torch.xpu.empty_cache()
+ elif is_torch_npu_available() and self.accelerator_type == "npu":
+ torch.npu.empty_cache()
+ else:
+ torch.cuda.empty_cache()
+ return super().__enter__()
+
+ def __exit__(self, *args, **kwargs):
+ """Sync streams and clear stashes before parent cleanup.
+
+ try/finally ensures the saved_tensors_hooks parent cleanup runs even if stream sync raises — otherwise hooks
+ stay permanently installed, creating a silent memory leak.
+ """
+ try:
+ if self.use_streams:
+ self.s0.synchronize()
+ self.s1.synchronize()
+ self.bwd_tensor_stash.clear()
+ self.bwd_ev_stash.clear()
+ self.fwd_stash.clear()
+ finally:
+ result = super().__exit__(*args, **kwargs)
+ return result
+
+
+class NoOpManager(saved_tensors_hooks):
+ """
+ A `saved_tensors_hook` manager used to disable any other `saved_tensors_hook` manager applied before. This relies
+ on the behavior that only the most recently registered `saved_tensors_hook` will run.
+
+ One example usage is to opt a local region of code out of activations offloading, which is usually applied globally
+ to best track state.
+ """
+
+ def __init__(self) -> None:
+ def noop(tensor):
+ return tensor
+
+ super().__init__(noop, noop)
+
+
+def get_act_offloading_ctx_manager(
+ model: nn.Module,
+ use_pin_memory: bool = True,
+ use_streams: bool = True,
+ min_offload_size: int = 1024,
+ max_fwd_stash_size: int = 5,
+ warn_if_no_head: bool = True,
+) -> OffloadActivations:
+ """
+ Returns the activation offloading context manager for the model. All but the last output Linear in every step will
+ be offloaded.
+
+ If activation offloading is enabled, we return the OffloadActivations context manager. If activation offloading is
+ disabled, we return a NoOpManager context manager.
+
+ Args:
+ model (`nn.Module`):
+ Model to wrap with the activation offloading context manager.
+ use_pin_memory (`bool`, *optional*, defaults to `True`):
+ Whether to offloaded Tensor will be placed in pinned memory on the CPU. Pinned memory allows the Tensor to
+ be moved back onto GPU more quickly but is a limited resource.
+ use_streams (`bool`, *optional*, defaults to `True`):
+ Whether to use streams for performance optimization where the communications get overlapped with the
+ computation. Requires a torch build after torch-2.5.0.
+ min_offload_size (`int`, *optional*, defaults to `1024`):
+ Minimum number of bytes a Tensor must be in order to qualify for offloading. If the tensor is too small, we
+ do not want to waste bandwidth and resources moving it to CPU and back.
+ max_fwd_stash_size (`int`, *optional*, defaults to `5`):
+ Maximum size of the forward stash, or the maximum number of consecutive activations to keep alive during
+ the forward pass. This number must be at least 1. Keeping alive more activations will potentially allow
+ more overlap between the communication and compute streams at the cost of increasing memory usage. Keeping
+ alive fewer activations will conserve memory, but may cause poor overlap between the streams, increasing
+ runtime.
+ warn_if_no_head (`bool`, *optional*, defaults to `True`):
+ Whether to warn if no output head is detected. If set to `False`, no warning will be raised if no output
+ head is detected.
+
+ Returns:
+ `contextlib.ContextDecorator`:
+ Activation offloading context manager for the model.
+ """
+ activations_handling_ctx = OffloadActivations(
+ use_pin_memory=use_pin_memory,
+ use_streams=use_streams,
+ min_offload_size=min_offload_size,
+ max_fwd_stash_size=max_fwd_stash_size,
+ )
+
+ # Update parameter storages to filter them during offloading (important for FSDP)
+ activations_handling_ctx.update_model_params(model)
+
+ # Below is our hack to disable offloading the last output Linear in every
+ # step, as the cost for offloading the activation and then soon after bringing
+ # it back is expensive.
+ output_head_detected = False
+ noop_ctx = NoOpManager()
+
+ # Try to get the actual model if it's wrapped
+ unwrapped_model = model
+ if hasattr(unwrapped_model, "module"):
+ unwrapped_model = unwrapped_model.module
+ # check for PEFT models
+ if hasattr(unwrapped_model, "base_model") and hasattr(unwrapped_model, "peft_config"):
+ unwrapped_model = unwrapped_model.base_model
+
+ # Check for different types of output heads
+ if hasattr(unwrapped_model, "output"):
+ if isinstance(unwrapped_model.output, nn.Module):
+ unwrapped_model.output.register_forward_pre_hook(lambda *args: noop_ctx.__enter__())
+ unwrapped_model.output.register_forward_hook(lambda *args: noop_ctx.__exit__(), always_call=True)
+ output_head_detected = True
+ elif hasattr(unwrapped_model.output, "linear") and isinstance(unwrapped_model.output.linear, nn.Module):
+ unwrapped_model.output.linear.register_forward_pre_hook(lambda *args: noop_ctx.__enter__())
+ unwrapped_model.output.linear.register_forward_hook(lambda *args: noop_ctx.__exit__(), always_call=True)
+ output_head_detected = True
+
+ # Check for HuggingFace model output heads
+ elif hasattr(unwrapped_model, "lm_head"):
+ unwrapped_model.lm_head.register_forward_pre_hook(lambda *args: noop_ctx.__enter__())
+ unwrapped_model.lm_head.register_forward_hook(lambda *args: noop_ctx.__exit__(), always_call=True)
+ output_head_detected = True
+
+ # Check for decoder-based models
+ elif hasattr(unwrapped_model, "decoder"):
+ decoder = unwrapped_model.decoder
+ if hasattr(decoder, "output"):
+ decoder.output.register_forward_pre_hook(lambda *args: noop_ctx.__enter__())
+ decoder.output.register_forward_hook(lambda *args: noop_ctx.__exit__(), always_call=True)
+ output_head_detected = True
+ # Some models have lm_head in the decoder
+ elif hasattr(decoder, "lm_head"):
+ decoder.lm_head.register_forward_pre_hook(lambda *args: noop_ctx.__enter__())
+ decoder.lm_head.register_forward_hook(lambda *args: noop_ctx.__exit__(), always_call=True)
+ output_head_detected = True
+
+ # Check for transformer models with final layer norm
+ elif hasattr(unwrapped_model, "final_layer_norm") or hasattr(unwrapped_model, "ln_f"):
+ final_norm = getattr(unwrapped_model, "final_layer_norm", None) or unwrapped_model.ln_f
+ final_norm.register_forward_pre_hook(lambda *args: noop_ctx.__enter__())
+ final_norm.register_forward_hook(lambda *args: noop_ctx.__exit__(), always_call=True)
+ output_head_detected = True
+
+ # Check for models with head module
+ elif hasattr(unwrapped_model, "head") and isinstance(unwrapped_model.head, nn.Module):
+ unwrapped_model.head.register_forward_pre_hook(lambda *args: noop_ctx.__enter__())
+ unwrapped_model.head.register_forward_hook(lambda *args: noop_ctx.__exit__(), always_call=True)
+ output_head_detected = True
+
+ if not output_head_detected and warn_if_no_head:
+ logger.warning(
+ "During activation offloading, no output head was detected. If your model has an output head, it will be "
+ "offloaded. This usually greatly slows training, given the large vocabulary size. To change this "
+ "behavior, set your output head as model.output and make it an nn.Module. You can disable this warning by "
+ "passing `warn_if_no_head=False`."
+ )
+
+ # Disable offloading for any Liger modules
+ for name, module in unwrapped_model.named_modules():
+ if "liger" in name.lower():
+ module.register_forward_pre_hook(lambda *args: noop_ctx.__enter__())
+ module.register_forward_hook(lambda *args: noop_ctx.__exit__(), always_call=True)
+
+ return activations_handling_ctx
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/models/utils.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/models/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..52badde5ed6a278595bc968d081ec83b2ad52b2d
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/models/utils.py
@@ -0,0 +1,406 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import itertools
+import warnings
+from collections.abc import Callable
+from contextlib import contextmanager
+from copy import deepcopy
+from typing import TYPE_CHECKING, Any
+
+import accelerate
+import torch.nn as nn
+import transformers
+from accelerate import Accelerator
+from packaging.version import Version
+from torch.distributed.fsdp import FSDPModule
+from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP
+from transformers import GenerationConfig, PreTrainedModel
+
+from ..import_utils import suppress_experimental_warning
+
+
+with suppress_experimental_warning():
+ from ..experimental.utils import create_reference_model as _create_reference_model
+
+
+if Version(accelerate.__version__) >= Version("1.11.0"):
+ from accelerate.utils.fsdp_utils import get_parameters_from_modules
+
+if TYPE_CHECKING:
+ from deepspeed.runtime.engine import DeepSpeedEngine
+ from torch.nn import Module
+ from torch.nn.parallel.distributed import DistributedDataParallel
+
+
+def remove_hooks(model: "DeepSpeedEngine") -> None:
+ """Removes the optimizer hooks from a DeepSpeed ZeRO-3 model."""
+ if not hasattr(model, "optimizer"): # before the first training step, the model has no optimizer
+ return
+ if model.optimizer is not None and hasattr(model.optimizer, "parameter_offload"):
+ optimizer_offload = model.optimizer.parameter_offload
+ elif model.optimizer is not None:
+ optimizer_offload = model.optimizer
+ else:
+ raise RuntimeError("The model optimizer is None, which is not yet supported.")
+
+ for param in iter_params(optimizer_offload.module, recurse=True):
+ param.ds_active_sub_modules.clear()
+
+ for hook in optimizer_offload.forward_hooks:
+ hook.remove()
+ for hook in optimizer_offload.backward_hooks:
+ hook.remove()
+
+ optimizer_offload.forward_hooks = []
+ optimizer_offload.backward_hooks = []
+
+
+def get_all_parameters(sub_module, recurse=False):
+ return itertools.chain(sub_module.named_parameters(recurse=recurse), sub_module.ds_external_parameters())
+
+
+def iter_params(module, recurse=False):
+ return [param for _, param in get_all_parameters(module, recurse)]
+
+
+def add_hooks(model: "DeepSpeedEngine") -> None:
+ """Adds the optimizer hooks from a DeepSpeed ZeRO-3 model."""
+ import deepspeed
+
+ if not hasattr(model, "optimizer"): # before the first training step, the model has no optimizer
+ return
+ if model.optimizer is not None and hasattr(model.optimizer, "parameter_offload"):
+ optimizer_offload = model.optimizer.parameter_offload
+ elif model.optimizer is not None:
+ optimizer_offload = model.optimizer
+ else:
+ raise RuntimeError("The model optimizer is None, which is not yet supported.")
+
+ # Invalidate parameter coordinator trace to prevent stale state
+ # after generation forward passes (fixes ZeRO-3 + GKD compatibility)
+ if hasattr(optimizer_offload, "param_coordinator"): # param_coordinator only exists in ZeRO stage 3
+ coordinator = optimizer_offload.param_coordinator
+ # Only invalidate if trace is not already invalid
+ if not coordinator.is_invalid_trace():
+ coordinator._invalidate_trace()
+
+ if Version(deepspeed.__version__) >= Version("0.16.4"):
+ # Account for renaming in https://github.com/deepspeedai/DeepSpeed/pull/6847
+ optimizer_offload._register_deepspeed_module(optimizer_offload.module)
+ else:
+ optimizer_offload._register_hooks_recursively(optimizer_offload.module)
+
+
+@contextmanager
+def _unwrap_model_for_generation(
+ model: "DistributedDataParallel | DeepSpeedEngine",
+ accelerator: "Accelerator",
+ gather_deepspeed3_params: bool = True,
+):
+ """
+ Context manager to unwrap distributed or accelerated models for generation tasks.
+
+ Args:
+ model (`DistributedDataParallel | DeepSpeedEngine`):
+ Model to be unwrapped.
+ accelerator ([`~accelerate.Accelerator`]):
+ Accelerator instance managing the model.
+ gather_deepspeed3_params (`bool`, *optional*, defaults to `True`):
+ Whether to gather weights for DeepSpeed ZeRO Stage 3 models. If `False`, skips parameter gathering, which
+ can be more memory-efficient but may lead to slower generation times.
+
+ Yields:
+ Unwrapped model.
+
+ Example:
+ ```python
+ with _unwrap_model_for_generation(model, accelerator) as unwrapped_model:
+ generated_outputs = unwrapped_model.generate(input_ids)
+ ```
+ """
+ unwrapped_model = accelerator.unwrap_model(model)
+ is_gradient_checkpointing = unwrapped_model.is_gradient_checkpointing
+ if is_gradient_checkpointing:
+ unwrapped_model.gradient_checkpointing_disable()
+ from ..distributed import DistributedBackend
+
+ if DistributedBackend(accelerator).is_zero3:
+ if not gather_deepspeed3_params:
+ yield accelerator.unwrap_model(model)
+ else:
+ import deepspeed
+
+ with deepspeed.zero.GatheredParameters(model.parameters()):
+ remove_hooks(model)
+ yield accelerator.unwrap_model(model)
+ add_hooks(model)
+ else:
+ yield unwrapped_model
+ if is_gradient_checkpointing:
+ unwrapped_model.gradient_checkpointing_enable()
+
+
+@contextmanager
+def _override_model_generation_config(model, generation_kwargs=None):
+ """
+ Context manager to temporarily override a model's generation_config with training config.
+
+ This works around transformers' config merging logic that would otherwise overwrite values matching global defaults
+ with model-specific values (see upstream issue transformers#42762; fixed in transformers v5 by PR
+ `transformers#42702`).
+
+ By temporarily setting the model's generation_config to match the passed generation_config, we avoid the conflict.
+
+ The model's original generation_config is preserved outside this context, ensuring that saved/pushed models retain
+ their intended inference behavior.
+
+ Args:
+ model: The model (typically unwrapped_model) whose generation_config to temporarily override.
+ generation_kwargs (dict): Generation kwargs to be used to override model's generation config.
+ """
+ if (
+ # Issue fixed in transformers v5 by PR transformers#42702
+ Version(transformers.__version__) >= Version("5.0.0")
+ or generation_kwargs is None
+ or not hasattr(model, "generation_config")
+ ):
+ yield model
+ return
+ # If it is a PEFT model, override the underlying base model
+ if hasattr(model, "get_base_model"):
+ model = model.get_base_model()
+ # Keep original model generation_config
+ original_config = model.generation_config
+ # Create training-specific generation config from the model's original generation config
+ # Then overwrite it with the training-specific generation kwargs
+ generation_config = GenerationConfig.from_dict(model.generation_config.to_dict())
+ generation_config.update(**generation_kwargs)
+ model.generation_config = generation_config
+ try:
+ yield
+ finally:
+ model.generation_config = original_config
+
+
+@contextmanager
+def unwrap_model_for_generation(
+ model: "DistributedDataParallel | DeepSpeedEngine",
+ accelerator: "Accelerator",
+ gather_deepspeed3_params: bool = True,
+ generation_kwargs: dict | None = None,
+):
+ """
+ Context manager to unwrap distributed or accelerated models for generation tasks.
+
+ This function unwraps distributed models (FSDP, DeepSpeed) and optionally overrides the model's generation_config
+ temporarily during generation. This is useful for applying training-specific generation parameters without
+ permanently modifying the model's original generation_config.
+
+ Args:
+ model (`DistributedDataParallel | DeepSpeedEngine`):
+ Model to be unwrapped.
+ accelerator ([`~accelerate.Accelerator`]):
+ Accelerator instance managing the model.
+ gather_deepspeed3_params (`bool`, *optional*, defaults to `True`):
+ Whether to gather weights for DeepSpeed ZeRO Stage 3 models. If `False`, skips parameter gathering, which
+ can be more memory-efficient but may lead to slower generation times.
+ generation_kwargs (dict, *optional*):
+ If provided, temporarily overrides the model's generation_config during generation. The original config is
+ automatically restored when exiting the context. This is useful for using different generation parameters
+ during training vs. inference.
+
+ Yields:
+ Unwrapped model with optionally overridden generation_config.
+ """
+ with (
+ _unwrap_model_for_generation(
+ model, accelerator, gather_deepspeed3_params=gather_deepspeed3_params
+ ) as unwrapped_model,
+ _override_model_generation_config(unwrapped_model, generation_kwargs=generation_kwargs),
+ ):
+ yield unwrapped_model
+
+
+def prepare_deepspeed(model: "Module", accelerator: "Accelerator"):
+ """Prepares the model for DeepSpeed inference or evaluation by initializing it with the appropriate configuration.
+
+ Adapted from accelerate:
+ https://github.com/huggingface/accelerate/blob/739b135f8367becb67ffaada12fe76e3aa60fefd/src/accelerate/accelerator.py#L1473
+ """
+ import deepspeed # local import (instead of top-level) to avoid DS init interfering with other backends (like vllm): https://github.com/deepspeedai/DeepSpeed/issues/7252
+
+ deepspeed_plugin = accelerator.state.deepspeed_plugin
+ config_kwargs = deepcopy(deepspeed_plugin.deepspeed_config)
+ stage = config_kwargs["zero_optimization"]["stage"]
+
+ if model is not None:
+ hidden_size = (
+ max(model.config.hidden_sizes)
+ if getattr(model.config, "hidden_sizes", None)
+ else getattr(model.config, "hidden_size", None)
+ )
+ if hidden_size is not None and stage == 3:
+ # Note that `stage3_prefetch_bucket_size` can produce DeepSpeed messages like: `Invalidate trace cache
+ # @ step 0: expected module 1, but got module 0`
+ # This is expected and is not an error, see: https://github.com/microsoft/DeepSpeed/discussions/4081
+ config_kwargs.update(
+ {
+ "zero_optimization.reduce_bucket_size": hidden_size * hidden_size,
+ "zero_optimization.stage3_param_persistence_threshold": 10 * hidden_size,
+ "zero_optimization.stage3_prefetch_bucket_size": 0.9 * hidden_size * hidden_size,
+ }
+ )
+
+ # If ZeRO-3 is used, we shard both the active and reference model.
+ # Otherwise, we assume the reference model fits in memory and is initialized on each device with ZeRO
+ # disabled (stage 0)
+ if stage != 3:
+ config_kwargs["zero_optimization"]["stage"] = 0
+ model, *_ = deepspeed.initialize(model=model, config=config_kwargs)
+ model.eval()
+ return model
+
+
+def prepare_fsdp(model, accelerator: Accelerator) -> FSDP | FSDPModule:
+ # Check if the model is already a FSDP model due to `Manual Wrapping` and if so, don't wrap it again
+ if not isinstance(model, (FSDP, FSDPModule)):
+ fsdp_plugin = accelerator.state.fsdp_plugin
+ if fsdp_plugin.fsdp_version == 1:
+ accelerator.state.fsdp_plugin.set_auto_wrap_policy(model)
+ kwargs = {
+ "sharding_strategy": fsdp_plugin.sharding_strategy or fsdp_plugin.reshard_after_forward,
+ "cpu_offload": fsdp_plugin.cpu_offload,
+ "auto_wrap_policy": fsdp_plugin.auto_wrap_policy,
+ "mixed_precision": fsdp_plugin.mixed_precision_policy,
+ "sync_module_states": fsdp_plugin.sync_module_states,
+ "backward_prefetch": fsdp_plugin.backward_prefetch,
+ "forward_prefetch": fsdp_plugin.forward_prefetch,
+ "use_orig_params": fsdp_plugin.use_orig_params,
+ "param_init_fn": fsdp_plugin.param_init_fn,
+ "ignored_modules": fsdp_plugin.ignored_modules,
+ "limit_all_gathers": fsdp_plugin.limit_all_gathers,
+ "device_id": accelerator.device,
+ }
+ model = FSDP(model, **kwargs)
+ elif fsdp_plugin.fsdp_version == 2:
+ from torch.distributed.fsdp import MixedPrecisionPolicy, fully_shard
+
+ mesh = getattr(accelerator, "torch_device_mesh", None)
+ if Version(accelerate.__version__) >= Version("1.11.0"):
+ ignored_params = get_parameters_from_modules(fsdp_plugin.ignored_modules, model, accelerator.device)
+ else:
+ warnings.warn(
+ "FSDP version 2 is being used with accelerate version < 1.11.0, which may lead to incorrect "
+ "handling of ignored modules. Please upgrade accelerate to v1.11.0 or later for proper support."
+ )
+ ignored_params = None
+ fully_shard(
+ model,
+ reshard_after_forward=fsdp_plugin.reshard_after_forward,
+ offload_policy=fsdp_plugin.cpu_offload,
+ # `fully_shard` doesn't accept `None` in case of `MixedPrecisionPolicy`
+ mp_policy=fsdp_plugin.mixed_precision_policy or MixedPrecisionPolicy(),
+ mesh=mesh[tuple(accelerator.parallelism_config.fsdp_dim_names)] if mesh is not None else None,
+ ignored_params=ignored_params,
+ )
+ else:
+ raise ValueError(f"FSDP version {fsdp_plugin.fsdp_version} is not supported.")
+ model.eval()
+ return model
+
+
+class _ForwardRedirection:
+ """Implements the `forward-redirection`.
+
+ Taken from Pytorch-lightning:
+ https://github.com/Lightning-AI/pytorch-lightning/blob/02311d03fb982560246eead7c08104481fac9579/src/lightning/pytorch/strategies/strategy.py#L602
+
+ A method call to a wrapped module gets rerouted through the wrapper's `forward` method instead.
+
+ """
+
+ def __call__(
+ self, wrapper_module: nn.Module, original_module: nn.Module, method: Callable, *args: Any, **kwargs: Any
+ ):
+ """Reroutes a method call through the `wrapper_module`'s `forward` method.
+
+ Args:
+ wrapper_module: The module that has `original_module` wrapped.
+ original_module: The module that was wrapped inside `wrapper_module`.
+ method: The method that should be called on the `original_module` after inputs get
+ redirected through the `wrapper_module`'s `forward` method.
+ *args: The positional arguments to the `method`. They will get passed to a patched
+ `forward` method instead.
+ **kwargs: The keyword arguments to the `method`. They will get passed to a patched
+ `forward` method instead.
+
+ """
+ original_forward = original_module.forward
+
+ def wrapped_forward(*_args: Any, **_kwargs: Any) -> Any:
+ # Unpatch ourselves immediately before calling the method `method_name`
+ # because itself may want to call the real `forward`
+ original_module.forward = original_forward # type: ignore[method-assign]
+ # Call the actual method e.g. `.training_step(...)`
+ out = method(*_args, **_kwargs)
+ self.on_after_inner_forward(wrapper_module, original_module)
+ return out
+
+ # Patch the original_module's forward so we can redirect the arguments back to the real method
+ original_module.forward = wrapped_forward # type: ignore[method-assign]
+
+ wrapper_output = wrapper_module(*args, **kwargs)
+ self.on_after_outer_forward(wrapper_module, original_module)
+ return wrapper_output
+
+ def on_after_inner_forward(self, wrapper_module: nn.Module, original_module: nn.Module) -> None:
+ pass
+
+ def on_after_outer_forward(self, wrapper_module: nn.Module, original_module: nn.Module) -> None:
+ pass
+
+
+@contextmanager
+def disable_gradient_checkpointing(model: PreTrainedModel, gradient_checkpointing_kwargs: dict | None = None):
+ """
+ Temporarily disable gradient checkpointing, restoring the previous state afterward.
+
+ Args:
+ model (`PreTrainedModel`):
+ Model for which to temporarily disable gradient checkpointing.
+ gradient_checkpointing_kwargs (`dict` or `None`, *optional*):
+ Additional kwargs for gradient checkpointing enabling.
+ """
+ was_enabled = model.is_gradient_checkpointing
+ if was_enabled:
+ model.gradient_checkpointing_disable()
+ try:
+ yield
+ finally:
+ if was_enabled:
+ model.gradient_checkpointing_enable(gradient_checkpointing_kwargs)
+
+
+def create_reference_model(
+ model: nn.Module, num_shared_layers: int | None = None, pattern: str | None = None
+) -> nn.Module:
+ warnings.warn(
+ "The `create_reference_model` function is now located in `trl.experimental.utils`. Please update your "
+ "imports to `from trl.experimental.utils import create_reference_model`. This import path will be removed in "
+ "TRL 1.0.0.",
+ FutureWarning,
+ stacklevel=2,
+ )
+ return _create_reference_model(model, num_shared_layers=num_shared_layers, pattern=pattern)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/py.typed b/tasks/tasksmith-03a6a091b12f/tests/source/trl/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/rewards/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/rewards/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0bf247a6f322cfdf78ef56f993b2d03ed49425b7
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/rewards/__init__.py
@@ -0,0 +1,35 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import sys
+from typing import TYPE_CHECKING
+
+from .._lazy_module import _LazyModule
+
+
+_import_structure = {
+ "accuracy_rewards": ["accuracy_reward", "get_cosine_scaled_reward", "reasoning_accuracy_reward"],
+ "format_rewards": ["think_format_reward"],
+ "other_rewards": ["get_repetition_penalty_reward", "get_soft_overlong_punishment"],
+}
+
+
+if TYPE_CHECKING:
+ from .accuracy_rewards import accuracy_reward, get_cosine_scaled_reward, reasoning_accuracy_reward
+ from .format_rewards import think_format_reward
+ from .other_rewards import get_repetition_penalty_reward, get_soft_overlong_punishment
+
+
+else:
+ sys.modules[__name__] = _LazyModule(__name__, __file__, _import_structure, module_spec=__spec__)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/rewards/accuracy_rewards.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/rewards/accuracy_rewards.py
new file mode 100644
index 0000000000000000000000000000000000000000..c78583c5ff060bc878ff973402660b19d76b0a92
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/rewards/accuracy_rewards.py
@@ -0,0 +1,350 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import math
+import threading
+from collections.abc import Callable
+
+from ..import_utils import is_math_verify_available
+
+
+if is_math_verify_available():
+ from latex2sympy2_extended import NormalizationConfig
+ from math_verify import LatexExtractionConfig, parse, verify
+
+
+def accuracy_reward(
+ completions: list[list[dict[str, str]]],
+ solution: list[str],
+ log_extra: Callable[[str, list], None] | None = None,
+ **kwargs,
+) -> list[float | None]:
+ r"""
+ Reward function that checks if the completion matches the ground truth.
+ - If both gold and prediction are parseable → use math verification.
+ - If gold is not parseable → return `None` to skip the example.
+
+ Args:
+ completions (`list[list[dict[str, str]]]`):
+ List of completions to be evaluated. Each completion must be a list of one message, i.e. a dictionary
+ containing the key `"content"` with the value being the text of the completion.
+ solution (`list[str]`):
+ List of the raw-text solutions to the questions/problems/prompts.
+ log_extra (`callable`, *optional*):
+ Callable to log extra columns to the completions table, provided automatically by the trainer. Defaults to
+ `None` to allow calling the function directly outside of a trainer (e.g., for testing).
+ **kwargs:
+ Additional keyword arguments. This function does not use them, but they are required in the function
+ signature to ensure compatibility with trainers like [`GRPOTrainer`].
+ Example:
+ ```python
+ >>> from trl.rewards import accuracy_reward
+
+ >>> solutions = [r"\frac{1}{3}", r"\frac{1}{3}"]
+ >>> completions = [
+ ... [{"role": "assistant", "content": r"My answer is \boxed{\frac{1}{3}}"}],
+ ... [{"role": "assistant", "content": r"My answer is \boxed{\frac{1}{2}}"}],
+ ... ]
+ >>> accuracy_reward(completions, solutions)
+ [1.0, 0.0]
+ ```
+ """
+ if not is_math_verify_available():
+ raise ImportError("Please install the `math_verify` package to use accuracy_reward")
+
+ contents = [completion[0]["content"] for completion in completions]
+ rewards = []
+ gold_parsed_strs = []
+ answer_parsed_strs = []
+
+ # math_verify uses signal.alarm() for timeouts, which only works in the main thread.
+ # Disable timeouts when running in a non-main thread to avoid ValueError.
+ is_main_thread = threading.current_thread() is threading.main_thread()
+ parsing_timeout = None if not is_main_thread else 10
+ verify_timeout = None if not is_main_thread else 5
+
+ # Suppress the "Timeout is disabled" warnings from math_verify when we intentionally disable timeouts
+ if not is_main_thread:
+ logging.getLogger("math_verify.parser").setLevel(logging.ERROR)
+ logging.getLogger("math_verify.grader").setLevel(logging.ERROR)
+
+ for content, sol in zip(contents, solution, strict=True):
+ gold_parsed = parse(sol, parsing_timeout=parsing_timeout)
+ if len(gold_parsed) != 0:
+ # We require the answer to be provided in correct latex (no malformed operators)
+ answer_parsed = parse(
+ content,
+ extraction_config=[
+ LatexExtractionConfig(
+ normalization_config=NormalizationConfig(units=True),
+ # Ensures that boxed is tried first
+ boxed_match_priority=0,
+ try_extract_without_anchor=False,
+ )
+ ],
+ extraction_mode="first_match",
+ parsing_timeout=parsing_timeout,
+ )
+ reward = float(verify(gold_parsed, answer_parsed, timeout_seconds=verify_timeout))
+ gold_parsed_strs.append(str(gold_parsed))
+ answer_parsed_strs.append(str(answer_parsed) if answer_parsed else "[unparseable]")
+ else:
+ # If the gold solution cannot be parsed, we assign `None` to skip this example
+ reward = None
+ gold_parsed_strs.append("[unparseable]")
+ answer_parsed_strs.append("[skipped]")
+ rewards.append(reward)
+
+ if log_extra is not None:
+ log_extra("solution", list(solution))
+ log_extra("gold_parsed", gold_parsed_strs)
+ log_extra("answer_parsed", answer_parsed_strs)
+
+ return rewards
+
+
+def get_cosine_scaled_reward(
+ max_len: int,
+ min_value_wrong: float = -1.0,
+ max_value_wrong: float = -0.5,
+ min_value_correct: float = 0.5,
+ max_value_correct: float = 1.0,
+) -> Callable:
+ # docstyle-ignore
+ r"""
+ Reward function that scales a correctness reward by the completion length following a cosine schedule, to favor
+ concise reasoning. Reference: Appendix C.1 of the "Demystifying Long Chain-of-Thought Reasoning" paper
+ (https://huggingface.co/papers/2502.03373).
+
+ Correctness is determined by math verification (as in [`~rewards.accuracy_reward`]), and the length is the number
+ of completion tokens. The reward interpolates along a cosine schedule between a short-completion and a
+ long-completion bound:
+
+ $$
+ R_{\text{cosine}}(y) = v_{\min} + \frac{1}{2}(v_{\max} - v_{\min})\left(1 + \cos\left(\frac{|y|}{L_{\max}}\pi\right)\right)
+ $$
+
+ For a **correct** completion, $(v_{\min}, v_{\max}) = (\texttt{min\_value\_correct}, \texttt{max\_value\_correct})$,
+ so a shorter completion is rewarded more. For a **wrong** completion, the bounds are swapped to
+ $(v_{\min}, v_{\max}) = (\texttt{max\_value\_wrong}, \texttt{min\_value\_wrong})$, so a shorter completion is
+ penalized more (a longer wrong completion is penalized less, preserving exploration). When the gold solution is not
+ parseable, the example is skipped (reward `None`), as in [`~rewards.accuracy_reward`].
+
+ Args:
+ max_len (`int`):
+ Maximum completion length (in tokens) used to normalize the cosine schedule, $L_{\max}$.
+ min_value_wrong (`float`, *optional*, defaults to `-1.0`):
+ Reward of a wrong completion at the shortest length.
+ max_value_wrong (`float`, *optional*, defaults to `-0.5`):
+ Reward of a wrong completion at the longest length.
+ min_value_correct (`float`, *optional*, defaults to `0.5`):
+ Reward of a correct completion at the longest length.
+ max_value_correct (`float`, *optional*, defaults to `1.0`):
+ Reward of a correct completion at the shortest length.
+
+ Returns:
+ `Callable`:
+ A reward function that takes completions, their solutions and token ids, and returns a list of rewards
+ (`None` for examples with an unparseable gold solution).
+
+ Example:
+ ```python
+ >>> from trl.rewards import get_cosine_scaled_reward
+
+ >>> cosine_scaled_reward = get_cosine_scaled_reward(max_len=100)
+ >>> completions = [[{"content": r"\boxed{\frac{1}{3}}"}], [{"content": r"\boxed{\frac{1}{2}}"}]]
+ >>> solution = [r"\frac{1}{3}", r"\frac{1}{3}"]
+ >>> completion_ids = [[1] * 50, [1] * 50] # both completions are 50 tokens, half of max_len
+ >>> cosine_scaled_reward(completions, solution, completion_ids)
+ [0.75, -0.75]
+ ```
+ """
+ return _CosineScaledReward(max_len, min_value_wrong, max_value_wrong, min_value_correct, max_value_correct)
+
+
+class _CosineScaledReward:
+ # Callable class rather than a closure so the reward stays picklable: the async GRPO rollout
+ # worker forwards reward funcs to a spawned child process, and closures can't be pickled.
+ __name__ = "cosine_scaled_reward"
+
+ def __init__(
+ self,
+ max_len: int,
+ min_value_wrong: float,
+ max_value_wrong: float,
+ min_value_correct: float,
+ max_value_correct: float,
+ ):
+ self.max_len = max_len
+ self.min_value_wrong = min_value_wrong
+ self.max_value_wrong = max_value_wrong
+ self.min_value_correct = min_value_correct
+ self.max_value_correct = max_value_correct
+
+ def __call__(
+ self,
+ completions: list[list[dict[str, str]]],
+ solution: list[str],
+ completion_ids: list[list[int]],
+ **kwargs,
+ ) -> list[float | None]:
+ is_correct = accuracy_reward(completions, solution)
+ rewards = []
+ for correct, ids in zip(is_correct, completion_ids, strict=True):
+ if correct is None:
+ # Gold solution was not parseable; skip the example, as in accuracy_reward.
+ rewards.append(None)
+ continue
+ # Clamp to 1.0 so completions longer than max_len stay at the long-length bound: cos is periodic, so
+ # without clamping the schedule would climb back up past max_len and reward very long completions.
+ progress = min(len(ids) / self.max_len, 1.0)
+ cosine = math.cos(progress * math.pi)
+ if correct:
+ min_value, max_value = self.min_value_correct, self.max_value_correct
+ else:
+ # Swap the bounds so that a shorter wrong completion is penalized more than a longer one.
+ min_value, max_value = self.max_value_wrong, self.min_value_wrong
+ rewards.append(float(min_value + 0.5 * (max_value - min_value) * (1.0 + cosine)))
+ return rewards
+
+
+def reasoning_accuracy_reward(
+ completions: list[list[dict[str, str]]],
+ solution: list[str],
+ reasoning_delimiters: list[str] | None = None,
+ log_extra: Callable[[str, list], None] | None = None,
+ **kwargs,
+) -> list[float | None]:
+ r"""
+ Reward function that removes the reasoning content and checks if the final answer matches the ground truth.
+ - If both gold and prediction are parseable → use math verification.
+ - If gold is not parseable → return `None` to skip the example.
+
+ Args:
+ completions (`list[list[dict[str, str]]]`):
+ List of completions to be evaluated. Each completion must be a list of one message, i.e. a dictionary
+ containing the key `"content"` with the value being the text of the completion.
+ solution (`list[str]`):
+ List of the raw-text solutions to the questions/problems/prompts.
+ reasoning_delimiters (`list[str]]`, *optional*):
+ List of strings indicating where the reasoning content ends. The final answer is assumed to be after the
+ last occurrence of any of these delimiters. If `None`, defaults to `[""]`.
+ log_extra (`callable`, *optional*):
+ Callable to log extra columns to the completions table, provided automatically by the trainer. Defaults to
+ `None` to allow calling the function directly outside of a trainer (e.g., for testing).
+ **kwargs:
+ Additional keyword arguments. This function does not use them, but they are required in the function
+ signature to ensure compatibility with trainers like [`GRPOTrainer`].
+ Example:
+ ```python
+ >>> from trl.rewards import reasoning_accuracy_reward
+
+ >>> reasoning_delimiters = [""]
+ >>> solutions = [r"\frac{1}{3}", r"\frac{1}{3}", r"\frac{1}{3}"]
+ >>> completions = [
+ ... [
+ ... {
+ ... "role": "assistant",
+ ... "content": r" Reasoning content The final answer is \boxed{\frac{1}{3}}",
+ ... }
+ ... ],
+ ... [
+ ... {
+ ... "role": "assistant",
+ ... "content": r" Reasoning content The final answer is \boxed{\frac{1}{2}}",
+ ... }
+ ... ],
+ ... [
+ ... {
+ ... "role": "assistant",
+ ... "content": r" Reasoning content with partial answers \boxed{\frac{1}{3}} but no final answer",
+ ... }
+ ... ],
+ ... ]
+ >>> reasoning_accuracy_reward(completions, solutions, reasoning_delimiters=reasoning_delimiters)
+ [1.0, 0.0, 0.0]
+ ```
+ """
+ if not is_math_verify_available():
+ raise ImportError("Please install the `math_verify` package to use reasoning_accuracy_reward")
+
+ if reasoning_delimiters is None:
+ # Use sensible defaults for majority of reasoning models
+ reasoning_delimiters = [""]
+
+ rewards = []
+ contents = [completion[0]["content"] for completion in completions]
+ gold_parsed_strs = []
+ answer_parsed_strs = []
+
+ # math_verify uses signal.alarm() for timeouts, which only works in the main thread.
+ # Disable timeouts when running in a non-main thread to avoid ValueError.
+ is_main_thread = threading.current_thread() is threading.main_thread()
+ parsing_timeout = None if not is_main_thread else 10
+ verify_timeout = None if not is_main_thread else 5
+
+ # Suppress the "Timeout is disabled" warnings from math_verify when we intentionally disable timeouts
+ if not is_main_thread:
+ logging.getLogger("math_verify.parser").setLevel(logging.ERROR)
+ logging.getLogger("math_verify.grader").setLevel(logging.ERROR)
+
+ for content, sol in zip(contents, solution, strict=True):
+ # Split final answer from reasoning content
+ is_reasoning_complete = False
+ for delim in reasoning_delimiters:
+ if delim in content:
+ content = content.split(delim)[-1]
+ is_reasoning_complete = True
+ break
+ if not is_reasoning_complete:
+ # We assign zero reward instead of `None` to penalize incomplete reasoning
+ rewards.append(0.0)
+ gold_parsed_strs.append("[incomplete reasoning]")
+ answer_parsed_strs.append("[incomplete reasoning]")
+ continue
+
+ gold_parsed = parse(sol, parsing_timeout=parsing_timeout)
+ if len(gold_parsed) != 0:
+ # We require the answer to be provided in correct latex (no malformed operators)
+ answer_parsed = parse(
+ content,
+ extraction_config=[
+ LatexExtractionConfig(
+ boxed_match_priority=0,
+ normalization_config=NormalizationConfig(
+ units=True,
+ ),
+ try_extract_without_anchor=False,
+ )
+ ],
+ extraction_mode="first_match",
+ parsing_timeout=parsing_timeout,
+ )
+ reward = float(verify(gold_parsed, answer_parsed, timeout_seconds=verify_timeout))
+ gold_parsed_strs.append(str(gold_parsed))
+ answer_parsed_strs.append(str(answer_parsed) if answer_parsed else "[unparseable]")
+ else:
+ # If the gold solution cannot be parsed, we assign `None` to skip this example
+ reward = None
+ gold_parsed_strs.append("[unparseable]")
+ answer_parsed_strs.append("[skipped]")
+ rewards.append(reward)
+
+ if log_extra is not None:
+ log_extra("solution", list(solution))
+ log_extra("gold_parsed", gold_parsed_strs)
+ log_extra("answer_parsed", answer_parsed_strs)
+
+ return rewards
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/rewards/format_rewards.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/rewards/format_rewards.py
new file mode 100644
index 0000000000000000000000000000000000000000..c737d0036b165ebf4a15e2c2558f82187e87038d
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/rewards/format_rewards.py
@@ -0,0 +1,50 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import re
+
+
+def think_format_reward(completions: list[list[dict[str, str]]], **kwargs) -> list[float]:
+ r"""
+ Reward function that checks if the reasoning process is enclosed within `""` and `""` tags. The
+ function returns a reward of 1.0 if the format is correct, otherwise 0.0.
+
+ Args:
+ completions (`list[list[dict[str, str]]]`):
+ List of completions to be evaluated. Each completion must be a list of one message, i.e. a dictionary
+ containing the key `"content"` with the value being the text of the completion.
+ **kwargs:
+ Additional keyword arguments. This function does not use them, but they are required in the function
+ signature to ensure compatibility with trainers like [`GRPOTrainer`].
+
+ Returns:
+ `list[float]`:
+ A list of rewards, where each reward is 1.0 if the completion matches the expected format, otherwise 0.0.
+
+ Example:
+ ```python
+ >>> from trl.rewards import think_format_reward
+
+ >>> completions = [
+ ... [{"content": "\nThis is my reasoning.\n\nThis is my answer."}],
+ ... [{"content": "\nThis is my reasoning.\nThis is my answer."}],
+ ... ]
+ >>> think_format_reward(completions)
+ [1.0, 0.0]
+ ```
+ """
+ pattern = r"^(?!.*)(.*?).*$"
+ completion_contents = [completion[0]["content"] for completion in completions]
+ matches = [re.match(pattern, content, re.DOTALL | re.MULTILINE) for content in completion_contents]
+ return [1.0 if match else 0.0 for match in matches]
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/rewards/other_rewards.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/rewards/other_rewards.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0a81870b813e51224979e67a5f53e074cbfe21a
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/rewards/other_rewards.py
@@ -0,0 +1,138 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections.abc import Callable
+
+
+def get_repetition_penalty_reward(ngram_size: int = 3, max_penalty: float = -1.0) -> Callable:
+ # docstyle-ignore
+ r"""
+ Reward function that penalizes repeated n-grams in a completion, used to discourage degenerate, repetitive text
+ (a common failure mode and reward-hacking strategy when length- or format-shaping rewards are used). Reference:
+ Appendix C.2 of the "Demystifying Long Chain-of-Thought Reasoning" paper (https://huggingface.co/papers/2502.03373).
+
+ The penalty is proportional to the fraction of repeated n-grams in the completion:
+
+ $$
+ R_{\text{repetition}}(y) = \left(1 - \frac{\#\,\text{unique } n\text{-grams}}{\#\,\text{total } n\text{-grams}}\right) \times p
+ $$
+
+ where $p$ is `max_penalty`. A completion with no repeated n-gram gets a reward of `0.0`, while a fully repetitive
+ one approaches `max_penalty`. The n-grams are computed over the completion token ids (the paper applies the penalty
+ to repeated tokens), so the reward is tokenizer-defined and language-agnostic. Completions with fewer than
+ `ngram_size` tokens get a reward of `0.0`.
+
+ Args:
+ ngram_size (`int`, *optional*, defaults to `3`):
+ Size of the token n-grams to consider.
+ max_penalty (`float`, *optional*, defaults to `-1.0`):
+ Most negative penalty, applied to a fully repetitive completion. Must be non-positive.
+
+ Returns:
+ `Callable`:
+ A reward function that takes a list of completion token ids and returns a list of penalties (each in
+ `[max_penalty, 0.0]`).
+
+ Example:
+ ```python
+ >>> from trl.rewards import get_repetition_penalty_reward
+
+ >>> repetition_penalty = get_repetition_penalty_reward(ngram_size=2, max_penalty=-1.0)
+ >>> completion_ids = [[1, 2, 3, 4], [5, 5, 5, 5, 5]]
+ >>> repetition_penalty(completion_ids)
+ [0.0, -0.75]
+ ```
+ """
+ if max_penalty > 0:
+ raise ValueError(f"max_penalty {max_penalty} should not be positive")
+ return _RepetitionPenalty(ngram_size, max_penalty)
+
+
+class _RepetitionPenalty:
+ # Callable class rather than a closure so the reward stays picklable: the async GRPO rollout
+ # worker forwards reward funcs to a spawned child process, and closures can't be pickled.
+ __name__ = "repetition_penalty_reward"
+
+ def __init__(self, ngram_size: int, max_penalty: float):
+ self.ngram_size = ngram_size
+ self.max_penalty = max_penalty
+
+ def __call__(self, completion_ids: list[list[int]], **kwargs) -> list[float]:
+ rewards = []
+ for ids in completion_ids:
+ if len(ids) < self.ngram_size:
+ rewards.append(0.0)
+ continue
+ ngrams = list(zip(*[ids[i:] for i in range(self.ngram_size)], strict=False))
+ scaling = 1 - len(set(ngrams)) / len(ngrams)
+ rewards.append(scaling * self.max_penalty if scaling else 0.0)
+ return rewards
+
+
+def get_soft_overlong_punishment(max_completion_len: int, soft_punish_cache: int) -> Callable:
+ # docstyle-ignore
+ r"""
+ Reward function that penalizes overlong completions. It is used to penalize overlong completions, but not to reward
+ shorter completions. Reference: Eq. (13) from the DAPO paper (https://huggingface.co/papers/2503.14476)
+
+ $$
+ R_{\text{length}}(y) = \begin{cases}
+ 0, & |y| \le L_{\max} - L_{\text{cache}} \\
+ \dfrac{(L_{\max} - L_{\text{cache}}) - |y|}{L_{\text{cache}}}, & L_{\max} - L_{\text{cache}} < |y| \le L_{\max} \\
+ -1, & L_{\max} < |y|
+ \end{cases}
+ $$
+
+ Args:
+ max_completion_len (`int`):
+ Maximum length of the completion, \( L_{\max} \).
+ soft_punish_cache (`int`):
+ Minimum length of the completion, \( L_{\text{cache}} \). If set to `0`, no minimum length is applied.
+
+ Example:
+ ```python
+ from trl.rewards import get_soft_overlong_punishment
+
+ soft_overlong_punishment = get_soft_overlong_punishment(max_completion_len=100, soft_punish_cache=20)
+ completion_ids = [[1] * 90] # simulating a completion with 90 tokens. 90 is between 80 and 100.
+ rewards = soft_overlong_punishment(completion_ids)
+ print(rewards) # [-0.5]
+ ```
+ """
+ return _SoftOverlongPunishment(max_completion_len, soft_punish_cache)
+
+
+class _SoftOverlongPunishment:
+ # Callable class rather than a closure so the reward stays picklable: the async GRPO rollout
+ # worker forwards reward funcs to a spawned child process, and closures can't be pickled.
+ # `__name__` mirrors the old inner-function name so metric logging keys are unchanged.
+ __name__ = "soft_overlong_punishment_reward"
+
+ def __init__(self, max_completion_len: int, soft_punish_cache: int):
+ self.max_completion_len = max_completion_len
+ self.soft_punish_cache = soft_punish_cache
+
+ def __call__(self, completion_ids: list[list[int]], **kwargs) -> list[float]:
+ rewards = []
+ for ids in completion_ids:
+ completion_length = len(ids)
+ if completion_length <= self.max_completion_len - self.soft_punish_cache:
+ rewards.append(0.0)
+ elif self.max_completion_len - self.soft_punish_cache < completion_length <= self.max_completion_len:
+ rewards.append(
+ (self.max_completion_len - self.soft_punish_cache - completion_length) / self.soft_punish_cache
+ )
+ else:
+ rewards.append(-1.0)
+ return rewards
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb15e6cdfe5446affd20a72cd22a8c74c6f15e1e
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/__init__.py
@@ -0,0 +1,29 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import TYPE_CHECKING
+
+from .._lazy_module import _LazyModule
+
+
+_import_structure = {
+ "utils": ["DatasetMixtureConfig", "ScriptArguments", "TrlParser", "get_dataset", "init_zero_verbose"],
+}
+
+if TYPE_CHECKING:
+ from .utils import DatasetMixtureConfig, ScriptArguments, TrlParser, get_dataset, init_zero_verbose
+else:
+ import sys
+
+ sys.modules[__name__] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/_hf_argparser.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/_hf_argparser.py
new file mode 100644
index 0000000000000000000000000000000000000000..f6b214154404dcc5f23791a577bdef85ac263eba
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/_hf_argparser.py
@@ -0,0 +1,454 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# Copied from: https://github.com/huggingface/transformers/blob/3a275d3581c0ecf962f7412aa764c2047331fd6b/src/transformers/hf_argparser.py
+# This avoids an upstream latency issue: https://github.com/huggingface/transformers/issues/44273
+# - Moved yaml import inside function
+
+
+import dataclasses
+import json
+import os
+import sys
+import types
+from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser, ArgumentTypeError
+from collections.abc import Callable, Iterable
+from copy import copy
+from enum import Enum
+from inspect import isclass
+from pathlib import Path
+from typing import Any, Literal, NewType, Union, get_type_hints
+
+
+DataClass = NewType("DataClass", Any)
+DataClassType = NewType("DataClassType", Any)
+
+
+# From https://stackoverflow.com/questions/15008758/parsing-boolean-values-with-argparse
+def string_to_bool(v):
+ if isinstance(v, bool):
+ return v
+ if v.lower() in ("yes", "true", "t", "y", "1"):
+ return True
+ elif v.lower() in ("no", "false", "f", "n", "0"):
+ return False
+ else:
+ raise ArgumentTypeError(
+ f"Truthy value expected: got {v} but expected one of yes/no, true/false, t/f, y/n, 1/0 (case insensitive)."
+ )
+
+
+def _accept_none(inner: Callable[[str], Any]) -> Callable[[str], Any]:
+ """Wrap a type converter so `'none'` and `'null'` (case-insensitive) parse to Python `None`.
+
+ Used for `T | None` fields so they can be set to `None` from the CLI (argparse's `type=int` rejects `'None'`).
+ Mirrors the case-insensitive convention of [`string_to_bool`].
+ """
+
+ def parse(v: str) -> Any:
+ if v.lower() in ("none", "null"):
+ return None
+ return inner(v)
+
+ parse.__name__ = getattr(inner, "__name__", "value") # so argparse error messages keep the inner type name
+ return parse
+
+
+def make_choice_type_function(choices: list) -> Callable[[str], Any]:
+ """
+ Creates a mapping function from each choices string representation to the actual value. Used to support multiple
+ value types for a single argument.
+
+ Args:
+ choices (list): List of choices.
+
+ Returns:
+ Callable[[str], Any]: Mapping function from string representation to actual value for each choice.
+ """
+ str_to_choice = {str(choice): choice for choice in choices}
+ return lambda arg: str_to_choice.get(arg, arg)
+
+
+def HfArg(
+ *,
+ aliases: str | list[str] | None = None,
+ help: str | None = None,
+ default: Any = dataclasses.MISSING,
+ default_factory: Callable[[], Any] = dataclasses.MISSING,
+ metadata: dict | None = None,
+ **kwargs,
+) -> dataclasses.Field:
+ """Argument helper enabling a concise syntax to create dataclass fields for parsing with `HfArgumentParser`.
+
+ Example comparing the use of `HfArg` and `dataclasses.field`:
+ ```
+ @dataclass
+ class Args:
+ regular_arg: str = dataclasses.field(default="Huggingface", metadata={"aliases": ["--example", "-e"], "help": "This syntax could be better!"})
+ hf_arg: str = HfArg(default="Huggingface", aliases=["--example", "-e"], help="What a nice syntax!")
+ ```
+
+ Args:
+ aliases (Union[str, list[str]], *optional*):
+ Single string or list of strings of aliases to pass on to argparse, e.g. `aliases=["--example", "-e"]`.
+ Defaults to None.
+ help (str, *optional*):
+ Help string to pass on to argparse that can be displayed with --help. Defaults to None.
+ default (Any, *optional*):
+ Default value for the argument. If not default or default_factory is specified, the argument is required.
+ Defaults to dataclasses.MISSING.
+ default_factory (Callable[[], Any], *optional*):
+ The default_factory is a 0-argument function called to initialize a field's value. It is useful to provide
+ default values for mutable types, e.g. lists: `default_factory=list`. Mutually exclusive with `default=`.
+ Defaults to dataclasses.MISSING.
+ metadata (dict, *optional*): Further metadata to pass on to `dataclasses.field`. Defaults to None.
+
+ Returns:
+ Field: A `dataclasses.Field` with the desired properties.
+ """
+ if metadata is None:
+ # Important, don't use as default param in function signature because dict is mutable and shared across function calls
+ metadata = {}
+ if aliases is not None:
+ metadata["aliases"] = aliases
+ if help is not None:
+ metadata["help"] = help
+
+ return dataclasses.field(metadata=metadata, default=default, default_factory=default_factory, **kwargs)
+
+
+class HfArgumentParser(ArgumentParser):
+ """
+ This subclass of `argparse.ArgumentParser` uses type hints on dataclasses to generate arguments.
+
+ The class is designed to play well with the native argparse. In particular, you can add more (non-dataclass backed)
+ arguments to the parser after initialization and you'll get the output back after parsing as an additional
+ namespace. Optional: To create sub argument groups use the `_argument_group_name` attribute in the dataclass.
+
+ Args:
+ dataclass_types (`DataClassType` or `Iterable[DataClassType]`, *optional*):
+ Dataclass type, or list of dataclass types for which we will "fill" instances with the parsed args.
+ kwargs (`dict[str, Any]`, *optional*):
+ Passed to `argparse.ArgumentParser()` in the regular way.
+ """
+
+ dataclass_types: Iterable[DataClassType]
+
+ def __init__(self, dataclass_types: DataClassType | Iterable[DataClassType] | None = None, **kwargs):
+ # Make sure dataclass_types is an iterable
+ if dataclass_types is None:
+ dataclass_types = []
+ elif not isinstance(dataclass_types, Iterable):
+ dataclass_types = [dataclass_types]
+
+ # To make the default appear when using --help
+ if "formatter_class" not in kwargs:
+ kwargs["formatter_class"] = ArgumentDefaultsHelpFormatter
+ super().__init__(**kwargs)
+ if dataclasses.is_dataclass(dataclass_types):
+ dataclass_types = [dataclass_types]
+ self.dataclass_types = list(dataclass_types)
+ for dtype in self.dataclass_types:
+ self._add_dataclass_arguments(dtype)
+
+ @staticmethod
+ def _parse_dataclass_field(parser: ArgumentParser, field: dataclasses.Field):
+ # Long-option strings are conventionlly separated by hyphens rather
+ # than underscores, e.g., "--long-format" rather than "--long_format".
+ # Argparse converts hyphens to underscores so that the destination
+ # string is a valid attribute name. Hf_argparser should do the same.
+ long_options = [f"--{field.name}"]
+ if "_" in field.name:
+ long_options.append(f"--{field.name.replace('_', '-')}")
+
+ kwargs = field.metadata.copy()
+ # field.metadata is not used at all by Data Classes,
+ # it is provided as a third-party extension mechanism.
+ if isinstance(field.type, str):
+ raise RuntimeError(
+ "Unresolved type detected, which should have been done with the help of "
+ "`typing.get_type_hints` method by default"
+ )
+
+ aliases = kwargs.pop("aliases", [])
+ if isinstance(aliases, str):
+ aliases = [aliases]
+
+ origin_type = getattr(field.type, "__origin__", field.type)
+ accepts_none = False
+ if origin_type is Union or (hasattr(types, "UnionType") and isinstance(origin_type, types.UnionType)):
+ if str not in field.type.__args__ and (
+ len(field.type.__args__) != 2 or type(None) not in field.type.__args__
+ ):
+ raise ValueError(
+ "Only `Union[X, NoneType]` (i.e., `Optional[X]`) is allowed for `Union` because"
+ " the argument parser only supports one type per argument."
+ f" Problem encountered in field '{field.name}'."
+ )
+ if type(None) not in field.type.__args__:
+ # filter `str` in Union
+ field.type = field.type.__args__[0] if field.type.__args__[1] is str else field.type.__args__[1]
+ origin_type = getattr(field.type, "__origin__", field.type)
+ elif bool not in field.type.__args__:
+ # filter `NoneType` in Union (except for `Union[bool, NoneType]`)
+ field.type = (
+ field.type.__args__[0] if isinstance(None, field.type.__args__[1]) else field.type.__args__[1]
+ )
+ origin_type = getattr(field.type, "__origin__", field.type)
+ # Enable the `'none'`/`'null'` sentinel only when the inner type can't possibly accept those as
+ # legitimate string values (i.e. anything non-str). For str-typed fields, `'none'` may be a real
+ # value — e.g. `report_to`, whose CLI string `'none'` means "no integrations" downstream.
+ accepts_none = field.type is not str
+
+ # A variable to store kwargs for a boolean field, if needed
+ # so that we can init a `no_*` complement argument (see below)
+ bool_kwargs = {}
+ if origin_type is Literal or (isinstance(field.type, type) and issubclass(field.type, Enum)):
+ if origin_type is Literal:
+ kwargs["choices"] = field.type.__args__
+ else:
+ kwargs["choices"] = [x.value for x in field.type]
+
+ kwargs["type"] = make_choice_type_function(kwargs["choices"])
+
+ if field.default is not dataclasses.MISSING:
+ kwargs["default"] = field.default
+ else:
+ kwargs["required"] = True
+ elif field.type is bool or field.type == bool | None:
+ # Copy the correct kwargs to use to instantiate a `no_*` complement argument below.
+ # We do not initialize it here because the `no_*` alternative must be instantiated after the real argument
+ bool_kwargs = copy(kwargs)
+
+ # Hack because type=bool in argparse does not behave as we want.
+ kwargs["type"] = string_to_bool
+ if field.type is bool or (field.default is not None and field.default is not dataclasses.MISSING):
+ # Default value is False if we have no default when of type bool.
+ default = False if field.default is dataclasses.MISSING else field.default
+ # This is the value that will get picked if we don't include --{field.name} in any way
+ kwargs["default"] = default
+ # This tells argparse we accept 0 or 1 value after --{field.name}
+ kwargs["nargs"] = "?"
+ # This is the value that will get picked if we do --{field.name} (without value)
+ kwargs["const"] = True
+ elif isclass(origin_type) and issubclass(origin_type, list):
+ kwargs["type"] = field.type.__args__[0]
+ kwargs["nargs"] = "+"
+ if field.default_factory is not dataclasses.MISSING:
+ kwargs["default"] = field.default_factory()
+ elif field.default is dataclasses.MISSING:
+ kwargs["required"] = True
+ else:
+ kwargs["type"] = _accept_none(field.type) if accepts_none else field.type
+ if field.default is not dataclasses.MISSING:
+ kwargs["default"] = field.default
+ elif field.default_factory is not dataclasses.MISSING:
+ kwargs["default"] = field.default_factory()
+ else:
+ kwargs["required"] = True
+ parser.add_argument(*long_options, *aliases, **kwargs)
+
+ # Add a complement `no_*` argument for a boolean field AFTER the initial field has already been added.
+ # Order is important for arguments with the same destination!
+ # We use a copy of earlier kwargs because the original kwargs have changed a lot before reaching down
+ # here and we do not need those changes/additional keys.
+ if field.default is True and (field.type is bool or field.type == bool | None):
+ bool_kwargs["default"] = False
+ parser.add_argument(
+ f"--no_{field.name}",
+ f"--no-{field.name.replace('_', '-')}",
+ action="store_false",
+ dest=field.name,
+ **bool_kwargs,
+ )
+
+ def _add_dataclass_arguments(self, dtype: DataClassType):
+ if hasattr(dtype, "_argument_group_name"):
+ parser = self.add_argument_group(dtype._argument_group_name)
+ else:
+ parser = self
+
+ try:
+ type_hints: dict[str, type] = get_type_hints(dtype)
+ except NameError:
+ raise RuntimeError(
+ f"Type resolution failed for {dtype}. Try declaring the class in global scope or "
+ "removing line of `from __future__ import annotations` which opts in Postponed "
+ "Evaluation of Annotations (PEP 563)"
+ ) from None
+
+ for field in dataclasses.fields(dtype):
+ if not field.init:
+ continue
+ field.type = type_hints[field.name]
+ self._parse_dataclass_field(parser, field)
+
+ def parse_args_into_dataclasses(
+ self,
+ args=None,
+ return_remaining_strings=False,
+ look_for_args_file=True,
+ args_filename=None,
+ args_file_flag=None,
+ ) -> tuple[DataClass, ...]:
+ """
+ Parse command-line args into instances of the specified dataclass types.
+
+ This relies on argparse's `ArgumentParser.parse_known_args`. See the doc at:
+ docs.python.org/3/library/argparse.html#argparse.ArgumentParser.parse_args
+
+ Args:
+ args:
+ List of strings to parse. The default is taken from sys.argv. (same as argparse.ArgumentParser)
+ return_remaining_strings:
+ If true, also return a list of remaining argument strings.
+ look_for_args_file:
+ If true, will look for a ".args" file with the same base name as the entry point script for this
+ process, and will append its potential content to the command line args.
+ args_filename:
+ If not None, will uses this file instead of the ".args" file specified in the previous argument.
+ args_file_flag:
+ If not None, will look for a file in the command-line args specified with this flag. The flag can be
+ specified multiple times and precedence is determined by the order (last one wins).
+
+ Returns:
+ Tuple consisting of:
+
+ - the dataclass instances in the same order as they were passed to the initializer.abspath
+ - if applicable, an additional namespace for more (non-dataclass backed) arguments added to the parser
+ after initialization.
+ - The potential list of remaining argument strings. (same as argparse.ArgumentParser.parse_known_args)
+ """
+
+ if args_file_flag or args_filename or (look_for_args_file and len(sys.argv)):
+ args_files = []
+
+ if args_filename:
+ args_files.append(Path(args_filename))
+ elif look_for_args_file and len(sys.argv):
+ args_files.append(Path(sys.argv[0]).with_suffix(".args"))
+
+ # args files specified via command line flag should overwrite default args files so we add them last
+ if args_file_flag:
+ # Create special parser just to extract the args_file_flag values
+ args_file_parser = ArgumentParser()
+ args_file_parser.add_argument(args_file_flag, type=str, action="append")
+
+ # Use only remaining args for further parsing (remove the args_file_flag)
+ cfg, args = args_file_parser.parse_known_args(args=args)
+ cmd_args_file_paths = vars(cfg).get(args_file_flag.lstrip("-"), None)
+
+ if cmd_args_file_paths:
+ args_files.extend([Path(p) for p in cmd_args_file_paths])
+
+ file_args = []
+ for args_file in args_files:
+ if args_file.exists():
+ file_args += args_file.read_text().split()
+
+ # in case of duplicate arguments the last one has precedence
+ # args specified via the command line should overwrite args from files, so we add them last
+ args = file_args + args if args is not None else file_args + sys.argv[1:]
+ namespace, remaining_args = self.parse_known_args(args=args)
+ outputs = []
+ for dtype in self.dataclass_types:
+ keys = {f.name for f in dataclasses.fields(dtype) if f.init}
+ inputs = {k: v for k, v in vars(namespace).items() if k in keys}
+ for k in keys:
+ delattr(namespace, k)
+ obj = dtype(**inputs)
+ outputs.append(obj)
+ if len(namespace.__dict__) > 0:
+ # additional namespace.
+ outputs.append(namespace)
+ if return_remaining_strings:
+ return (*outputs, remaining_args)
+ else:
+ if remaining_args:
+ raise ValueError(f"Some specified arguments are not used by the HfArgumentParser: {remaining_args}")
+
+ return (*outputs,)
+
+ def parse_dict(self, args: dict[str, Any], allow_extra_keys: bool = False) -> tuple[DataClass, ...]:
+ """
+ Alternative helper method that does not use `argparse` at all, instead uses a dict and populating the dataclass
+ types.
+
+ Args:
+ args (`dict`):
+ dict containing config values
+ allow_extra_keys (`bool`, *optional*, defaults to `False`):
+ Defaults to False. If False, will raise an exception if the dict contains keys that are not parsed.
+
+ Returns:
+ Tuple consisting of:
+
+ - the dataclass instances in the same order as they were passed to the initializer.
+ """
+ unused_keys = set(args.keys())
+ outputs = []
+ for dtype in self.dataclass_types:
+ keys = {f.name for f in dataclasses.fields(dtype) if f.init}
+ inputs = {k: v for k, v in args.items() if k in keys}
+ unused_keys.difference_update(inputs.keys())
+ obj = dtype(**inputs)
+ outputs.append(obj)
+ if not allow_extra_keys and unused_keys:
+ raise ValueError(f"Some keys are not used by the HfArgumentParser: {sorted(unused_keys)}")
+ return tuple(outputs)
+
+ def parse_json_file(self, json_file: str | os.PathLike, allow_extra_keys: bool = False) -> tuple[DataClass, ...]:
+ """
+ Alternative helper method that does not use `argparse` at all, instead loading a json file and populating the
+ dataclass types.
+
+ Args:
+ json_file (`str` or `os.PathLike`):
+ File name of the json file to parse
+ allow_extra_keys (`bool`, *optional*, defaults to `False`):
+ Defaults to False. If False, will raise an exception if the json file contains keys that are not
+ parsed.
+
+ Returns:
+ Tuple consisting of:
+
+ - the dataclass instances in the same order as they were passed to the initializer.
+ """
+ with open(Path(json_file), encoding="utf-8") as open_json_file:
+ data = json.loads(open_json_file.read())
+ outputs = self.parse_dict(data, allow_extra_keys=allow_extra_keys)
+ return tuple(outputs)
+
+ def parse_yaml_file(self, yaml_file: str | os.PathLike, allow_extra_keys: bool = False) -> tuple[DataClass, ...]:
+ """
+ Alternative helper method that does not use `argparse` at all, instead loading a yaml file and populating the
+ dataclass types.
+
+ Args:
+ yaml_file (`str` or `os.PathLike`):
+ File name of the yaml file to parse
+ allow_extra_keys (`bool`, *optional*, defaults to `False`):
+ Defaults to False. If False, will raise an exception if the json file contains keys that are not
+ parsed.
+
+ Returns:
+ Tuple consisting of:
+
+ - the dataclass instances in the same order as they were passed to the initializer.
+ """
+ import yaml
+
+ outputs = self.parse_dict(yaml.safe_load(Path(yaml_file).read_text()), allow_extra_keys=allow_extra_keys)
+ return tuple(outputs)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/dpo.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/dpo.py
new file mode 100644
index 0000000000000000000000000000000000000000..5303906dcef18a954af4ac0f18d48c27aa4d1e1a
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/dpo.py
@@ -0,0 +1,146 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "peft",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+# Full training
+```bash
+python trl/scripts/dpo.py \
+ --dataset_name trl-lib/ultrafeedback_binarized \
+ --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
+ --learning_rate 5.0e-7 \
+ --num_train_epochs 1 \
+ --per_device_train_batch_size 2 \
+ --max_steps 1000 \
+ --gradient_accumulation_steps 8 \
+ --eval_strategy steps \
+ --eval_steps 50 \
+ --output_dir Qwen2-0.5B-DPO \
+ --no_remove_unused_columns
+```
+
+# LoRA:
+```bash
+python trl/scripts/dpo.py \
+ --dataset_name trl-lib/ultrafeedback_binarized \
+ --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
+ --learning_rate 5.0e-6 \
+ --num_train_epochs 1 \
+ --per_device_train_batch_size 2 \
+ --max_steps 1000 \
+ --gradient_accumulation_steps 8 \
+ --eval_strategy steps \
+ --eval_steps 50 \
+ --output_dir Qwen2-0.5B-DPO \
+ --no_remove_unused_columns \
+ --use_peft \
+ --lora_r 32 \
+ --lora_alpha 16
+```
+"""
+
+import argparse
+
+
+def main(script_args, training_args, model_args, dataset_args):
+ from accelerate.logging import get_logger
+ from datasets import load_dataset
+
+ from trl import DPOTrainer, get_dataset, get_kbit_device_map, get_peft_config, get_quantization_config
+
+ logger = get_logger(__name__)
+
+ training_args.model_init_kwargs = dict(
+ revision=model_args.model_revision,
+ trust_remote_code=training_args.trust_remote_code,
+ attn_implementation=model_args.attn_implementation,
+ dtype=model_args.dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ training_args.model_init_kwargs["device_map"] = get_kbit_device_map()
+ training_args.model_init_kwargs["quantization_config"] = quantization_config
+
+ # Load the dataset
+ if dataset_args.datasets and script_args.dataset_name:
+ logger.warning(
+ "Both `datasets` and `dataset_name` are provided. The `datasets` argument will be used to load the "
+ "dataset and `dataset_name` will be ignored."
+ )
+ dataset = get_dataset(dataset_args)
+ elif dataset_args.datasets and not script_args.dataset_name:
+ dataset = get_dataset(dataset_args)
+ elif not dataset_args.datasets and script_args.dataset_name:
+ dataset = load_dataset(
+ script_args.dataset_name, name=script_args.dataset_config, streaming=script_args.dataset_streaming
+ )
+ else:
+ raise ValueError("Either `datasets` or `dataset_name` must be provided.")
+
+ # Initialize the DPO trainer
+ trainer = DPOTrainer(
+ model=model_args.model_name_or_path,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ peft_config=get_peft_config(model_args),
+ )
+
+ if script_args.ignore_bias_buffers:
+ import torch
+
+ # torch distributed hack
+ trainer.model._ddp_params_and_buffers_to_ignore = [
+ name for name, buffer in trainer.model.named_buffers() if buffer.dtype == torch.bool
+ ]
+
+ # Train the model
+ trainer.train()
+
+ # Log training complete
+ trainer.accelerator.print("✅ Training completed.")
+
+ # Save and push to Hub
+ trainer.save_model(training_args.output_dir)
+ trainer.accelerator.print(f"💾 Model saved to {training_args.output_dir}.")
+
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
+ trainer.accelerator.print(f"🤗 Model pushed to the Hub in https://huggingface.co/{trainer.hub_model_id}.")
+
+
+def make_parser(subparsers: argparse._SubParsersAction | None = None, prog: str | None = None):
+ from trl import DatasetMixtureConfig, DPOConfig, ModelConfig, ScriptArguments, TrlParser
+
+ dataclass_types = (ScriptArguments, DPOConfig, ModelConfig, DatasetMixtureConfig)
+ if subparsers is not None:
+ parser = subparsers.add_parser("dpo", help="Run the DPO training script", dataclass_types=dataclass_types)
+ else:
+ parser = TrlParser(dataclass_types, prog=prog)
+ return parser
+
+
+if __name__ == "__main__":
+ parser = make_parser()
+ script_args, training_args, model_args, dataset_args = parser.parse_args_and_config(fail_with_unknown_args=False)
+ main(script_args, training_args, model_args, dataset_args)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/env.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/env.py
new file mode 100644
index 0000000000000000000000000000000000000000..830bbee0a9ab39e1426f011bcdf06df3a9b85f9e
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/env.py
@@ -0,0 +1,81 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# ]
+# ///
+
+import os
+import platform
+from importlib.metadata import version
+
+
+def print_env():
+ import torch
+ from accelerate.commands.config import default_config_file, load_config_from_file
+ from transformers import is_bitsandbytes_available
+ from transformers.utils import is_peft_available
+
+ from trl import __version__
+ from trl.import_utils import is_deepspeed_available, is_liger_kernel_available, is_vllm_available
+ from trl.scripts.utils import get_git_commit_hash
+
+ devices = None
+ if torch.cuda.is_available():
+ devices = [torch.cuda.get_device_name(i) for i in range(torch.cuda.device_count())]
+ elif torch.backends.mps.is_available():
+ devices = ["MPS"]
+ elif torch.xpu.is_available():
+ devices = [torch.xpu.get_device_name(i) for i in range(torch.xpu.device_count())]
+
+ accelerate_config = accelerate_config_str = "not found"
+
+ # Get the default from the config file.
+ if os.path.isfile(default_config_file):
+ accelerate_config = load_config_from_file(default_config_file).to_dict()
+
+ accelerate_config_str = (
+ "\n" + "\n".join([f" - {prop}: {val}" for prop, val in accelerate_config.items()])
+ if isinstance(accelerate_config, dict)
+ else accelerate_config
+ )
+
+ commit_hash = get_git_commit_hash("trl")
+
+ info = {
+ "Platform": platform.platform(),
+ "Python version": platform.python_version(),
+ "TRL version": f"{__version__}+{commit_hash[:7]}" if commit_hash else __version__,
+ "PyTorch version": version("torch"),
+ "accelerator(s)": ", ".join(devices) if devices is not None else "cpu",
+ "Transformers version": version("transformers"),
+ "Accelerate version": version("accelerate"),
+ "Accelerate config": accelerate_config_str,
+ "Datasets version": version("datasets"),
+ "HF Hub version": version("huggingface_hub"),
+ "bitsandbytes version": version("bitsandbytes") if is_bitsandbytes_available() else "not installed",
+ "DeepSpeed version": version("deepspeed") if is_deepspeed_available() else "not installed",
+ "Liger-Kernel version": version("liger_kernel") if is_liger_kernel_available() else "not installed",
+ "PEFT version": version("peft") if is_peft_available() else "not installed",
+ "vLLM version": version("vllm") if is_vllm_available() else "not installed",
+ }
+
+ info_str = "\n".join([f"- {prop}: {val}" for prop, val in info.items()])
+ print(f"\nCopy-paste the following information when reporting an issue:\n\n{info_str}\n") # noqa
+
+
+if __name__ == "__main__":
+ print_env()
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/grpo.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/grpo.py
new file mode 100644
index 0000000000000000000000000000000000000000..fde837780c5dee88a2fbccdcdad242f94ac96c46
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/grpo.py
@@ -0,0 +1,177 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "peft",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+import argparse
+import importlib
+import os
+import sys
+from dataclasses import dataclass, field
+
+from trl import ScriptArguments
+
+
+@dataclass
+class GRPOScriptArguments(ScriptArguments):
+ """
+ Script arguments for the GRPO training script.
+
+ Args:
+ reward_model_name_or_path (`str`, *optional*):
+ Reward model id of a pretrained model hosted inside a model repo on huggingface.co or local path to a
+ directory containing model weights saved using [`~transformers.PreTrainedModel.save_pretrained`].
+ reward_funcs (`list[str]`, *optional*):
+ Reward functions to use. Supported values are:
+ - `"accuracy_reward"`
+ - `"reasoning_accuracy_reward"`
+ - `"think_format_reward"`
+ - `"get_soft_overlong_punishment"` (used value are `max_completion_len=1280`, `soft_punish_cache=256`)
+ - any dotted import path " (e.g., `'my_lib.rewards.custom_reward'`).
+ """
+
+ reward_model_name_or_path: str | None = field(
+ default=None,
+ metadata={
+ "help": "Reward model id of a pretrained model hosted inside a model repo on huggingface.co or "
+ "local path to a directory containing model weights saved using `PreTrainedModel.save_pretrained`."
+ },
+ )
+ reward_funcs: list[str] | None = field(
+ default=None,
+ metadata={
+ "help": "Reward functions to use. Supported values are: `accuracy_reward`, `reasoning_accuracy_reward`, `think_format_reward`, "
+ "`get_soft_overlong_punishment` (used values are `max_completion_len=1280`, `soft_punish_cache=256`), or "
+ "any dotted import path (e.g., `'my_lib.rewards.custom_reward'`)."
+ },
+ )
+
+
+def main(script_args, training_args, model_args, dataset_args):
+ from accelerate.logging import get_logger
+ from datasets import load_dataset
+
+ from trl import GRPOTrainer, get_dataset, get_kbit_device_map, get_peft_config, get_quantization_config
+ from trl.rewards import (
+ accuracy_reward,
+ get_soft_overlong_punishment,
+ reasoning_accuracy_reward,
+ think_format_reward,
+ )
+
+ logger = get_logger(__name__)
+
+ reward_funcs_registry = {
+ "accuracy_reward": accuracy_reward,
+ "reasoning_accuracy_reward": reasoning_accuracy_reward,
+ "think_format_reward": think_format_reward,
+ "get_soft_overlong_punishment": get_soft_overlong_punishment(max_completion_len=1280, soft_punish_cache=256),
+ }
+
+ # Get the reward models and functions
+ reward_funcs = []
+ if script_args.reward_model_name_or_path:
+ reward_funcs.append(script_args.reward_model_name_or_path)
+
+ if script_args.reward_funcs:
+ for func_name in script_args.reward_funcs:
+ if func_name in reward_funcs_registry:
+ reward_funcs.append(reward_funcs_registry[func_name])
+ elif "." in func_name:
+ module_path, func_name = func_name.rsplit(".", 1)
+ sys.path.insert(0, os.getcwd())
+ module = importlib.import_module(module_path)
+ reward_func = getattr(module, func_name)
+ reward_funcs.append(reward_func)
+ else:
+ raise ValueError(
+ f"Could not load reward function '{func_name}'. Expected one of "
+ f"{list(reward_funcs_registry.keys())} or a valid import path."
+ )
+
+ training_args.model_init_kwargs = dict(
+ revision=model_args.model_revision,
+ trust_remote_code=training_args.trust_remote_code,
+ attn_implementation=model_args.attn_implementation,
+ dtype=model_args.dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ training_args.model_init_kwargs["device_map"] = get_kbit_device_map()
+ training_args.model_init_kwargs["quantization_config"] = quantization_config
+
+ # Load the dataset
+ if dataset_args.datasets and script_args.dataset_name:
+ logger.warning(
+ "Both `datasets` and `dataset_name` are provided. The `datasets` argument will be used to load the "
+ "dataset and `dataset_name` will be ignored."
+ )
+ dataset = get_dataset(dataset_args)
+ elif dataset_args.datasets and not script_args.dataset_name:
+ dataset = get_dataset(dataset_args)
+ elif not dataset_args.datasets and script_args.dataset_name:
+ dataset = load_dataset(
+ script_args.dataset_name, name=script_args.dataset_config, streaming=script_args.dataset_streaming
+ )
+ else:
+ raise ValueError("Either `datasets` or `dataset_name` must be provided.")
+
+ # Initialize the GRPO trainer
+ trainer = GRPOTrainer(
+ model=model_args.model_name_or_path,
+ reward_funcs=reward_funcs,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ peft_config=get_peft_config(model_args),
+ )
+
+ # Train the model
+ trainer.train()
+
+ # Log training complete
+ trainer.accelerator.print("✅ Training completed.")
+
+ # Save and push to Hub
+ trainer.save_model(training_args.output_dir)
+ trainer.accelerator.print(f"💾 Model saved to {training_args.output_dir}.")
+
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
+ trainer.accelerator.print(f"🤗 Model pushed to the Hub in https://huggingface.co/{trainer.hub_model_id}.")
+
+
+def make_parser(subparsers: argparse._SubParsersAction | None = None, prog: str | None = None):
+ from trl import DatasetMixtureConfig, GRPOConfig, ModelConfig, TrlParser
+
+ dataclass_types = (GRPOScriptArguments, GRPOConfig, ModelConfig, DatasetMixtureConfig)
+ if subparsers is not None:
+ parser = subparsers.add_parser("grpo", help="Run the GRPO training script", dataclass_types=dataclass_types)
+ else:
+ parser = TrlParser(dataclass_types, prog=prog)
+ return parser
+
+
+if __name__ == "__main__":
+ parser = make_parser()
+ script_args, training_args, model_args, dataset_args = parser.parse_args_and_config(fail_with_unknown_args=False)
+ main(script_args, training_args, model_args, dataset_args)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/kto.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/kto.py
new file mode 100644
index 0000000000000000000000000000000000000000..601b71e6cff581f40f87f1cc295002a6fd776fe7
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/kto.py
@@ -0,0 +1,151 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "peft",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Run the KTO training script with the commands below. In general, the optimal configuration for KTO will be similar to
+that of DPO.
+
+# Full training:
+```bash
+python trl/scripts/kto.py \
+ --dataset_name trl-lib/kto-mix-14k \
+ --model_name_or_path=trl-lib/qwen1.5-1.8b-sft \
+ --per_device_train_batch_size 16 \
+ --num_train_epochs 1 \
+ --learning_rate 5e-7 \
+ --lr_scheduler_type=cosine \
+ --gradient_accumulation_steps 1 \
+ --eval_steps 500 \
+ --output_dir=kto-aligned-model \
+ --warmup_steps 0.1 \
+ --logging_first_step
+```
+
+# QLoRA:
+```bash
+# QLoRA:
+python trl/scripts/kto.py \
+ --dataset_name trl-lib/kto-mix-14k \
+ --model_name_or_path=trl-lib/qwen1.5-1.8b-sft \
+ --per_device_train_batch_size 8 \
+ --num_train_epochs 1 \
+ --learning_rate 5e-7 \
+ --lr_scheduler_type=cosine \
+ --gradient_accumulation_steps 1 \
+ --eval_steps 500 \
+ --output_dir=kto-aligned-model-lora \
+ --warmup_steps 0.1 \
+ --logging_first_step \
+ --use_peft \
+ --load_in_4bit \
+ --lora_target_modules=all-linear \
+ --lora_r=16 \
+ --lora_alpha=16
+```
+"""
+
+import argparse
+
+
+def main(script_args, training_args, model_args, dataset_args):
+ from accelerate.logging import get_logger
+ from datasets import load_dataset
+ from transformers import AutoModelForCausalLM, AutoTokenizer
+
+ from trl import get_dataset, get_peft_config
+ from trl.experimental.kto import KTOTrainer
+
+ logger = get_logger(__name__)
+
+ # Load a pretrained model
+ model = AutoModelForCausalLM.from_pretrained(
+ model_args.model_name_or_path, trust_remote_code=training_args.trust_remote_code
+ )
+ ref_model = AutoModelForCausalLM.from_pretrained(
+ model_args.model_name_or_path, trust_remote_code=training_args.trust_remote_code
+ )
+
+ tokenizer = AutoTokenizer.from_pretrained(
+ model_args.model_name_or_path, trust_remote_code=training_args.trust_remote_code
+ )
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+
+ # Load the dataset
+ if dataset_args.datasets and script_args.dataset_name:
+ logger.warning(
+ "Both `datasets` and `dataset_name` are provided. The `datasets` argument will be used to load the "
+ "dataset and `dataset_name` will be ignored."
+ )
+ dataset = get_dataset(dataset_args)
+ elif dataset_args.datasets and not script_args.dataset_name:
+ dataset = get_dataset(dataset_args)
+ elif not dataset_args.datasets and script_args.dataset_name:
+ dataset = load_dataset(
+ script_args.dataset_name, name=script_args.dataset_config, streaming=script_args.dataset_streaming
+ )
+ else:
+ raise ValueError("Either `datasets` or `dataset_name` must be provided.")
+
+ # Initialize the KTO trainer
+ trainer = KTOTrainer(
+ model,
+ ref_model,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ processing_class=tokenizer,
+ peft_config=get_peft_config(model_args),
+ )
+
+ # Train the model
+ trainer.train()
+
+ # Log training complete
+ trainer.accelerator.print("✅ Training completed.")
+
+ # Save and push to Hub
+ trainer.save_model(training_args.output_dir)
+ trainer.accelerator.print(f"💾 Model saved to {training_args.output_dir}.")
+
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
+ trainer.accelerator.print(f"🤗 Model pushed to the Hub in https://huggingface.co/{trainer.hub_model_id}.")
+
+
+def make_parser(subparsers: argparse._SubParsersAction | None = None, prog: str | None = None):
+ from trl import DatasetMixtureConfig, ModelConfig, ScriptArguments, TrlParser
+ from trl.experimental.kto import KTOConfig
+
+ dataclass_types = (ScriptArguments, KTOConfig, ModelConfig, DatasetMixtureConfig)
+ if subparsers is not None:
+ parser = subparsers.add_parser("kto", help="Run the KTO training script", dataclass_types=dataclass_types)
+ else:
+ parser = TrlParser(dataclass_types, prog=prog)
+ return parser
+
+
+if __name__ == "__main__":
+ parser = make_parser()
+ script_args, training_args, model_args, dataset_args = parser.parse_args_and_config(fail_with_unknown_args=False)
+ main(script_args, training_args, model_args, dataset_args)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/reward.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/reward.py
new file mode 100644
index 0000000000000000000000000000000000000000..9cec8e9de84f60a5498cf98f542969d24b83e8b4
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/reward.py
@@ -0,0 +1,103 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "peft",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+import argparse
+
+
+def main(script_args, training_args, model_args, dataset_args):
+ from accelerate.logging import get_logger
+ from datasets import load_dataset
+
+ from trl import RewardTrainer, get_dataset, get_kbit_device_map, get_peft_config, get_quantization_config
+
+ logger = get_logger(__name__)
+
+ training_args.model_init_kwargs = dict(
+ revision=model_args.model_revision,
+ trust_remote_code=training_args.trust_remote_code,
+ attn_implementation=model_args.attn_implementation,
+ dtype=model_args.dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ training_args.model_init_kwargs["device_map"] = get_kbit_device_map()
+ training_args.model_init_kwargs["quantization_config"] = quantization_config
+
+ # Load the dataset
+ if dataset_args.datasets and script_args.dataset_name:
+ logger.warning(
+ "Both `datasets` and `dataset_name` are provided. The `datasets` argument will be used to load the "
+ "dataset and `dataset_name` will be ignored."
+ )
+ dataset = get_dataset(dataset_args)
+ elif dataset_args.datasets and not script_args.dataset_name:
+ dataset = get_dataset(dataset_args)
+ elif not dataset_args.datasets and script_args.dataset_name:
+ dataset = load_dataset(
+ script_args.dataset_name, name=script_args.dataset_config, streaming=script_args.dataset_streaming
+ )
+ else:
+ raise ValueError("Either `datasets` or `dataset_name` must be provided.")
+
+ # Initialize the reward trainer
+ trainer = RewardTrainer(
+ model=model_args.model_name_or_path,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ peft_config=get_peft_config(model_args),
+ )
+
+ # Train the model
+ trainer.train()
+
+ # Log training complete
+ trainer.accelerator.print("✅ Training completed.")
+
+ # Save and push to Hub
+ trainer.save_model(training_args.output_dir)
+ trainer.accelerator.print(f"💾 Model saved to {training_args.output_dir}.")
+
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
+ trainer.accelerator.print(f"🤗 Model pushed to the Hub in https://huggingface.co/{trainer.hub_model_id}.")
+
+
+def make_parser(subparsers: argparse._SubParsersAction | None = None, prog: str | None = None):
+ from trl import DatasetMixtureConfig, ModelConfig, RewardConfig, ScriptArguments, TrlParser
+
+ dataclass_types = (ScriptArguments, RewardConfig, ModelConfig, DatasetMixtureConfig)
+ if subparsers is not None:
+ parser = subparsers.add_parser(
+ "reward", help="Run the reward training script", dataclass_types=dataclass_types
+ )
+ else:
+ parser = TrlParser(dataclass_types, prog=prog)
+ return parser
+
+
+if __name__ == "__main__":
+ parser = make_parser()
+ script_args, training_args, model_args, dataset_args = parser.parse_args_and_config(fail_with_unknown_args=False)
+ main(script_args, training_args, model_args, dataset_args)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/rloo.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/rloo.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ec6f3806951db8d738bf9bfea4d6e65cbe89b8d
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/rloo.py
@@ -0,0 +1,177 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "peft",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+import argparse
+import importlib
+import os
+import sys
+from dataclasses import dataclass, field
+
+from trl import ScriptArguments
+
+
+@dataclass
+class RLOOScriptArguments(ScriptArguments):
+ """
+ Script arguments for the RLOO training script.
+
+ Args:
+ reward_model_name_or_path (`str`, *optional*):
+ Reward model id of a pretrained model hosted inside a model repo on huggingface.co or local path to a
+ directory containing model weights saved using [`~transformers.PreTrainedModel.save_pretrained`].
+ reward_funcs (`list[str]`, *optional*):
+ Reward functions to use. Supported values are:
+ - `"accuracy_reward"`
+ - `"reasoning_accuracy_reward"`
+ - `"think_format_reward"`
+ - `"get_soft_overlong_punishment"` (used value are `max_completion_len=1280`, `soft_punish_cache=256`)
+ - any dotted import path " (e.g., `'my_lib.rewards.custom_reward'`).
+ """
+
+ reward_model_name_or_path: str | None = field(
+ default=None,
+ metadata={
+ "help": "Reward model id of a pretrained model hosted inside a model repo on huggingface.co or "
+ "local path to a directory containing model weights saved using `PreTrainedModel.save_pretrained`."
+ },
+ )
+ reward_funcs: list[str] | None = field(
+ default=None,
+ metadata={
+ "help": "Reward functions to use. Supported values are: `accuracy_reward`, `reasoning_accuracy_reward`, `think_format_reward`, "
+ "`get_soft_overlong_punishment` (used values are `max_completion_len=1280`, `soft_punish_cache=256`), or "
+ "any dotted import path (e.g., `'my_lib.rewards.custom_reward'`)."
+ },
+ )
+
+
+def main(script_args, training_args, model_args, dataset_args):
+ from accelerate.logging import get_logger
+ from datasets import load_dataset
+
+ from trl import RLOOTrainer, get_dataset, get_kbit_device_map, get_peft_config, get_quantization_config
+ from trl.rewards import (
+ accuracy_reward,
+ get_soft_overlong_punishment,
+ reasoning_accuracy_reward,
+ think_format_reward,
+ )
+
+ logger = get_logger(__name__)
+
+ reward_funcs_registry = {
+ "accuracy_reward": accuracy_reward,
+ "reasoning_accuracy_reward": reasoning_accuracy_reward,
+ "think_format_reward": think_format_reward,
+ "get_soft_overlong_punishment": get_soft_overlong_punishment(max_completion_len=1280, soft_punish_cache=256),
+ }
+
+ # Get the reward models and functions
+ reward_funcs = []
+ if script_args.reward_model_name_or_path:
+ reward_funcs.append(script_args.reward_model_name_or_path)
+
+ if script_args.reward_funcs:
+ for func_name in script_args.reward_funcs:
+ if func_name in reward_funcs_registry:
+ reward_funcs.append(reward_funcs_registry[func_name])
+ elif "." in func_name:
+ module_path, func_name = func_name.rsplit(".", 1)
+ sys.path.insert(0, os.getcwd())
+ module = importlib.import_module(module_path)
+ reward_func = getattr(module, func_name)
+ reward_funcs.append(reward_func)
+ else:
+ raise ValueError(
+ f"Could not load reward function '{func_name}'. Expected one of "
+ f"{list(reward_funcs_registry.keys())} or a valid import path."
+ )
+
+ training_args.model_init_kwargs = dict(
+ revision=model_args.model_revision,
+ trust_remote_code=training_args.trust_remote_code,
+ attn_implementation=model_args.attn_implementation,
+ dtype=model_args.dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ training_args.model_init_kwargs["device_map"] = get_kbit_device_map()
+ training_args.model_init_kwargs["quantization_config"] = quantization_config
+
+ # Load the dataset
+ if dataset_args.datasets and script_args.dataset_name:
+ logger.warning(
+ "Both `datasets` and `dataset_name` are provided. The `datasets` argument will be used to load the "
+ "dataset and `dataset_name` will be ignored."
+ )
+ dataset = get_dataset(dataset_args)
+ elif dataset_args.datasets and not script_args.dataset_name:
+ dataset = get_dataset(dataset_args)
+ elif not dataset_args.datasets and script_args.dataset_name:
+ dataset = load_dataset(
+ script_args.dataset_name, name=script_args.dataset_config, streaming=script_args.dataset_streaming
+ )
+ else:
+ raise ValueError("Either `datasets` or `dataset_name` must be provided.")
+
+ # Initialize the RLOO trainer
+ trainer = RLOOTrainer(
+ model=model_args.model_name_or_path,
+ reward_funcs=reward_funcs,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ peft_config=get_peft_config(model_args),
+ )
+
+ # Train the model
+ trainer.train()
+
+ # Log training complete
+ trainer.accelerator.print("✅ Training completed.")
+
+ # Save and push to Hub
+ trainer.save_model(training_args.output_dir)
+ trainer.accelerator.print(f"💾 Model saved to {training_args.output_dir}.")
+
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
+ trainer.accelerator.print(f"🤗 Model pushed to the Hub in https://huggingface.co/{trainer.hub_model_id}.")
+
+
+def make_parser(subparsers: argparse._SubParsersAction | None = None, prog: str | None = None):
+ from trl import DatasetMixtureConfig, ModelConfig, RLOOConfig, TrlParser
+
+ dataclass_types = (RLOOScriptArguments, RLOOConfig, ModelConfig, DatasetMixtureConfig)
+ if subparsers is not None:
+ parser = subparsers.add_parser("rloo", help="Run the RLOO training script", dataclass_types=dataclass_types)
+ else:
+ parser = TrlParser(dataclass_types, prog=prog)
+ return parser
+
+
+if __name__ == "__main__":
+ parser = make_parser()
+ script_args, training_args, model_args, dataset_args = parser.parse_args_and_config(fail_with_unknown_args=False)
+ main(script_args, training_args, model_args, dataset_args)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/sft.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/sft.py
new file mode 100644
index 0000000000000000000000000000000000000000..82c9622cb0da0f9fb9e1541a09c765af14647a8a
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/sft.py
@@ -0,0 +1,140 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "peft",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+# Full training
+```
+python trl/scripts/sft.py \
+ --model_name_or_path Qwen/Qwen2-0.5B \
+ --dataset_name trl-lib/Capybara \
+ --learning_rate 2.0e-5 \
+ --num_train_epochs 1 \
+ --packing \
+ --per_device_train_batch_size 2 \
+ --gradient_accumulation_steps 8 \
+ --eos_token '<|im_end|>' \
+ --eval_strategy steps \
+ --eval_steps 100 \
+ --output_dir Qwen2-0.5B-SFT \
+ --push_to_hub
+```
+
+# LoRA
+```
+python trl/scripts/sft.py \
+ --model_name_or_path Qwen/Qwen2-0.5B \
+ --dataset_name trl-lib/Capybara \
+ --learning_rate 2.0e-4 \
+ --num_train_epochs 1 \
+ --packing \
+ --per_device_train_batch_size 2 \
+ --gradient_accumulation_steps 8 \
+ --eos_token '<|im_end|>' \
+ --eval_strategy steps \
+ --eval_steps 100 \
+ --use_peft \
+ --lora_r 32 \
+ --lora_alpha 16 \
+ --output_dir Qwen2-0.5B-SFT \
+ --push_to_hub
+```
+"""
+
+import argparse
+
+
+def main(script_args, training_args, model_args, dataset_args):
+ from accelerate.logging import get_logger
+ from datasets import load_dataset
+
+ from trl import SFTTrainer, get_dataset, get_kbit_device_map, get_peft_config, get_quantization_config
+
+ logger = get_logger(__name__)
+
+ training_args.model_init_kwargs = dict(
+ revision=model_args.model_revision,
+ trust_remote_code=training_args.trust_remote_code,
+ attn_implementation=model_args.attn_implementation,
+ dtype=model_args.dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ training_args.model_init_kwargs["device_map"] = get_kbit_device_map()
+ training_args.model_init_kwargs["quantization_config"] = quantization_config
+
+ # Load the dataset
+ if dataset_args.datasets and script_args.dataset_name:
+ logger.warning(
+ "Both `datasets` and `dataset_name` are provided. The `datasets` argument will be used to load the "
+ "dataset and `dataset_name` will be ignored."
+ )
+ dataset = get_dataset(dataset_args)
+ elif dataset_args.datasets and not script_args.dataset_name:
+ dataset = get_dataset(dataset_args)
+ elif not dataset_args.datasets and script_args.dataset_name:
+ dataset = load_dataset(
+ script_args.dataset_name, name=script_args.dataset_config, streaming=script_args.dataset_streaming
+ )
+ else:
+ raise ValueError("Either `datasets` or `dataset_name` must be provided.")
+
+ # Initialize the SFT trainer
+ trainer = SFTTrainer(
+ model=model_args.model_name_or_path,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ peft_config=get_peft_config(model_args),
+ )
+
+ # Train the model
+ trainer.train()
+
+ # Log training complete
+ trainer.accelerator.print("✅ Training completed.")
+
+ # Save and push to Hub
+ trainer.save_model(training_args.output_dir)
+ trainer.accelerator.print(f"💾 Model saved to {training_args.output_dir}.")
+
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
+ trainer.accelerator.print(f"🤗 Model pushed to the Hub in https://huggingface.co/{trainer.hub_model_id}.")
+
+
+def make_parser(subparsers: argparse._SubParsersAction | None = None, prog: str | None = None):
+ from trl import DatasetMixtureConfig, ModelConfig, ScriptArguments, SFTConfig, TrlParser
+
+ dataclass_types = (ScriptArguments, SFTConfig, ModelConfig, DatasetMixtureConfig)
+ if subparsers is not None:
+ parser = subparsers.add_parser("sft", help="Run the SFT training script", dataclass_types=dataclass_types)
+ else:
+ parser = TrlParser(dataclass_types, prog=prog)
+ return parser
+
+
+if __name__ == "__main__":
+ parser = make_parser()
+ script_args, training_args, model_args, dataset_args = parser.parse_args_and_config(fail_with_unknown_args=False)
+ main(script_args, training_args, model_args, dataset_args)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/utils.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..165fec49fc32ed3c00cb3001f64f35ab5d690a6f
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/utils.py
@@ -0,0 +1,466 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import importlib
+import inspect
+import logging
+import os
+import subprocess
+import sys
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+# Temporarily import from the local module instead of transformers to avoid an upstream latency issue
+# See: https://github.com/huggingface/transformers/issues/44273
+# This workaround can be reverted once the fix is included in the minimum required transformers version
+from trl.scripts._hf_argparser import DataClass, DataClassType, HfArgumentParser
+
+
+if TYPE_CHECKING:
+ from datasets import DatasetDict
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DatasetConfig:
+ """
+ Configuration for a dataset.
+
+ This class matches the signature of [`~datasets.load_dataset`] and the arguments are used directly in the
+ [`~datasets.load_dataset`] function. You can refer to the [`~datasets.load_dataset`] documentation for more
+ details.
+
+ Parameters:
+ path (`str`):
+ Path or name of the dataset.
+ name (`str`, *optional*):
+ Defining the name of the dataset configuration.
+ data_dir (`str`, *optional*):
+ Defining the `data_dir` of the dataset configuration. If specified for the generic builders(csv, text etc.)
+ or the Hub datasets and `data_files` is `None`, the behavior is equal to passing `os.path.join(data_dir,
+ **)` as `data_files` to reference all the files in a directory.
+ data_files (`str` or `Sequence` or `Mapping`, *optional*):
+ Path(s) to source data file(s).
+ split (`str`, *optional*, defaults to `"train"`):
+ Which split of the data to load.
+ columns (`list[str]`, *optional*):
+ List of column names to select from the dataset. If `None`, all columns are selected.
+ """
+
+ path: str
+ name: str | None = None
+ data_dir: str | None = None
+ data_files: str | list[str] | dict[str, str] | None = None
+ split: str = "train"
+ columns: list[str] | None = None
+
+
+@dataclass
+class DatasetMixtureConfig:
+ """
+ Configuration class for a mixture of datasets.
+
+ Using [`~transformers.HfArgumentParser`] we can turn this class into
+ [argparse](https://docs.python.org/3/library/argparse#module-argparse) arguments that can be specified on the
+ command line.
+
+ Parameters:
+ datasets (`list[DatasetConfig]`):
+ List of dataset configurations to include in the mixture.
+ streaming (`bool`, *optional*, defaults to `False`):
+ Whether to stream the datasets. If `True`, the datasets will be loaded in streaming mode.
+ test_split_size (`float`, *optional*):
+ Size of the test split. Refer to the `test_size` parameter in the [`~datasets.train_test_split`] function
+ for more details. If `None`, the dataset will not be split into train and test sets.
+
+ Usage:
+ When using the CLI, you can add the following section to your YAML config file:
+
+ ```yaml
+ datasets:
+ - path: ...
+ name: ...
+ data_dir: ...
+ data_files: ...
+ split: ...
+ columns: ...
+ - path: ...
+ name: ...
+ data_dir: ...
+ data_files: ...
+ split: ...
+ columns: ...
+ streaming: ...
+ test_split_size: ...
+ ```
+ """
+
+ datasets: list[DatasetConfig] = field(
+ default_factory=list,
+ metadata={"help": "List of dataset configurations to include in the mixture."},
+ )
+ streaming: bool = field(
+ default=False,
+ metadata={"help": "Whether to stream the datasets. If True, the datasets will be loaded in streaming mode."},
+ )
+ test_split_size: float | None = field(
+ default=None,
+ metadata={
+ "help": "Size of the test split. Refer to the `test_size` parameter in the `datasets.train_test_split` "
+ "function for more details. If None, the dataset will not be split into train and test sets."
+ },
+ )
+
+ def __post_init__(self):
+ # Convert any dataset dicts (from CLI/config parsing) into DatasetConfig objects
+ for idx, dataset in enumerate(self.datasets):
+ if isinstance(dataset, dict):
+ # If it's a dict, convert it to DatasetConfig
+ self.datasets[idx] = DatasetConfig(**dataset)
+
+
+@dataclass
+class ScriptArguments:
+ """
+ Arguments common to all scripts.
+
+ Args:
+ dataset_name (`str`,, *optional*):
+ Path or name of the dataset to load. If `datasets` is provided, this will be ignored.
+ dataset_config (`str`, *optional*):
+ Dataset configuration name. Corresponds to the `name` argument of the [`~datasets.load_dataset`] function.
+ If `datasets` is provided, this will be ignored.
+ dataset_train_split (`str`, *optional*, defaults to `"train"`):
+ Dataset split to use for training. If `datasets` is provided, this will be ignored.
+ dataset_test_split (`str`, *optional*, defaults to `"test"`):
+ Dataset split to use for evaluation. If `datasets` is provided, this will be ignored.
+ dataset_streaming (`bool`, *optional*, defaults to `False`):
+ Whether to stream the dataset. If True, the dataset will be loaded in streaming mode. If `datasets` is
+ provided, this will be ignored.
+ ignore_bias_buffers (`bool`, *optional*, defaults to `False`):
+ Debug argument for distributed training. Fix for DDP issues with LM bias/mask buffers - invalid scalar
+ type, inplace operation. See
+ https://github.com/huggingface/transformers/issues/22482#issuecomment-1595790992.
+ """
+
+ dataset_name: str | None = field(
+ default=None,
+ metadata={"help": "Path or name of the dataset to load. If `datasets` is provided, this will be ignored."},
+ )
+ dataset_config: str | None = field(
+ default=None,
+ metadata={
+ "help": "Dataset configuration name. Corresponds to the `name` argument of the `datasets.load_dataset` "
+ "function. If `datasets` is provided, this will be ignored."
+ },
+ )
+ dataset_train_split: str = field(
+ default="train",
+ metadata={"help": "Dataset split to use for training. If `datasets` is provided, this will be ignored."},
+ )
+ dataset_test_split: str = field(
+ default="test",
+ metadata={"help": "Dataset split to use for evaluation. If `datasets` is provided, this will be ignored."},
+ )
+ dataset_streaming: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to stream the dataset. If True, the dataset will be loaded in streaming mode. If "
+ "`datasets` is provided, this will be ignored."
+ },
+ )
+ ignore_bias_buffers: bool = field(
+ default=False,
+ metadata={
+ "help": "Debug argument for distributed training. Fix for DDP issues with LM bias/mask buffers - invalid "
+ "scalar type, inplace operation. See "
+ "https://github.com/huggingface/transformers/issues/22482#issuecomment-1595790992."
+ },
+ )
+
+
+def init_zero_verbose():
+ """
+ Perform zero verbose init - use this method on top of the CLI modules to make logging and warning output cleaner.
+ Uses Rich if available, falls back otherwise.
+ """
+ import logging
+ import warnings
+
+ from transformers.utils import is_rich_available
+
+ FORMAT = "%(message)s"
+
+ if is_rich_available():
+ from rich.logging import RichHandler
+
+ handler = RichHandler()
+ else:
+ handler = logging.StreamHandler()
+
+ logging.basicConfig(format=FORMAT, datefmt="[%X]", handlers=[handler], level=logging.ERROR)
+
+ # Custom warning handler to redirect warnings to the logging system
+ def warning_handler(message, category, filename, lineno, file=None, line=None):
+ logging.warning(f"{filename}:{lineno}: {category.__name__}: {message}")
+
+ # Add the custom warning handler - we need to do that before importing anything to make sure the loggers work well
+ warnings.showwarning = warning_handler
+
+
+class TrlParser(HfArgumentParser):
+ """
+ A subclass of [`transformers.HfArgumentParser`] designed for parsing command-line arguments with dataclass-backed
+ configurations, while also supporting configuration file loading and environment variable management.
+
+ Args:
+ dataclass_types (`DataClassType | Iterable[DataClassType]`, *optional*):
+ Dataclass types to use for argument parsing.
+ **kwargs:
+ Additional keyword arguments passed to the [`transformers.HfArgumentParser`] constructor.
+
+ Examples:
+
+ ```yaml
+ # config.yaml
+ env:
+ VAR1: value1
+ arg1: 23
+ ```
+
+ ```python
+ # main.py
+ import os
+ from dataclasses import dataclass
+ from trl import TrlParser
+
+
+ @dataclass
+ class MyArguments:
+ arg1: int
+ arg2: str = "alpha"
+
+
+ parser = TrlParser(dataclass_types=[MyArguments])
+ training_args = parser.parse_args_and_config()
+
+ print(training_args, os.environ.get("VAR1"))
+ ```
+
+ ```bash
+ $ python main.py --config config.yaml
+ (MyArguments(arg1=23, arg2='alpha'),) value1
+
+ $ python main.py --arg1 5 --arg2 beta
+ (MyArguments(arg1=5, arg2='beta'),) None
+ ```
+ """
+
+ def __init__(
+ self,
+ dataclass_types: DataClassType | Iterable[DataClassType] | None = None,
+ **kwargs,
+ ):
+ # Make sure dataclass_types is an iterable
+ if dataclass_types is None:
+ dataclass_types = []
+ elif not isinstance(dataclass_types, Iterable):
+ dataclass_types = [dataclass_types]
+
+ # Check that none of the dataclasses have the "config" field
+ for dataclass_type in dataclass_types:
+ if "config" in dataclass_type.__dataclass_fields__:
+ raise ValueError(
+ f"Dataclass {dataclass_type.__name__} has a field named 'config'. This field is reserved for the "
+ f"config file path and should not be used in the dataclass."
+ )
+
+ super().__init__(dataclass_types=dataclass_types, **kwargs)
+
+ def parse_args_and_config(
+ self,
+ args: Iterable[str] | None = None,
+ return_remaining_strings: bool = False,
+ fail_with_unknown_args: bool = True,
+ separate_remaining_strings: bool = False,
+ ) -> tuple[DataClass, ...]:
+ """
+ Parse command-line args and config file into instances of the specified dataclass types.
+
+ This method wraps [`transformers.HfArgumentParser.parse_args_into_dataclasses`] and also parses the config file
+ specified with the `--config` flag. The config file (in YAML format) provides argument values that replace the
+ default values in the dataclasses. Command line arguments can override values set by the config file. The
+ method also sets any environment variables specified in the `env` field of the config file.
+ """
+ import yaml
+
+ args = list(args) if args is not None else sys.argv[1:]
+ if "--config" in args:
+ # Get the config file path from
+ config_index = args.index("--config")
+ args.pop(config_index) # remove the --config flag
+ config_path = args.pop(config_index) # get the path to the config file
+ with open(config_path) as yaml_file:
+ config = yaml.safe_load(yaml_file)
+
+ # Set the environment variables specified in the config file
+ if "env" in config:
+ env_vars = config.pop("env", {})
+ if not isinstance(env_vars, dict):
+ raise ValueError("`env` field should be a dict in the YAML file.")
+ for key, value in env_vars.items():
+ os.environ[key] = str(value)
+
+ # Set the defaults from the config values
+ config_remaining_strings = self.set_defaults_with_config(**config)
+ else:
+ config_remaining_strings = []
+
+ # Parse the arguments from the command line
+ output = self.parse_args_into_dataclasses(args=args, return_remaining_strings=return_remaining_strings)
+
+ # Merge remaining strings from the config file with the remaining strings from the command line
+ if return_remaining_strings:
+ args_remaining_strings = output[-1]
+ if separate_remaining_strings:
+ return output[:-1] + (config_remaining_strings, args_remaining_strings)
+ return output[:-1] + (config_remaining_strings + args_remaining_strings,)
+ elif fail_with_unknown_args and config_remaining_strings:
+ raise ValueError(
+ f"Unknown arguments from config file: {config_remaining_strings}. Please remove them, add them to the "
+ "dataclass, or set `fail_with_unknown_args=False`."
+ )
+ else:
+ return output
+
+ def set_defaults_with_config(self, **kwargs) -> list[str]:
+ """
+ Overrides the parser's default values with those provided via keyword arguments, including for subparsers.
+
+ Any argument with an updated default will also be marked as not required if it was previously required.
+
+ Returns a list of strings that were not consumed by the parser.
+ """
+
+ def apply_defaults(parser, kw):
+ used_keys = set()
+ for action in parser._actions:
+ # Handle subparsers recursively
+ if isinstance(action, argparse._SubParsersAction):
+ for subparser in action.choices.values():
+ used_keys.update(apply_defaults(subparser, kw))
+ elif action.dest in kw:
+ action.default = kw[action.dest]
+ action.required = False
+ used_keys.add(action.dest)
+ return used_keys
+
+ used_keys = apply_defaults(self, kwargs)
+ # Remaining args not consumed by the parser
+ remaining = [
+ item for key, value in kwargs.items() if key not in used_keys for item in (f"--{key}", str(value))
+ ]
+ return remaining
+
+
+def get_git_commit_hash(package_name):
+ try:
+ # Import the package to locate its path
+ package = importlib.import_module(package_name)
+ # Get the path to the package using inspect
+ package_path = os.path.dirname(inspect.getfile(package))
+
+ # Navigate up to the Git repository root if the package is inside a subdirectory
+ git_repo_path = os.path.abspath(os.path.join(package_path, ".."))
+ git_dir = os.path.join(git_repo_path, ".git")
+
+ if os.path.isdir(git_dir):
+ # Run the git command to get the current commit hash
+ commit_hash = (
+ subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=git_repo_path).strip().decode("utf-8")
+ )
+ return commit_hash
+ else:
+ return None
+ except Exception as e:
+ return f"Error: {str(e)}"
+
+
+def get_dataset(mixture_config: DatasetMixtureConfig) -> "DatasetDict":
+ """
+ Load a mixture of datasets based on the configuration.
+
+ Args:
+ mixture_config ([`DatasetMixtureConfig`]):
+ Script arguments containing dataset configuration.
+
+ Returns:
+ [`~datasets.DatasetDict`]:
+ Combined dataset(s) from the mixture configuration, with optional train/test split if `test_split_size` is
+ set.
+
+ Example:
+ ```python
+ from trl import DatasetMixtureConfig, get_dataset
+ from trl.scripts.utils import DatasetConfig
+
+ mixture_config = DatasetMixtureConfig(datasets=[DatasetConfig(path="trl-lib/tldr")])
+ dataset = get_dataset(mixture_config)
+ print(dataset)
+ ```
+
+ ```
+ DatasetDict({
+ train: Dataset({
+ features: ['prompt', 'completion'],
+ num_rows: 116722
+ })
+ })
+ ```
+ """
+ import datasets
+
+ logger.info(f"Creating dataset mixture with {len(mixture_config.datasets)} datasets")
+ datasets_list = []
+ for dataset_config in mixture_config.datasets:
+ logger.info(f"Loading dataset for mixture: {dataset_config.path} (config name: {dataset_config.name})")
+ dataset = datasets.load_dataset(
+ path=dataset_config.path,
+ name=dataset_config.name,
+ data_dir=dataset_config.data_dir,
+ data_files=dataset_config.data_files,
+ split=dataset_config.split,
+ streaming=mixture_config.streaming,
+ )
+ if dataset_config.columns is not None:
+ dataset = dataset.select_columns(dataset_config.columns)
+ datasets_list.append(dataset)
+
+ if datasets_list:
+ combined_dataset = datasets.concatenate_datasets(datasets_list)
+ if isinstance(combined_dataset, datasets.Dataset): # IterableDataset does not have a length
+ logger.info(f"Created dataset mixture with {len(combined_dataset)} examples")
+
+ if mixture_config.test_split_size is not None:
+ logger.info(f"Splitting dataset into train and test sets with test size: {mixture_config.test_split_size}")
+ combined_dataset = combined_dataset.train_test_split(test_size=mixture_config.test_split_size)
+ return combined_dataset
+ else:
+ return datasets.DatasetDict({"train": combined_dataset})
+ else:
+ raise ValueError("No datasets were loaded from the mixture configuration")
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/vllm_serve.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/vllm_serve.py
new file mode 100644
index 0000000000000000000000000000000000000000..ccf182eeaacfbc498b3fbcd5c455a3e93be16536
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/scripts/vllm_serve.py
@@ -0,0 +1,1220 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import base64
+import json
+import logging
+import math
+import os
+from collections.abc import Sequence
+from contextlib import asynccontextmanager
+from dataclasses import dataclass, field
+from io import BytesIO
+from itertools import chain
+from multiprocessing import Pipe, Process
+from multiprocessing.connection import Connection
+
+
+# We use CUDA with multiprocessing, so we must use the 'spawn' start method. Otherwise, we will get the following
+# error: RuntimeError: Cannot re-initialize CUDA in forked subprocess. To use CUDA with multiprocessing, you must use
+# the 'spawn' start method
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+
+
+class WeightSyncWorkerExtension:
+ """
+ A vLLM worker extension that enables weight synchronization between a client and multiple server workers.
+
+ This worker uses a `StatelessProcessGroup` to establish communication and a `PyNcclCommunicator` or
+ `ProcessGroupXCCL` to handle efficient GPU-based communication using NCCL. The primary purpose of this class is to
+ receive updated model weights from a client process and distribute them to all worker processes participating in
+ model inference.
+ """
+
+ # The following attributes are initialized when `init_communicator` method is called.
+ communicator = None # Communicator for weight updates
+ client_rank = None # Source rank for broadcasting updated weights
+
+ def init_communicator(self, host: str, port: int, world_size: int, client_device_uuid: str) -> None:
+ """
+ Initializes the weight update communicator using a stateless process group.
+
+ This method creates a `StatelessProcessGroup` that allows external training processes to communicate with vLLM
+ workers without interfering with the global torch distributed group.
+
+ Args:
+ host (`str`):
+ Hostname or IP address of the master node.
+ port (`int`):
+ Port number to be used for communication.
+ world_size (`int`):
+ Total number of participating processes in the update group.
+ client_device_uuid (`str`):
+ UUID of the device of client main process. Used to assert that devices are different from vllm workers
+ devices.
+ """
+ import torch
+ import torch.distributed.distributed_c10d as c10d
+ from transformers import is_torch_xpu_available
+ from vllm.distributed.device_communicators.pynccl import PyNcclCommunicator
+ from vllm.distributed.parallel_state import get_world_group
+ from vllm.distributed.utils import StatelessProcessGroup
+
+ from trl.import_utils import is_vllm_ascend_available
+
+ if is_vllm_ascend_available():
+ from vllm_ascend.distributed.device_communicators.pyhccl import PyHcclCommunicator as PyNcclCommunicator
+
+ if self.communicator is not None:
+ raise RuntimeError("Weight update group already initialized. Call close_communicator first.")
+
+ # TODO: will remove after torch xpu 2.9 support uuid in get_device_properties
+ if torch.cuda.is_available() or (
+ is_torch_xpu_available() and hasattr(torch.xpu.get_device_properties(self.device), "uuid")
+ ):
+ accelerator_module = torch.xpu if is_torch_xpu_available() else torch.cuda
+ if client_device_uuid == str(accelerator_module.get_device_properties(self.device).uuid):
+ raise RuntimeError(
+ f"Attempting to use the same CUDA device (UUID: {client_device_uuid}) for multiple distinct "
+ "roles/ranks within the same communicator. This setup is unsupported and will likely lead to program "
+ "hangs or incorrect behavior. Ensure that trainer is using different devices than vLLM server."
+ )
+ # Get the rank of the current worker in the global world group.
+ rank = get_world_group().rank
+
+ if is_torch_xpu_available():
+ store = torch.distributed.TCPStore(host_name=host, port=port, world_size=world_size, is_master=(rank == 0))
+ prefixed_store = c10d.PrefixStore("client2server", store)
+ xccl_options = c10d.ProcessGroupXCCL.Options()
+ pg = c10d.ProcessGroupXCCL(
+ store=prefixed_store,
+ rank=rank,
+ size=world_size,
+ options=xccl_options,
+ )
+ self.communicator = pg
+ else:
+ # Create a stateless process group to manage communication between training processes and vLLM workers.
+ # Initialize the NCCL-based communicator for weight synchronization.
+ pg = StatelessProcessGroup.create(host=host, port=port, rank=rank, world_size=world_size)
+ self.communicator = PyNcclCommunicator(pg, device=self.device)
+
+ # The client process that sends updated weights has the highest rank (world_size - 1).
+ self.client_rank = world_size - 1
+
+ def update_named_param(self, name: str, dtype: str, shape: Sequence[int]) -> None:
+ """
+ Receives updated weights from the client process and updates the named parameter in the model.
+
+ Args:
+ name (`str`):
+ Name of the weight tensor being updated.
+ dtype (`str`):
+ Data type of the weight tensor as a string (e.g., `"torch.float32"`).
+ shape (`Sequence[int]`):
+ Shape of the weight tensor.
+ """
+ import torch
+ from transformers import is_torch_xpu_available
+
+ if self.communicator is None:
+ raise RuntimeError("Communicator not initialized. Call `init_communicator` first.")
+
+ dtype = getattr(torch, dtype.split(".")[-1])
+ # Allocate memory for the incoming weight tensor on the correct device.
+ weight = torch.empty(shape, dtype=dtype, device=self.device)
+
+ if is_torch_xpu_available():
+ # Use XCCL to broadcast the updated weights from the client (src) to all workers.
+ self.communicator.broadcast(weight, root=self.client_rank)
+ self.communicator.barrier()
+ else:
+ # Use NCCL to broadcast the updated weights from the client (src) to all workers.
+ self.communicator.broadcast(weight, src=self.client_rank)
+ self.communicator.group.barrier()
+
+ # Load the received weights into the model.
+ self.model_runner.model.load_weights(weights=[(name, weight)])
+
+ def close_communicator(self) -> None:
+ """
+ Closes the communicator when weight synchronization is no longer needed.
+
+ This method deletes the NCCL communicator to release associated resources.
+ """
+
+ if self.communicator is not None:
+ del self.communicator
+ self.communicator = None # Ensure attribute is reset to None
+ self.client_rank = None # Ensure attribute is reset to None
+
+
+@dataclass
+class ScriptArguments:
+ r"""
+ Arguments for the script.
+
+ Args:
+ model (`str`):
+ Model name or path to load the model from.
+ revision (`str`, *optional*):
+ Revision to use for the model. If not specified, the default branch will be used.
+ tensor_parallel_size (`int`, *optional*, defaults to `1`):
+ Number of tensor parallel workers to use.
+ data_parallel_size (`int`, *optional*, defaults to `1`):
+ Number of data parallel workers to use. For dense models, keep this at 1. Starting from vLLM `0.14.0`,
+ setting this above `1` for dense models is no longer supported/useful and will error out (see vLLM PR
+ #30739).
+ host (`str`, *optional*, defaults to `"0.0.0.0"`):
+ Host address to run the server on.
+ port (`int`, *optional*, defaults to `8000`):
+ Port to run the server on.
+ gpu_memory_utilization (`float`, *optional*, defaults to `0.9`):
+ Ratio (between 0 and 1) of GPU memory to reserve for the model weights, activations, and KV cache on the
+ device dedicated to generation powered by vLLM. Higher values will increase the KV cache size and thus
+ improve the model's throughput. However, if the value is too high, it may cause out-of-memory (OOM) errors
+ during initialization.
+ dtype (`str`, *optional*, defaults to `"auto"`):
+ Data type to use for vLLM generation. If set to `"auto"`, the data type will be automatically determined
+ based on the model configuration. Find the supported values in the vLLM documentation.
+ max_model_len (`int`, *optional*):
+ If set, the `max_model_len` to use for vLLM. This can be useful when running with reduced
+ `vllm_gpu_memory_utilization`, leading to a reduced KV cache size. If not set, vLLM will use the model
+ context size, which might be much larger than the KV cache, leading to inefficiencies.
+ enable_prefix_caching (`bool`, *optional*):
+ Whether to enable prefix caching in vLLM. If set to `True`, ensure that the model and the hardware support
+ this feature.
+ enforce_eager (`bool`, *optional*, defaults to `False`):
+ Whether to enforce eager execution. If set to `True`, we will disable CUDA graph and always execute the
+ model in eager mode. If `False` (default behavior), we will use CUDA graph and eager execution in hybrid.
+ vllm_model_impl (`str`, *optional*, defaults to `"vllm"`):
+ Model implementation to use for vLLM. Must be one of `"transformers"` or `"vllm"`. `"transformers"`: Use
+ the `transformers` backend for model implementation. `"vllm"`: Use the `vllm` library for model
+ implementation.
+ kv_cache_dtype (`str`, *optional*, defaults to `"auto"`):
+ Data type to use for KV cache. If set to `"auto"`, the dtype will default to the model data type.
+ trust_remote_code (`bool`, *optional*, defaults to `False`):
+ Whether to trust remote code when loading models. Set to `True` to allow executing code from model
+ repositories. This is required for some custom models but introduces security risks.
+ log_level (`str`, *optional*, defaults to `"info"`):
+ Log level for uvicorn. Possible choices: `"critical"`, `"error"`, `"warning"`, `"info"`, `"debug"`,
+ `"trace"`.
+ distributed_executor_backend (`str` or `None`, *optional*):
+ Distributed executor backend for vLLM. Set to `"ray"` to distribute tensor parallel workers across multiple
+ nodes via a Ray cluster. Required when `tensor_parallel_size` exceeds the number of local GPUs. If not set,
+ vLLM defaults to the multiproc backend (single-node only).
+ speculative_config (`str`, *optional*):
+ JSON string for vLLM speculative decoding config, forwarded to `LLM(speculative_config=...)`. When unset,
+ speculative decoding is disabled. Example: `'{"method": "qwen3_next_mtp", "num_speculative_tokens": 5}'`.
+ """
+
+ model: str = field(
+ metadata={"help": "Model name or path to load the model from."},
+ )
+ revision: str | None = field(
+ default=None,
+ metadata={"help": "Revision to use for the model. If not specified, the default branch will be used."},
+ )
+ tensor_parallel_size: int = field(
+ default=1,
+ metadata={"help": "Number of tensor parallel workers to use."},
+ )
+ data_parallel_size: int = field(
+ default=1,
+ metadata={
+ "help": "Number of data parallel workers to use. For dense models, keep this at 1. Starting from vLLM "
+ "`0.14.0`, setting this above `1` for dense models is no longer supported/useful and will error out (see "
+ "vLLM PR #30739)."
+ },
+ )
+ host: str = field(
+ default="0.0.0.0",
+ metadata={"help": "Host address to run the server on."},
+ )
+ port: int = field(
+ default=8000,
+ metadata={"help": "Port to run the server on."},
+ )
+ gpu_memory_utilization: float = field(
+ default=0.9,
+ metadata={
+ "help": "Ratio (between 0 and 1) of GPU memory to reserve for the model weights, activations, and KV "
+ "cache on the device dedicated to generation powered by vLLM. Higher values will increase the KV cache "
+ "size and thus improve the model's throughput. However, if the value is too high, it may cause "
+ "out-of-memory (OOM) errors during initialization."
+ },
+ )
+ dtype: str = field(
+ default="auto",
+ metadata={
+ "help": "Data type to use for vLLM generation. If set to 'auto', the data type will be automatically "
+ "determined based on the model configuration. Find the supported values in the vLLM documentation."
+ },
+ )
+ max_model_len: int | None = field(
+ default=None,
+ metadata={
+ "help": "If set, the `max_model_len` to use for vLLM. This can be useful when running with reduced "
+ "`vllm_gpu_memory_utilization`, leading to a reduced KV cache size. If not set, vLLM will use the model "
+ "context size, which might be much larger than the KV cache, leading to inefficiencies."
+ },
+ )
+ enable_prefix_caching: bool | None = field(
+ default=None,
+ metadata={
+ "help": "Whether to enable prefix caching in vLLM. If set to `True`, ensure that the model and the "
+ "hardware support this feature."
+ },
+ )
+ enforce_eager: bool | None = field(
+ default=False,
+ metadata={
+ "help": "Whether to enforce eager execution. If set to `True`, we will disable CUDA graph and always "
+ "execute the model in eager mode. If `False` (default behavior), we will use CUDA graph and eager "
+ "execution in hybrid."
+ },
+ )
+ kv_cache_dtype: str = field(
+ default="auto",
+ metadata={
+ "help": "Data type to use for KV cache. If set to 'auto', the dtype will default to the model data type."
+ },
+ )
+ trust_remote_code: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to trust remote code when loading models. Set to True to allow executing code from model "
+ "repositories. This is required for some custom models but introduces security risks."
+ },
+ )
+ log_level: str = field(
+ default="info",
+ metadata={
+ "help": "Log level for uvicorn. Possible choices: 'critical', 'error', 'warning', 'info', 'debug', "
+ "'trace'."
+ },
+ )
+ vllm_model_impl: str = field(
+ default="vllm",
+ metadata={
+ "help": "Model implementation to use for vLLM. Must be one of `transformers` or `vllm`. `transformers`: "
+ "Use the `transformers` backend for model implementation. `vllm`: Use the `vllm` library for "
+ "model implementation."
+ },
+ )
+ distributed_executor_backend: str | None = field(
+ default=None,
+ metadata={
+ "help": "Distributed executor backend for vLLM. When set to 'ray', vLLM uses Ray to distribute tensor "
+ "parallel workers across multiple nodes. Required when tensor_parallel_size exceeds the number of local "
+ "GPUs. If not set, vLLM defaults to the multiproc backend (single-node only)."
+ },
+ )
+ speculative_config: str | None = field(
+ default=None,
+ metadata={
+ "help": "JSON string for vLLM speculative decoding config. "
+ 'Example: \'{"method": "qwen3_next_mtp", "num_speculative_tokens": 5}\''
+ },
+ )
+
+
+def llm_worker(
+ script_args: ScriptArguments, data_parallel_rank: int, master_port: int, connection: Connection
+) -> None:
+ from vllm import LLM
+
+ # Set required environment variables for DP to work with vLLM
+ os.environ["VLLM_DP_RANK"] = str(data_parallel_rank)
+ os.environ["VLLM_DP_RANK_LOCAL"] = str(data_parallel_rank)
+ os.environ["VLLM_DP_SIZE"] = str(script_args.data_parallel_size)
+ os.environ["VLLM_DP_MASTER_PORT"] = str(master_port)
+
+ llm = LLM(
+ model=script_args.model,
+ revision=script_args.revision,
+ tensor_parallel_size=script_args.tensor_parallel_size,
+ gpu_memory_utilization=script_args.gpu_memory_utilization,
+ enforce_eager=script_args.enforce_eager,
+ dtype=script_args.dtype,
+ # Automatic Prefix Caching caches the KV cache of existing queries, so that a new query can
+ # directly reuse the KV cache if it shares the same prefix with one of the existing queries.
+ # This is particularly useful here because we generate completions from the same prompts.
+ enable_prefix_caching=script_args.enable_prefix_caching,
+ kv_cache_dtype=script_args.kv_cache_dtype,
+ max_model_len=script_args.max_model_len,
+ worker_extension_cls="trl.scripts.vllm_serve.WeightSyncWorkerExtension",
+ trust_remote_code=script_args.trust_remote_code,
+ model_impl=script_args.vllm_model_impl,
+ distributed_executor_backend=script_args.distributed_executor_backend,
+ # Important so temperature scaling/logit tweaking affects the TIS log probs
+ logprobs_mode="processed_logprobs",
+ speculative_config=json.loads(script_args.speculative_config) if script_args.speculative_config else None,
+ )
+
+ # Send ready signal to parent process
+ connection.send({"status": "ready"})
+
+ while True:
+ # Wait for commands from the parent process
+ try:
+ command = connection.recv()
+ except KeyboardInterrupt:
+ llm.collective_rpc(method="close_communicator")
+ break
+
+ # Handle commands
+ if command["type"] in ["call", "fire_and_forget"]:
+ method_name = command["method"]
+ args, kwargs = command.get("args", ()), command.get("kwargs", {})
+ method = getattr(llm, method_name)
+ result = method(*args, **kwargs)
+ if command["type"] == "call":
+ connection.send(result)
+ elif command["type"] == "shutdown":
+ break
+
+
+def chunk_list(lst: list, n: int) -> list[list]:
+ """
+ Split list `lst` into `n` evenly distributed sublists.
+
+ Example:
+ ```python
+ >>> chunk_list([1, 2, 3, 4, 5, 6], 2)
+ [[1, 2, 3], [4, 5, 6]]
+
+ >>> chunk_list([1, 2, 3, 4, 5, 6], 4)
+ [[1, 2], [3, 4], [5], [6]]
+
+ >>> chunk_list([1, 2, 3, 4, 5, 6], 8)
+ [[1], [2], [3], [4], [5], [6], [], []]
+ ```
+ """
+ k, r = divmod(len(lst), n)
+ return [lst[i * k + min(i, r) : (i + 1) * k + min(i + 1, r)] for i in range(n)]
+
+
+def main(script_args: ScriptArguments):
+ import asyncio
+
+ from transformers import is_vision_available
+
+ from trl.generation.vllm_generation import extract_logprobs
+ from trl.import_utils import (
+ is_fastapi_available,
+ is_pydantic_available,
+ is_uvicorn_available,
+ is_vllm_available,
+ )
+
+ if not is_fastapi_available():
+ raise ImportError(
+ "FastAPI is required to run the vLLM serve script. Please install it using `pip install fastapi`."
+ )
+
+ if not is_pydantic_available():
+ raise ImportError(
+ "Pydantic is required to run the vLLM serve script. Please install it using `pip install pydantic`."
+ )
+
+ if not is_uvicorn_available():
+ raise ImportError(
+ "Uvicorn is required to run the vLLM serve script. Please install it using `pip install uvicorn`."
+ )
+
+ if not is_vllm_available():
+ raise ImportError("vLLM is required to run the vLLM serve script. Please install it using `pip install vllm`.")
+
+ import uvicorn
+ from fastapi import FastAPI
+ from pydantic import BaseModel
+ from vllm import SamplingParams
+ from vllm.sampling_params import StructuredOutputsParams
+ from vllm.utils.network_utils import get_open_port
+
+ if is_vision_available():
+ from PIL import Image
+
+ logger = logging.getLogger(__name__)
+
+ # Spawn dp workers, and setup pipes for communication
+ master_port = get_open_port()
+ connections = []
+ processes = []
+ for data_parallel_rank in range(script_args.data_parallel_size):
+ parent_connection, child_connection = Pipe()
+ process = Process(target=llm_worker, args=(script_args, data_parallel_rank, master_port, child_connection))
+ process.start()
+ connections.append(parent_connection)
+ processes.append(process)
+
+ @asynccontextmanager
+ async def lifespan(app: FastAPI):
+ # Wait for all workers to send "ready"
+ ready_connections = set()
+ while len(ready_connections) < script_args.data_parallel_size:
+ for connection in connections:
+ msg = connection.recv()
+ if isinstance(msg, dict) and msg.get("status") == "ready":
+ ready_connections.add(connection)
+
+ # Start the logprob request batcher background task
+ batcher_task = asyncio.create_task(_logprob_batcher())
+
+ yield
+
+ batcher_task.cancel()
+
+ # Wait for processes to terminate
+ for process in processes:
+ process.join(timeout=10) # Wait for 10 seconds for the process to terminate
+ if process.is_alive():
+ logger.warning(f"Process {process} is still alive after 10 seconds, attempting to terminate...")
+ process.terminate()
+ process.join() # ensure process termination after calling terminate()
+
+ app = FastAPI(lifespan=lifespan)
+
+ # Define the endpoints for the model server
+ @app.get("/health/")
+ async def health():
+ """
+ Health check endpoint to verify that the server is running.
+ """
+ return {"status": "ok"}
+
+ @app.get("/get_world_size/")
+ async def get_world_size():
+ """
+ Retrieves the world size of the LLM engine, which is `tensor_parallel_size * data_parallel_size`.
+
+ Returns:
+ `dict`:
+ A dictionary containing the world size.
+
+ Example response:
+ ```json
+ {"world_size": 8}
+ ```
+ """
+ return {"world_size": script_args.tensor_parallel_size * script_args.data_parallel_size}
+
+ class GenerateRequest(BaseModel):
+ prompts: list[str] | list[list[int]]
+ images: list[list[str] | None] | None = None
+ n: int = 1
+ repetition_penalty: float = 1.0
+ temperature: float = 1.0
+ top_p: float = 1.0
+ top_k: int = -1
+ min_p: float = 0.0
+ max_tokens: int = 16
+ logprobs: int | None = 0
+ structured_outputs_regex: str | None = None
+ generation_kwargs: dict = field(default_factory=dict)
+
+ class GenerateResponse(BaseModel):
+ prompt_ids: list[list[int]]
+ completion_ids: list[list[int]]
+ logprobs: list[list[list[float | None]]] | None
+ logprob_token_ids: list[list[list[int]]] | None
+
+ @app.post("/generate/", response_model=GenerateResponse)
+ async def generate(request: GenerateRequest):
+ """
+ Generates completions for the provided prompts.
+
+ Args:
+ request (`GenerateRequest`):
+ - `prompts` (list of `str` or list of list of `int`): A list of prompts. It accepts either text strings
+ or pre-tokenized token ID lists. When text strings are provided, `images` can optionally be included.
+ - `images` (list of list of `str` or `None`, *optional*): A list of image lists. Each element is a list
+ of base64-encoded images for the corresponding prompt, or `None` if no images for that prompt.
+ - `n` (`int`, *optional*, defaults to `1`): Number of completions to generate for each prompt.
+ - `repetition_penalty` (`float`, *optional*, defaults to `1.0`): Repetition penalty to apply during
+ generation.
+ - `temperature` (`float`, *optional*, defaults to `1.0`): Temperature for sampling. Higher values lead
+ to more random outputs.
+ - `top_p` (`float`, *optional*, defaults to `1.0`): Top-p (nucleus) sampling parameter. It controls the
+ diversity of the generated text.
+ - `top_k` (`int`, *optional*, defaults to `-1`): Top-k sampling parameter. If set to `-1`, it disables
+ top-k sampling.
+ - `min_p` (`float`, *optional*, defaults to `0.0`): Minimum probability threshold for sampling.
+ - `max_tokens` (`int`, *optional*, defaults to `16`): Maximum number of tokens to generate for each
+ completion.
+ - `logprobs` (`int`, *optional*, defaults to `0`): Number of top logprobs to return per token. When 0,
+ only the sampled token's logprob is returned. When N>0, returns up to N+1 logprobs sorted by
+ descending probability, because vLLM always includes the sampled token's logprob (which may fall
+ outside the top-N).
+ - `structured_outputs_regex` (`str`, *optional*): A regex pattern for structured outputs. If provided,
+ the model will only generate tokens that match this regex pattern.
+ - `generation_kwargs` (`dict`, *optional*): Additional generation parameters to pass to the vLLM
+ `SamplingParams`. This can include parameters like `seed`, `frequency_penalty`, etc. If it contains
+ keys that conflict with the other parameters, they will override them.
+
+ Returns:
+ `GenerateResponse`:
+ - `prompt_ids` (list of list of `int`): A list of lists of token IDs for each input prompt.
+ - `completion_ids` (list of list of `int`): A list of lists of token IDs for each generated completion.
+ - `logprobs` (list of list of list of `float`): Per-token logprobs of shape (num_sequences, seq_len,
+ num_logprobs), sorted by descending probability.
+ - `logprob_token_ids` (list of list of list of `int`): Token IDs corresponding to each logprob, same
+ shape as `logprobs`.
+
+ Example request (text prompts):
+ ```json
+ {"prompts": ["Hello world", "What is AI?"]}
+ ```
+
+ Example request (token IDs):
+ ```json
+ {"prompts": [[101, 102], [201, 202]]}
+ ```
+
+ Example response:
+ ```json
+ {
+ "prompt_ids": [[101, 102], [201, 202]],
+ "completion_ids": [[103, 104, 105], [203, 204, 205]],
+ "logprobs": [[[-0.1], [-0.2], [-0.3]], [[-0.4], [-0.5], [-0.6]]],
+ "logprob_token_ids": [[[103], [104], [105]], [[203], [204], [205]]]
+ }
+ ```
+ """
+ # Build vLLM-compatible prompt inputs
+ is_token_ids = request.prompts and isinstance(request.prompts[0], list)
+ request.images = request.images or [None] * len(request.prompts)
+
+ prompts = []
+ for prompt, image_list in zip(request.prompts, request.images, strict=True):
+ row = {"prompt_token_ids": prompt} if is_token_ids else {"prompt": prompt}
+ if image_list is not None:
+ row["multi_modal_data"] = {"image": [Image.open(BytesIO(base64.b64decode(img))) for img in image_list]}
+ prompts.append(row)
+
+ generation_kwargs = {
+ "n": request.n,
+ "repetition_penalty": request.repetition_penalty,
+ "temperature": request.temperature,
+ "top_p": request.top_p,
+ "top_k": request.top_k,
+ "min_p": request.min_p,
+ "max_tokens": request.max_tokens,
+ "logprobs": request.logprobs,
+ }
+ generation_kwargs.update(request.generation_kwargs)
+
+ # Structured outputs, if enabled
+ if request.structured_outputs_regex is not None:
+ if generation_kwargs.get("structured_outputs") is not None:
+ logger.warning(
+ "Both `structured_outputs_regex` and `generation_kwargs['structured_outputs']` are set; "
+ "`structured_outputs_regex` takes precedence."
+ )
+ generation_kwargs["structured_outputs"] = StructuredOutputsParams(regex=request.structured_outputs_regex)
+ elif isinstance(structured_outputs_kwargs := generation_kwargs.get("structured_outputs"), dict):
+ generation_kwargs["structured_outputs"] = StructuredOutputsParams(**structured_outputs_kwargs)
+ sampling_params = SamplingParams(**generation_kwargs)
+
+ # Evenly distribute prompts across DP ranks
+ chunked_prompts = chunk_list(prompts, script_args.data_parallel_size)
+
+ # Send the prompts to each worker
+ for connection, prompts in zip(connections, chunked_prompts, strict=True):
+ # When the number of prompts is less than data_parallel_size, some workers will receive empty prompts.
+ # However, vLLM requires that we always send at least one prompt. So we send a placeholder prompt to comply
+ # with vLLM's requirement, and we later ignore the result.
+ if not prompts:
+ prompts = [""]
+ kwargs = {"prompts": prompts, "sampling_params": sampling_params}
+ connection.send({"type": "call", "method": "generate", "kwargs": kwargs})
+
+ # Receive results
+ all_outputs = [connection.recv() for connection in connections]
+
+ # Handle empty prompts (see above)
+ all_outputs = [output for output, prompts in zip(all_outputs, chunked_prompts, strict=True) if prompts]
+
+ # Flatten and combine all results
+ all_outputs = list(chain.from_iterable(all_outputs)) # from list of list to single list
+ prompt_ids = [output.prompt_token_ids for output in all_outputs]
+ completion_ids = [list(output.token_ids) for outputs in all_outputs for output in outputs.outputs]
+ logprobs, logprob_token_ids = extract_logprobs(all_outputs)
+
+ return {
+ "prompt_ids": prompt_ids,
+ "completion_ids": completion_ids,
+ "logprobs": logprobs,
+ "logprob_token_ids": logprob_token_ids,
+ }
+
+ class SequenceLogprobsRequest(BaseModel):
+ sequences: list[list[int]]
+ prompt_lengths: list[int]
+ top_logprobs: int = 100
+ temperature: float = 1.0
+ response_format: str = "json" # "json" (legacy) or "binary" (base64 numpy arrays)
+
+ class SequenceLogprobsResponse(BaseModel):
+ logprobs: list[list[list[float | None]]] | None = None
+ logprob_token_ids: list[list[list[int]]] | None = None
+ # Binary format fields (base64-encoded numpy arrays)
+ logprobs_b64: str | None = None
+ token_ids_b64: str | None = None
+ actual_logprobs_b64: str | None = None
+ actual_token_ids_b64: str | None = None
+ shape: list[int] | None = None # [batch_size, max_completion_len, top_logprobs]
+ completion_lengths: list[int] | None = None # actual completion length per sample
+
+ def _run_prompt_logprobs(prompts, sampling_params):
+ """Send prompts to DP workers and collect outputs."""
+ chunked_prompts = chunk_list(prompts, script_args.data_parallel_size)
+ for connection, chunk in zip(connections, chunked_prompts, strict=True):
+ if not chunk:
+ chunk = [{"prompt_token_ids": [0]}]
+ kwargs = {"prompts": chunk, "sampling_params": sampling_params}
+ connection.send({"type": "call", "method": "generate", "kwargs": kwargs})
+ all_outputs = [connection.recv() for connection in connections]
+ all_outputs = [output for output, chunk in zip(all_outputs, chunked_prompts, strict=True) if chunk]
+ return list(chain.from_iterable(all_outputs))
+
+ # ── Request batching for get_sequence_logprobs ──
+ # Collects concurrent requests into batches and dispatches them together so that
+ # all DP workers stay busy. Without this, async endpoint handlers block the event
+ # loop during pipe I/O, serializing requests and leaving DP workers idle.
+ _logprob_queue: asyncio.Queue = asyncio.Queue()
+
+ # Maximum time (seconds) to wait for more requests before dispatching a batch.
+ _BATCH_WAIT_S = 0.005 # 5ms - short enough to not add much latency when lightly loaded
+ # Maximum number of HTTP requests to collect per batcher cycle
+ _MAX_BATCH_REQUESTS = max(script_args.data_parallel_size * 4, 16)
+ # Maximum total tokens per batch. prompt_logprobs materializes full-vocab logits
+ # during the forward pass, so each worker can safely handle ~1 max-length sequence.
+ # Budget = max_model_len * dp_size gives ~1 sequence per worker at max length.
+ _max_model_len = script_args.max_model_len or 8192
+ _MAX_BATCH_TOKENS = _max_model_len * script_args.data_parallel_size
+
+ async def _logprob_batcher():
+ """Background task that continuously drains the queue, batches requests, and dispatches."""
+ loop = asyncio.get_running_loop()
+
+ while True:
+ batch = []
+ try:
+ # Wait for the first request
+ batch_tokens = 0
+ item = await _logprob_queue.get()
+ batch.append(item)
+ # Count tokens in this item's sequences
+ for prompt in item[0]:
+ batch_tokens += len(prompt.get("prompt_token_ids", []))
+
+ # Collect more requests up to batch limit, timeout, or token budget
+ deadline = loop.time() + _BATCH_WAIT_S
+ while len(batch) < _MAX_BATCH_REQUESTS and batch_tokens < _MAX_BATCH_TOKENS:
+ remaining = deadline - loop.time()
+ if remaining <= 0:
+ break
+ try:
+ item = await asyncio.wait_for(_logprob_queue.get(), timeout=remaining)
+ # Check if adding this item would exceed the token budget
+ item_tokens = sum(len(p.get("prompt_token_ids", [])) for p in item[0])
+ if batch_tokens + item_tokens > _MAX_BATCH_TOKENS and len(batch) > 0:
+ # Put it back and dispatch current batch
+ await _logprob_queue.put(item)
+ break
+ batch.append(item)
+ batch_tokens += item_tokens
+ except asyncio.TimeoutError:
+ break
+
+ # batch is a list of (prompts, prompt_lengths, top_logprobs, temperature, response_format, future)
+ # All items in a batch must share the same (top_logprobs, temperature) pair.
+ # Group by those execution parameters to handle mixed requests.
+ groups = {}
+ for prompts, prompt_lengths, top_logprobs, temperature, response_format, future in batch:
+ key = (top_logprobs, temperature)
+ if key not in groups:
+ groups[key] = []
+ groups[key].append((prompts, prompt_lengths, response_format, future))
+
+ for (top_logprobs, temperature), items in groups.items():
+ # Merge all sequences into a single batch
+ all_prompts = []
+ all_prompt_lengths = []
+ offsets = [] # (start_idx, count) per original request
+ for prompts, prompt_lengths, _response_format, _future in items:
+ start = len(all_prompts)
+ all_prompts.extend(prompts)
+ all_prompt_lengths.extend(prompt_lengths)
+ offsets.append((start, len(prompts)))
+
+ sampling_params = SamplingParams(
+ max_tokens=1,
+ temperature=temperature,
+ prompt_logprobs=top_logprobs,
+ )
+
+ # Dispatch to workers in a thread to avoid blocking the event loop
+ try:
+ all_outputs = await loop.run_in_executor(
+ None, _run_prompt_logprobs, all_prompts, sampling_params
+ )
+
+ # Split results back to individual requests
+ for (start, count), (_, prompt_lengths, response_format, future) in zip(
+ offsets, items, strict=True
+ ):
+ outputs_slice = all_outputs[start : start + count]
+ if not future.done():
+ future.set_result((outputs_slice, prompt_lengths, top_logprobs, response_format))
+ except Exception as e:
+ # Signal error to all waiting requests in this execution-parameter group
+ for *_, future in items:
+ if not future.done():
+ future.set_exception(e)
+ except Exception as e:
+ # Prevent killing the batcher task — signal error to all unfulfilled futures
+ for *_, future in batch:
+ if not future.done():
+ future.set_exception(e)
+
+ def _format_logprob_response(all_outputs, prompt_lengths, top_k, response_format):
+ """Format vLLM outputs into the response dict (runs in any thread)."""
+ import numpy as np
+
+ batch_size = len(all_outputs)
+ use_binary = response_format == "binary"
+
+ if use_binary:
+ from starlette.responses import Response
+
+ comp_lengths = []
+ for output, prompt_length in zip(all_outputs, prompt_lengths, strict=True):
+ prompt_lps = output.prompt_logprobs
+ if prompt_lps is None:
+ raise ValueError("prompt_logprobs is None.")
+ comp_lengths.append(len(prompt_lps) - prompt_length)
+
+ max_comp_len = max(comp_lengths) if comp_lengths else 0
+
+ # logprobs_arr / token_ids_arr: teacher's sorted top-k logprobs + token ids (for forward KL).
+ # actual_logprobs_arr / actual_token_ids_arr: actual token's teacher logprob (for reverse KL).
+ logprobs_arr = np.full((batch_size, max_comp_len, top_k), float("-inf"), dtype=np.float32)
+ token_ids_arr = np.zeros((batch_size, max_comp_len, top_k), dtype=np.int32)
+ actual_logprobs_arr = np.full((batch_size, max_comp_len, 1), float("-inf"), dtype=np.float32)
+ actual_token_ids_arr = np.zeros((batch_size, max_comp_len, 1), dtype=np.int32)
+
+ for i, (output, prompt_length) in enumerate(zip(all_outputs, prompt_lengths, strict=True)):
+ prompt_lps = output.prompt_logprobs
+ seq_tokens = output.prompt_token_ids
+ if comp_lengths[i] == 0:
+ continue
+
+ for pos in range(prompt_length, len(prompt_lps)):
+ lp = prompt_lps[pos]
+ if lp is None:
+ continue
+ t = pos - prompt_length
+ actual_token = seq_tokens[pos]
+
+ # Actual token's logprob (for reverse KL)
+ if actual_token in lp:
+ val = lp[actual_token].logprob
+ if not math.isnan(val):
+ actual_logprobs_arr[i, t, 0] = val
+ actual_token_ids_arr[i, t, 0] = actual_token
+
+ # Teacher's top-k logprobs (for forward KL)
+ if top_k == 1:
+ # Fast path: find rank-1 directly instead of sorting
+ for token_id, logprob_obj in lp.items():
+ if logprob_obj.rank == 1:
+ val = logprob_obj.logprob
+ if not math.isnan(val):
+ logprobs_arr[i, t, 0] = val
+ token_ids_arr[i, t, 0] = token_id
+ break
+ else:
+ sorted_items = sorted(lp.items(), key=lambda x: x[1].rank)
+ for k_idx, (token_id, logprob_obj) in enumerate(sorted_items[:top_k]):
+ val = logprob_obj.logprob
+ if not math.isnan(val):
+ logprobs_arr[i, t, k_idx] = val
+ token_ids_arr[i, t, k_idx] = token_id
+
+ payload = {
+ "logprobs_b64": base64.b64encode(logprobs_arr.tobytes()).decode("ascii"),
+ "token_ids_b64": base64.b64encode(token_ids_arr.tobytes()).decode("ascii"),
+ "actual_logprobs_b64": base64.b64encode(actual_logprobs_arr.tobytes()).decode("ascii"),
+ "actual_token_ids_b64": base64.b64encode(actual_token_ids_arr.tobytes()).decode("ascii"),
+ "shape": [batch_size, max_comp_len, top_k],
+ "completion_lengths": comp_lengths,
+ }
+
+ try:
+ import orjson
+
+ return Response(content=orjson.dumps(payload), media_type="application/json")
+ except ImportError:
+ return payload
+ else:
+ all_logprobs = []
+ all_token_ids = []
+ for output, prompt_length in zip(all_outputs, prompt_lengths, strict=True):
+ prompt_lps = output.prompt_logprobs
+ if prompt_lps is None:
+ raise ValueError("prompt_logprobs is None.")
+ seq_logprobs = []
+ seq_token_ids = []
+ for pos in range(prompt_length, len(prompt_lps)):
+ lp = prompt_lps[pos]
+ if lp is None:
+ seq_logprobs.append([])
+ seq_token_ids.append([])
+ continue
+ sorted_items = sorted(lp.items(), key=lambda x: x[1].rank)
+ seq_token_ids.append([token_id for token_id, _ in sorted_items])
+ seq_logprobs.append(
+ [None if math.isnan(item.logprob) else item.logprob for _, item in sorted_items]
+ )
+ all_logprobs.append(seq_logprobs)
+ all_token_ids.append(seq_token_ids)
+ return {"logprobs": all_logprobs, "logprob_token_ids": all_token_ids}
+
+ @app.post("/get_sequence_logprobs/", response_model=SequenceLogprobsResponse)
+ async def get_sequence_logprobs(request: SequenceLogprobsRequest):
+ """
+ Computes teacher logprobs for existing token sequences without generating new tokens.
+
+ Concurrent requests are automatically batched and dispatched together to maximize GPU utilization across DP
+ workers. This avoids the event-loop-blocking problem where synchronous pipe I/O serializes requests despite
+ having multiple DP workers.
+
+ Args:
+ request (`SequenceLogprobsRequest`):
+ - `sequences` (list of list of `int`): Full token sequences (prompt + completion) per sample.
+ - `prompt_lengths` (list of `int`): Number of prompt tokens per sequence; completion logprobs start
+ after each prompt.
+ - `top_logprobs` (`int`, *optional*, defaults to `100`): Number of top teacher logprobs to return per
+ completion position (sorted by vLLM rank).
+ - `temperature` (`float`, *optional*, defaults to `1.0`): Sampling temperature passed to vLLM for
+ logprob computation.
+ - `response_format` (`str`, *optional*, defaults to `"json"`): Either `"json"` (nested lists,
+ backward-compatible) or `"binary"` (base64-encoded numpy arrays for fast serialization).
+
+ Returns:
+ `SequenceLogprobsResponse` or Starlette `Response`:
+ When `response_format` is `"json"`, a JSON object with:
+ - `logprobs` (list of list of list of `float` or `None`): Top-k teacher logprobs per completion token.
+ - `logprob_token_ids` (list of list of list of `int`): Token IDs aligned with `logprobs`.
+ When `response_format` is `"binary"`, a JSON response (Starlette `Response` if `orjson` is installed)
+ whose body is a JSON object with base64-encoded float32/int32 arrays: `logprobs_b64`, `token_ids_b64`,
+ `actual_logprobs_b64`, `actual_token_ids_b64`, plus `shape` (`list[int]`, `[batch_size,
+ max_completion_len, top_k]`) and `completion_lengths` (`list[int]`).
+ """
+ if len(request.sequences) != len(request.prompt_lengths):
+ raise ValueError("sequences and prompt_lengths must have the same length.")
+
+ for i, (seq, pl) in enumerate(zip(request.sequences, request.prompt_lengths, strict=True)):
+ if pl < 0 or pl > len(seq):
+ raise ValueError(
+ f"Sequence {i} has prompt_length={pl} which is out of range [0, {len(seq)}]. "
+ f"prompt_length must be between 0 and the sequence length inclusive."
+ )
+
+ # Validate sequence lengths against max_model_len to prevent worker OOM crashes
+ if _max_model_len:
+ for i, seq in enumerate(request.sequences):
+ if len(seq) > _max_model_len:
+ raise ValueError(
+ f"Sequence {i} has length {len(seq)} which exceeds max_model_len={_max_model_len}. "
+ f"Truncate sequences or increase --max-model-len."
+ )
+
+ prompts = [{"prompt_token_ids": seq} for seq in request.sequences]
+
+ # Submit to the batching queue and await result
+ loop = asyncio.get_running_loop()
+ future = loop.create_future()
+ await _logprob_queue.put(
+ (
+ prompts,
+ list(request.prompt_lengths),
+ request.top_logprobs,
+ request.temperature,
+ request.response_format,
+ future,
+ )
+ )
+
+ # Wait for the batcher to process our request
+ all_outputs, prompt_lengths, top_k, response_format = await future
+
+ return await loop.run_in_executor(
+ None, _format_logprob_response, all_outputs, prompt_lengths, top_k, response_format
+ )
+
+ class ChatRequest(BaseModel):
+ messages: list[list[dict]]
+ n: int = 1
+ repetition_penalty: float = 1.0
+ temperature: float = 1.0
+ top_p: float = 1.0
+ top_k: int = -1
+ min_p: float = 0.0
+ max_tokens: int = 16
+ logprobs: int | None = 0
+ structured_outputs_regex: str | None = None
+ generation_kwargs: dict = field(default_factory=dict)
+ chat_template_kwargs: dict = field(default_factory=dict)
+ tools: list | None = None
+
+ class ChatResponse(BaseModel):
+ prompt_ids: list[list[int]]
+ completion_ids: list[list[int]]
+ logprobs: list[list[list[float | None]]] | None
+ logprob_token_ids: list[list[list[int]]] | None
+
+ @app.post("/chat/", response_model=ChatResponse)
+ async def chat(request: ChatRequest):
+ """
+ Generates completions for the provided chat messages.
+
+ Args:
+ request (`ChatRequest`):
+ - `messages` (list of `dict`): A list of messages (dicts with "role" and "content" keys) for the model
+ to generate completions.
+ - `n` (`int`, *optional*, defaults to `1`): Number of completions to generate for each prompt.
+ - `repetition_penalty` (`float`, *optional*, defaults to `1.0`): Repetition penalty to apply during
+ generation.
+ - `temperature` (`float`, *optional*, defaults to `1.0`): Temperature for sampling. Higher values lead
+ to more random outputs.
+ - `top_p` (`float`, *optional*, defaults to `1.0`): Top-p (nucleus) sampling parameter. It controls the
+ diversity of the generated text.
+ - `top_k` (`int`, *optional*, defaults to `-1`): Top-k sampling parameter. If set to `-1`, it disables
+ top-k sampling.
+ - `min_p` (`float`, *optional*, defaults to `0.0`): Minimum probability threshold for sampling.
+ - `max_tokens` (`int`, *optional*, defaults to `16`): Maximum number of tokens to generate for each
+ completion.
+ - `logprobs` (`int`, *optional*, defaults to `0`): Number of top logprobs to return per token. When 0,
+ only the sampled token's logprob is returned. When N>0, returns up to N+1 logprobs sorted by
+ descending probability, because vLLM always includes the sampled token's logprob (which may fall
+ outside the top-N).
+ - `structured_outputs_regex` (`str`, *optional*): A regex pattern for structured outputs. If provided,
+ the model will only generate tokens that match this regex pattern.
+ - `generation_kwargs` (`dict`, *optional*): Additional generation parameters to pass to the vLLM
+ `SamplingParams`. This can include parameters like `seed`, `frequency_penalty`, etc. If it contains
+ keys that conflict with the other parameters, they will override them.
+ - `chat_template_kwargs` (`dict`, *optional*): Additional keyword arguments to pass to the chat
+ template.
+
+ Returns:
+ `ChatResponse`:
+ - `prompt_ids` (list of list of `int`): A list of lists of token IDs for each input prompt.
+ - `completion_ids` (list of list of `int`): A list of lists of token IDs for each generated completion.
+ - `logprobs` (list of list of list of `float`): Per-token logprobs of shape (num_sequences, seq_len,
+ num_logprobs), sorted by descending probability.
+ - `logprob_token_ids` (list of list of list of `int`): Token IDs corresponding to each logprob, same
+ shape as `logprobs`.
+
+ Example request:
+ ```bash
+ curl -X POST 'http://0.0.0.0:8000/chat/' \
+ -H 'Content-Type: application/json' \
+ -d '{"messages": [[{ "role": "user", "content": "Hello!" }]]}'
+ ```
+
+ Example response:
+ ```json
+ {
+ "prompt_ids": [[151644, 872, 198, 9707, 0, 151645, 198, 151644, 77091, 198]],
+ "completion_ids": [[151667, 198, 32313, 11, 279]],
+ "logprobs": [[[-0.0003], [-3.58e-07], [-0.0902], [-6.39e-05], [-0.0387]]],
+ "logprob_token_ids": [[[151667], [198], [32313], [11], [279]]]
+ }
+ ```
+ """
+ # Convert PIL images to base64 strings
+ for message_list in request.messages:
+ for message in message_list:
+ if isinstance(message["content"], list):
+ for part in message["content"]:
+ if part["type"] == "image_pil":
+ part["image_pil"] = Image.open(BytesIO(base64.b64decode(part["image_pil"])))
+
+ generation_kwargs = {
+ "n": request.n,
+ "repetition_penalty": request.repetition_penalty,
+ "temperature": request.temperature,
+ "top_p": request.top_p,
+ "top_k": request.top_k,
+ "min_p": request.min_p,
+ "max_tokens": request.max_tokens,
+ "logprobs": request.logprobs,
+ }
+ generation_kwargs.update(request.generation_kwargs)
+
+ # Structured outputs, if enabled
+ if request.structured_outputs_regex is not None:
+ if generation_kwargs.get("structured_outputs") is not None:
+ logger.warning(
+ "Both `structured_outputs_regex` and `generation_kwargs['structured_outputs']` are set; "
+ "`structured_outputs_regex` takes precedence."
+ )
+ generation_kwargs["structured_outputs"] = StructuredOutputsParams(regex=request.structured_outputs_regex)
+ elif isinstance(structured_outputs_kwargs := generation_kwargs.get("structured_outputs"), dict):
+ generation_kwargs["structured_outputs"] = StructuredOutputsParams(**structured_outputs_kwargs)
+ sampling_params = SamplingParams(**generation_kwargs)
+
+ # Evenly distribute prompts across DP ranks
+ chunked_messages = chunk_list(request.messages, script_args.data_parallel_size)
+
+ # Send the messages to each worker
+ for connection, messages in zip(connections, chunked_messages, strict=True):
+ # When the number of messages is less than data_parallel_size, some workers will receive empty messages.
+ # However, vLLM requires that we always send at least one prompt. So we send a placeholder prompt to comply
+ # with vLLM's requirement, and we later ignore the result.
+ if not messages:
+ messages = [[{"role": "user", "content": ""}]]
+ kwargs = {
+ "messages": messages,
+ "sampling_params": sampling_params,
+ "chat_template_kwargs": request.chat_template_kwargs,
+ "tools": request.tools,
+ }
+ connection.send({"type": "call", "method": "chat", "kwargs": kwargs})
+
+ # Receive results
+ all_outputs = [connection.recv() for connection in connections]
+
+ # Handle empty prompts (see above)
+ all_outputs = [output for output, prompts in zip(all_outputs, chunked_messages, strict=True) if prompts]
+
+ # Flatten and combine all results
+ all_outputs = list(chain.from_iterable(all_outputs)) # from list of list to single list
+ prompt_ids = [output.prompt_token_ids for output in all_outputs]
+ completion_ids = [list(output.token_ids) for outputs in all_outputs for output in outputs.outputs]
+ logprobs, logprob_token_ids = extract_logprobs(all_outputs)
+
+ return {
+ "prompt_ids": prompt_ids,
+ "completion_ids": completion_ids,
+ "logprobs": logprobs,
+ "logprob_token_ids": logprob_token_ids,
+ }
+
+ class InitCommunicatorRequest(BaseModel):
+ host: str
+ port: int
+ world_size: int
+ client_device_uuid: str
+
+ @app.post("/init_communicator/")
+ async def init_communicator(request: InitCommunicatorRequest):
+ """
+ Initializes the communicator for synchronizing model weights between a client and multiple server workers.
+
+ Args:
+ request (`InitCommunicatorRequest`):
+ - `host` (`str`): Hostname or IP address of the master node.
+ - `port` (`int`): Port number to be used for communication.
+ - `world_size` (`int`): Total number of participating processes in the group.
+ - `client_device_uuid` (`str`): UUID of the device of client main process. Used to assert that devices
+ are different from vLLM workers devices.
+ """
+ world_size = script_args.tensor_parallel_size * script_args.data_parallel_size + 1
+
+ # The function init_communicator is called this way: init_communicator(host, port, world_size)
+ # So with collective_rpc we need to call it this way:
+ # llm.collective_rpc(method="init_communicator", args=(host, port, world_size))
+ kwargs = {
+ "method": "init_communicator",
+ "args": (request.host, request.port, world_size, request.client_device_uuid),
+ }
+ for connection in connections:
+ connection.send({"type": "fire_and_forget", "method": "collective_rpc", "kwargs": kwargs})
+
+ return {"message": "Request received, initializing communicator"}
+
+ class UpdateWeightsRequest(BaseModel):
+ name: str
+ dtype: str
+ shape: list[int]
+
+ @app.post("/update_named_param/")
+ async def update_named_param(request: UpdateWeightsRequest):
+ """
+ Updates the model weights with the provided tensor.
+
+ Once this endpoint is called, the client process should broadcast the updated weights to all server workers.
+
+ Args:
+ request (`UpdateWeightsRequest`):
+ - `name` (`str`): Name of the weight tensor being updated.
+ - `dtype` (`str`): Data type of the weight tensor (e.g., `"torch.float32"`).
+ - `shape` (list of `int`): Shape of the weight
+
+ """
+ # The function update_named_param is called this way: update_named_param("name", "torch.float32", (10, 10))
+ # So with collective_rpc we need to call it this way:
+ # llm.collective_rpc("update_named_param", args=("name", "torch.float32", (10, 10)))
+ kwargs = {"method": "update_named_param", "args": (request.name, request.dtype, tuple(request.shape))}
+ for connection in connections:
+ connection.send({"type": "fire_and_forget", "method": "collective_rpc", "kwargs": kwargs})
+
+ return {"message": "Request received, updating named parameter"}
+
+ @app.post("/reset_prefix_cache/")
+ async def reset_prefix_cache():
+ """
+ Resets the prefix cache for the model.
+ """
+ for connection in connections:
+ connection.send({"type": "call", "method": "reset_prefix_cache"})
+ # Wait for and collect all results
+ all_outputs = [connection.recv() for connection in connections]
+ success = all(output for output in all_outputs)
+ return {"message": "Request received, resetting prefix cache status: " + str(success)}
+
+ @app.post("/close_communicator/")
+ async def close_communicator():
+ """
+ Closes the weight update group and cleans up associated resources.
+ """
+ kwargs = {"method": "close_communicator"}
+ for connection in connections:
+ connection.send({"type": "fire_and_forget", "method": "collective_rpc", "kwargs": kwargs})
+ return {"message": "Request received, closing communicator"}
+
+ # Start the server
+ uvicorn.run(app, host=script_args.host, port=script_args.port, log_level=script_args.log_level)
+
+
+def make_parser(subparsers: argparse._SubParsersAction | None = None, prog: str | None = None):
+ from trl import TrlParser
+
+ if subparsers is not None:
+ parser = subparsers.add_parser("vllm-serve", help="Run the vLLM serve script", dataclass_types=ScriptArguments)
+ else:
+ parser = TrlParser(ScriptArguments, prog=prog)
+ return parser
+
+
+if __name__ == "__main__":
+ parser = make_parser()
+ (script_args,) = parser.parse_args_and_config()
+ main(script_args)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/skills/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/skills/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..29603ebfd06c6042f7892ccff7426cf38a2936b7
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/skills/__init__.py
@@ -0,0 +1,21 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .skills import (
+ install_skill,
+ list_agent_names,
+ list_skills,
+ resolve_target_path,
+ uninstall_skill,
+)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/skills/cli.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/skills/cli.py
new file mode 100644
index 0000000000000000000000000000000000000000..712f50d1b0b61d751a547dc99224d71b934785fc
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/skills/cli.py
@@ -0,0 +1,199 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+CLI commands for TRL skills installation and management.
+
+This module provides command-line interface for installing TRL skills to various AI agent directories.
+"""
+
+import argparse
+
+from .skills import install_skill, list_agent_names, list_skills, resolve_target_path, uninstall_skill
+
+
+def add_skills_subcommands(subparsers: argparse._SubParsersAction) -> None:
+ """
+ Add skills subcommands to the parser.
+
+ This creates nested subcommands under 'trl skills' for managing skill installations.
+
+ Args:
+ subparsers: Subparsers from 'trl skills' command
+ """
+ # Parent parser for common target options
+ target_parser = argparse.ArgumentParser(add_help=False)
+ target_parser.add_argument(
+ "--target",
+ default="agents",
+ help=f"Installation target: agent name ({', '.join(list_agent_names())}) or directory path",
+ )
+ target_parser.add_argument(
+ "--scope",
+ choices=["project", "global"],
+ default="project",
+ help="Scope when using --target with agent name: project (./agents/skills/) or global (user-level like ~/.agents/skills/)",
+ )
+
+ # trl skills list (no target required - lists TRL's built-in skills by default)
+ list_parser = subparsers.add_parser(
+ "list",
+ help="List available TRL skills or installed skills in a target",
+ description="Show TRL skills available for installation, or if --target is specified, show installed skills",
+ )
+ list_parser.add_argument(
+ "--target",
+ help="Optional: show installed skills in target (agent name or directory path)",
+ )
+ list_parser.add_argument(
+ "--scope",
+ choices=["project", "global"],
+ default="project",
+ help="Scope when using --target with agent name: project (./agents/skills/) or global (user-level like ~/.agents/skills/)",
+ )
+ list_parser.set_defaults(func=cmd_list)
+
+ # trl skills install
+ install_parser = subparsers.add_parser(
+ "install",
+ parents=[target_parser],
+ help="Install skill",
+ description="Install TRL skill to target",
+ )
+ install_parser.add_argument("skill", nargs="?", help="Skill name to install (omit to use --all)")
+ install_parser.add_argument("--all", action="store_true", help="Install all available TRL skills")
+ install_parser.add_argument("--force", action="store_true", help="Overwrite if skill already exists")
+ install_parser.set_defaults(func=cmd_install)
+
+ # trl skills uninstall
+ uninstall_parser = subparsers.add_parser(
+ "uninstall",
+ parents=[target_parser],
+ help="Uninstall skill from target",
+ description="Remove a TRL skill from an AI agent's skills directory",
+ )
+ uninstall_parser.add_argument("skill", help="Skill name to uninstall")
+ uninstall_parser.set_defaults(func=cmd_uninstall)
+
+
+def cmd_install(args):
+ """Handle 'trl skills install' command."""
+ # Validate arguments
+ if not args.skill and not args.all:
+ print("Error: Either provide a skill name or use --all to install all skills")
+ print("Usage: trl skills install --target ")
+ print(" or: trl skills install --all --target ")
+ return 1
+
+ if args.skill and args.all:
+ print("Error: Cannot specify both a skill name and --all")
+ return 1
+
+ # Determine skills to install
+ if args.all:
+ skills_to_install = list_skills()
+ if not skills_to_install:
+ print("No skills available to install")
+ return 1
+ print(f"Installing {len(skills_to_install)} skills to {args.target}")
+ else:
+ skills_to_install = [args.skill]
+
+ # Install each skill
+ success_count = 0
+ for skill_name in skills_to_install:
+ try:
+ print(f"Installing '{skill_name}'...", end=" ")
+ install_skill(
+ skill_name=skill_name,
+ target=args.target,
+ scope=args.scope,
+ force=args.force,
+ )
+ print("✓")
+ success_count += 1
+
+ except FileExistsError as e:
+ print("✗")
+ print(f" Error: {e}")
+ if not args.force:
+ print(" Use --force to overwrite")
+ except (FileNotFoundError, ValueError) as e:
+ print("✗")
+ print(f" Error: {e}")
+
+ # Summary
+ print(f"\n{success_count}/{len(skills_to_install)} skills installed successfully")
+
+ if success_count > 0:
+ target_path = resolve_target_path(args.target, args.scope)
+ print(f"\nSkills are now available at: {target_path}")
+ print("You may need to restart your AI agent to use the new skills.")
+
+ return 0 if success_count == len(skills_to_install) else 1
+
+
+def cmd_uninstall(args):
+ """Handle 'trl skills uninstall' command."""
+ try:
+ print(f"Uninstalling '{args.skill}' from {args.target}...", end=" ")
+ uninstall_skill(args.skill, target=args.target, scope=args.scope)
+ print("✓")
+ print(f"\nSkill '{args.skill}' has been removed")
+ return 0
+
+ except (FileNotFoundError, PermissionError, ValueError) as e:
+ print("✗")
+ print(f"Error: {e}")
+ return 1
+
+
+def cmd_list(args):
+ """Handle 'trl skills list' command."""
+ try:
+ # List skills - if no target specified, list TRL's built-in skills
+ if args.target:
+ skills = list_skills(target=args.target, scope=args.scope)
+ location = args.target
+ else:
+ skills = list_skills()
+ location = "TRL (available for installation)"
+
+ if not skills:
+ if args.target:
+ print(f"No skills installed in {args.target}")
+ else:
+ print("No TRL skills available")
+ return 0
+
+ print(f"\nSkills in {location}:\n")
+
+ for skill in skills:
+ print(f" {skill}")
+
+ print(f"\nTotal: {len(skills)} skill(s)")
+
+ if not args.target:
+ print("\nUse 'trl skills install --target ' to install a skill")
+
+ return 0
+
+ except ValueError as e:
+ print(f"Error: {e}")
+ return 1
+
+
+__all__ = [
+ "add_skills_subcommands",
+]
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/skills/skills.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/skills/skills.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a9b15f4e13f38e930c48dfa6b7e47e687e1ab5d
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/skills/skills.py
@@ -0,0 +1,353 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Agent Skills.
+
+This module:
+- provides utilities for discovering and accessing TRL skills that can be used by AI agents to learn how to use the TRL
+ CLI
+- handles installation, uninstallation, and management of TRL skills
+- defines where different AI agents and coding tools look for skills, enabling easy installation of TRL skills to the
+ appropriate directories
+
+Agent Skills are folders of instructions, scripts, and resources that agents can discover and use to perform tasks more
+accurately and efficiently. Learn more at https://agentskills.io
+"""
+
+import importlib.resources as resources
+import shutil
+from pathlib import Path
+
+
+AGENT_PATHS = {
+ "agents": {
+ "global": Path("~/.agents/skills"),
+ "project": Path("./.agents/skills"),
+ },
+ "claude": {
+ "global": Path("~/.claude/skills"),
+ "project": Path("./.claude/skills"),
+ },
+}
+
+
+def list_agent_names() -> list[str]:
+ """
+ List available predefined agent names.
+
+ Returns:
+ `list[str]`: Sorted list of agent names (e.g., ['agents', 'claude']).
+ """
+ return sorted(AGENT_PATHS.keys())
+
+
+def _get_trl_skills_dir() -> Path:
+ """
+ Get the path to the TRL skills directory.
+
+ This is the directory inside the TRL package containing skills that can be installed to AI agent directories.
+
+ Returns:
+ `Path`: TRL skills directory.
+ """
+ return Path(str(resources.files("trl.skills")))
+
+
+def resolve_target_path(target: str | Path, scope: str = "project") -> Path:
+ """
+ Resolve target to a concrete directory path.
+
+ Converts semantic agent names (e.g., 'claude') with scope to actual filesystem paths, or normalizes provided paths.
+
+ Args:
+ target (`str | Path`): Agent name (e.g., 'agents', 'claude') or directory path.
+ scope (`str`, defaults to `"project"`):
+ Scope for agent names: 'global' (user-level like ~/.agents/skills/) or 'project' (./agents/skills/).
+
+ Returns:
+ `Path`: Resolved absolute path.
+
+ Raises:
+ `ValueError`: If `scope` is invalid for a predefined agent target.
+
+ Example:
+ ```python
+ from trl.skills import resolve_target_path
+
+ # Resolve agent name with scope
+ path = resolve_target_path("claude", "global")
+ print(path) # /home/user/.claude/skills
+
+ # Resolve custom path
+ path = resolve_target_path("/custom/skills")
+ print(path) # /custom/skills
+ ```
+ """
+ if isinstance(target, Path):
+ return target.expanduser().resolve()
+
+ # Check if it's a predefined agent
+ if target in AGENT_PATHS:
+ if scope not in AGENT_PATHS[target]:
+ valid_scopes = ", ".join(sorted(AGENT_PATHS[target]))
+ raise ValueError(f"Invalid scope '{scope}' for agent '{target}'. Expected one of: {valid_scopes}")
+ agent_path = AGENT_PATHS[target][scope]
+ return agent_path.expanduser().resolve()
+
+ # Treat as custom path string
+ return Path(target).expanduser().resolve()
+
+
+def _list_skills_in_dir(skills_dir: Path) -> list[str]:
+ """
+ List skills in directory.
+
+ A skill is a directory containing a SKILL.md file.
+
+ Args:
+ skills_dir (`Path`): Skills directory to scan.
+
+ Returns:
+ `list[str]`: Skill names (directory names containing SKILL.md).
+ """
+ if not skills_dir.exists():
+ return []
+ skills = []
+ for item in skills_dir.iterdir():
+ if item.is_dir() and (item / "SKILL.md").exists():
+ skills.append(item.name)
+ return sorted(skills)
+
+
+def list_skills(target: str | Path | None = None, scope: str = "project") -> list[str]:
+ """
+ List skills.
+
+ A skill is a directory containing a SKILL.md file.
+
+ Args:
+ target (`str | Path`, *optional*):
+ Agent name (e.g., 'claude'), directory path, or `None` for TRL's built-in skills.
+ scope (`str`, defaults to `"project"`):
+ For agent names: 'global' (user-level) or 'project' (current directory).
+
+ Returns:
+ `list[str]`: Skill names (directory names containing SKILL.md).
+
+ Example:
+ ```python
+ from trl.skills import list_skills
+
+ # List TRL's built-in skills
+ skills = list_skills()
+ print(skills) # ['trl-training']
+
+ # List skills installed for Claude globally
+ installed = list_skills(target="claude", scope="global")
+ print(installed) # ['trl-training', 'custom-skill']
+
+ # List skills in custom directory
+ custom = list_skills(target="/path/to/skills")
+ print(custom) # [...]
+ ```
+ """
+ if target is None:
+ # List TRL's built-in skills
+ return _list_skills_in_dir(_get_trl_skills_dir())
+
+ target_dir = resolve_target_path(target, scope)
+ return _list_skills_in_dir(target_dir)
+
+
+def _install_skill_to_dir(
+ skill_name: str,
+ target_dir: Path,
+ source_dir: Path,
+ force: bool = False,
+) -> bool:
+ """
+ Install a skill to target directory.
+
+ Args:
+ skill_name (`str`): Name of skill to install.
+ target_dir (`Path`): Target installation directory.
+ source_dir (`Path`): Source directory containing skills.
+ force (`bool`, defaults to `False`): Whether to overwrite if exists.
+
+ Returns:
+ `bool`: True if installed successfully.
+
+ Raises:
+ - `FileNotFoundError`: If skill doesn't exist in source_dir.
+ - `FileExistsError`: If skill already installed and not force.
+ - `PermissionError`: If no permission to write to target_dir.
+ - `ValueError`: If source_dir entry exists but is not a directory.
+ - `OSError`: If copying the skill fails.
+ """
+ source_skill = source_dir / skill_name
+
+ # Check if source skill exists
+ if not source_skill.exists():
+ available = ", ".join(list_skills(target=source_dir))
+ source_msg = f"source directory {source_dir}"
+ if available:
+ raise FileNotFoundError(f"Skill '{skill_name}' not found in {source_msg}. Available skills: {available}")
+ raise FileNotFoundError(f"Skill '{skill_name}' not found in {source_msg}")
+
+ if not source_skill.is_dir():
+ raise ValueError(f"Skill '{skill_name}' is not a directory")
+
+ target_skill = target_dir / skill_name
+
+ # Check if already exists
+ if target_skill.exists() and not force:
+ raise FileExistsError(f"Skill '{skill_name}' already installed at {target_skill}. Use --force to overwrite.")
+
+ # Create target directory
+ try:
+ target_dir.mkdir(parents=True, exist_ok=True)
+ except PermissionError as e:
+ raise PermissionError(f"Cannot create directory {target_dir}: {e}") from e
+
+ # Remove existing if force
+ if target_skill.exists() and force:
+ if target_skill.is_symlink():
+ target_skill.unlink()
+ else:
+ shutil.rmtree(target_skill)
+
+ # Install
+ try:
+ shutil.copytree(source_skill, target_skill)
+ except OSError as e:
+ raise OSError(f"Failed to install skill: {e}") from e
+
+ return True
+
+
+def install_skill(
+ skill_name: str,
+ target: str | Path,
+ scope: str = "project",
+ source: str | Path | None = None,
+ force: bool = False,
+) -> bool:
+ """
+ Install a skill.
+
+ Args:
+ skill_name (`str`): Name of skill to install.
+ target (`str | Path`): Agent name (e.g., 'agents', 'claude') or directory path.
+ scope (`str`, defaults to `"project"`):
+ Scope for agent names: 'global' (user-level) or 'project' (current directory).
+ source (`str | Path`, *optional*):
+ Source directory containing skills. If `None`, defaults to TRL skills directory.
+ force (`bool`, defaults to `False`): Whether to overwrite if skill already exists.
+
+ Returns:
+ `bool`: True if installed successfully.
+
+ Raises:
+ - `FileNotFoundError`: If skill doesn't exist in source.
+ - `FileExistsError`: If skill already installed and not force.
+ - `PermissionError`: If no permission to write to target.
+ - `ValueError`:
+ - If `scope` is invalid for a predefined agent target.
+ - If `source` entry exists but is not a directory.
+ - `OSError`: If copying the skill fails.
+
+ Example:
+ ```python
+ from trl.skills import install_skill
+
+ # Install to Claude's global skills directory
+ install_skill("trl-training", target="claude", scope="global")
+
+ # Install to custom directory
+ install_skill("trl-training", target="/path/to/skills")
+
+ # Overwrite existing installation
+ install_skill("trl-training", target="claude", force=True)
+ ```
+ """
+ target_dir = resolve_target_path(target, scope)
+ source_dir = Path(source).expanduser().resolve() if source else _get_trl_skills_dir()
+ return _install_skill_to_dir(skill_name, target_dir, source_dir, force)
+
+
+def _uninstall_skill_from_dir(skill_name: str, target_dir: Path) -> bool:
+ """
+ Uninstall a skill from target directory.
+
+ Args:
+ skill_name (`str`): Name of skill to uninstall.
+ target_dir (`Path`): Directory skill is installed in.
+
+ Returns:
+ `bool`: True if uninstalled successfully.
+
+ Raises:
+ - `FileNotFoundError`: If skill not installed.
+ - `PermissionError`: If no permission to remove.
+ - `OSError`: If removing the skill fails for another filesystem reason.
+ """
+ target_skill = target_dir / skill_name
+
+ if not target_skill.exists():
+ raise FileNotFoundError(f"Skill '{skill_name}' not installed at {target_dir}")
+
+ # Remove symlink or directory
+ try:
+ shutil.rmtree(target_skill)
+ except PermissionError as e:
+ raise PermissionError(f"Cannot remove skill: {e}") from e
+ except OSError as e:
+ raise OSError(f"Failed to remove skill: {e}") from e
+
+ return True
+
+
+def uninstall_skill(skill_name: str, target: str | Path, scope: str = "project") -> bool:
+ """
+ Uninstall a skill.
+
+ Args:
+ skill_name (`str`): Name of skill to uninstall.
+ target (`str | Path`): Agent name (e.g., 'agents', 'claude') or directory path.
+ scope (`str`, defaults to `"project"`):
+ Scope for agent names: 'global' (user-level) or 'project' (current directory).
+
+ Returns:
+ `bool`: True if uninstalled successfully.
+
+ Raises:
+ - `FileNotFoundError`: If skill not installed.
+ - `PermissionError`: If no permission to remove.
+ - `OSError`: If removing the skill fails for another filesystem reason.
+ - `ValueError`: If `scope` is invalid for a predefined agent target.
+
+ Example:
+ ```python
+ from trl.skills import uninstall_skill
+
+ # Uninstall from Claude's global directory
+ uninstall_skill("trl-training", target="claude", scope="global")
+
+ # Uninstall from custom directory
+ uninstall_skill("trl-training", target="/path/to/skills")
+ ```
+ """
+ target_dir = resolve_target_path(target, scope)
+ return _uninstall_skill_from_dir(skill_name, target_dir)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/skills/trl-training/SKILL.md b/tasks/tasksmith-03a6a091b12f/tests/source/trl/skills/trl-training/SKILL.md
new file mode 100644
index 0000000000000000000000000000000000000000..1941385812d82abbbe1f466aa1204e0f8d775ea9
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/skills/trl-training/SKILL.md
@@ -0,0 +1,333 @@
+---
+name: trl-training
+description: Train and fine-tune transformer language models using TRL (Transformers Reinforcement Learning). Supports SFT, DPO, GRPO, KTO, RLOO and Reward Model training via CLI commands.
+license: Apache-2.0
+metadata:
+ version: "1.0.0"
+ author: huggingface
+ commands:
+ - trl sft
+ - trl dpo
+ - trl grpo
+ - trl kto
+ - trl rloo
+ - trl reward
+ categories:
+ - machine-learning
+ - llm-training
+ - reinforcement-learning
+ tags:
+ - rlhf
+ - supervised-fine-tuning
+ - dpo
+ - grpo
+ - huggingface
+ - transformers
+ documentation: https://huggingface.co/docs/trl/en/clis
+---
+
+# TRL Training Skill
+
+You are an expert at using the TRL (Transformers Reinforcement Learning) library to train and fine-tune large language models.
+
+## Overview
+
+TRL provides CLI commands for post-training foundation models using state-of-the-art techniques:
+
+- **SFT** (Supervised Fine-Tuning): Fine-tune models on instruction-following or conversational datasets
+- **DPO** (Direct Preference Optimization): Align models using preference data
+- **GRPO** (Group Relative Policy Optimization): Train models by ranking multiple sampled outputs relative to each other and optimizing based on their comparative rewards.
+- **RLOO** (Reinforce Leave One Out): Online RL training with generation-based rewards
+- **Reward Model Training**: Train reward models for RLHF
+
+TRL is built on top of Hugging Face Transformers and Accelerate, providing seamless integration with the Hugging Face ecosystem.
+
+## Core Commands
+
+### trl sft - Supervised Fine-Tuning
+
+Fine-tune language models on instruction-following or conversational datasets.
+
+**Full training:**
+
+```bash
+trl sft \
+ --model_name_or_path Qwen/Qwen2-0.5B \
+ --dataset_name trl-lib/Capybara \
+ --learning_rate 2.0e-5 \
+ --num_train_epochs 1 \
+ --packing \
+ --per_device_train_batch_size 2 \
+ --gradient_accumulation_steps 8 \
+ --eos_token '<|im_end|>' \
+ --eval_strategy steps \
+ --eval_steps 100 \
+ --output_dir Qwen2-0.5B-SFT \
+ --push_to_hub
+```
+
+**Train with LoRA adapters:**
+
+```bash
+trl sft \
+ --model_name_or_path Qwen/Qwen2-0.5B \
+ --dataset_name trl-lib/Capybara \
+ --learning_rate 2.0e-4 \
+ --num_train_epochs 1 \
+ --packing \
+ --per_device_train_batch_size 2 \
+ --gradient_accumulation_steps 8 \
+ --eos_token '<|im_end|>' \
+ --eval_strategy steps \
+ --eval_steps 100 \
+ --use_peft \
+ --lora_r 32 \
+ --lora_alpha 16 \
+ --output_dir Qwen2-0.5B-SFT \
+ --push_to_hub
+```
+
+### trl dpo - Direct Preference Optimization
+
+Align models using preference data (chosen/rejected pairs).
+
+**Full training:**
+
+```bash
+trl dpo \
+ --dataset_name trl-lib/ultrafeedback_binarized \
+ --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
+ --learning_rate 5.0e-7 \
+ --num_train_epochs 1 \
+ --per_device_train_batch_size 2 \
+ --max_steps 1000 \
+ --gradient_accumulation_steps 8 \
+ --eval_strategy steps \
+ --eval_steps 50 \
+ --output_dir Qwen2-0.5B-DPO \
+ --no_remove_unused_columns
+```
+
+**Train with LoRA adapters:**
+
+```bash
+trl dpo \
+ --dataset_name trl-lib/ultrafeedback_binarized \
+ --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
+ --learning_rate 5.0e-6 \
+ --num_train_epochs 1 \
+ --per_device_train_batch_size 2 \
+ --max_steps 1000 \
+ --gradient_accumulation_steps 8 \
+ --eval_strategy steps \
+ --eval_steps 50 \
+ --output_dir Qwen2-0.5B-DPO \
+ --no_remove_unused_columns \
+ --use_peft \
+ --lora_r 32 \
+ --lora_alpha 16
+```
+
+### trl grpo - Group Relative Policy Optimization
+
+Train models using reward functions or LLM-as-a-judge for evaluating generations and providing rewards.
+
+**Basic usage:**
+
+```bash
+trl grpo \
+ --model_name_or_path Qwen/Qwen2.5-0.5B \
+ --dataset_name trl-lib/gsm8k \
+ --reward_funcs accuracy_reward \
+ --output_dir Qwen2-0.5B-GRPO \
+ --push_to_hub
+```
+
+### trl rloo - Reinforce Leave One Out
+
+Online RL training where the model generates text and receives rewards based on custom criteria.
+
+**Basic usage:**
+
+```bash
+trl rloo \
+ --model_name_or_path Qwen/Qwen2.5-0.5B \
+ --dataset_name trl-lib/tldr \
+ --reward_model_name_or_path sentiment-analysis:nlptown/bert-base-multilingual-uncased-sentiment \
+ --output_dir Qwen2-0.5B-RLOO \
+ --push_to_hub
+```
+
+### trl reward - Reward Model Training
+
+Train a reward model to score text quality for RLHF.
+
+**Full training:**
+
+```bash
+trl reward \
+ --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
+ --dataset_name trl-lib/ultrafeedback_binarized \
+ --output_dir Qwen2-0.5B-Reward \
+ --per_device_train_batch_size 8 \
+ --num_train_epochs 1 \
+ --learning_rate 1.0e-5 \
+ --eval_strategy steps \
+ --eval_steps 50 \
+ --max_length 2048
+```
+
+**Train with LoRA adapters:**
+
+```bash
+trl reward \
+ --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
+ --dataset_name trl-lib/ultrafeedback_binarized \
+ --output_dir Qwen2-0.5B-Reward-LoRA \
+ --per_device_train_batch_size 8 \
+ --num_train_epochs 1 \
+ --learning_rate 1.0e-4 \
+ --eval_strategy steps \
+ --eval_steps 50 \
+ --max_length 2048 \
+ --use_peft \
+ --lora_task_type SEQ_CLS \
+ --lora_r 32 \
+ --lora_alpha 16
+```
+
+## Configuration Files
+
+TRL supports YAML configuration files for reproducible training. All CLI arguments can be specified in a config file.
+
+**Example config (sft_config.yaml):**
+
+```yaml
+model_name_or_path: Qwen/Qwen2.5-0.5B
+dataset_name: trl-lib/Capybara
+learning_rate: 2.0e-5
+num_train_epochs: 1
+per_device_train_batch_size: 8
+gradient_accumulation_steps: 2
+output_dir: ./sft_output
+use_peft: true
+lora_r: 16
+lora_alpha: 16
+report_to: trackio
+```
+
+**Launch with config:**
+
+```bash
+trl sft --config sft_config.yaml
+```
+
+**Override config values:**
+
+```bash
+trl sft --config sft_config.yaml --learning_rate 1.0e-5
+```
+
+## Distributed Training
+
+TRL integrates with Accelerate for multi-GPU and multi-node training.
+
+**Multi-GPU training:**
+
+```bash
+trl sft \
+ --config sft_config.yaml \
+ --num_processes 4
+```
+
+**Use predefined Accelerate configs:**
+
+TRL provides predefined configs: `single_gpu`, `multi_gpu`, `fsdp1`, `fsdp2`, `zero1`, `zero2`, `zero3`
+
+```bash
+trl sft \
+ --config sft_config.yaml \
+ --accelerate_config zero2
+```
+
+**Custom Accelerate config:**
+
+```bash
+# Generate custom config
+accelerate config
+
+# Use custom config
+trl sft --config sft_config.yaml --config_file ~/.cache/huggingface/accelerate/default_config.yaml
+```
+
+**Fully Sharded Data Parallel (FSDP):**
+
+```bash
+trl sft --config sft_config.yaml --accelerate_config fsdp2
+```
+
+**DeepSpeed ZeRO:**
+
+```bash
+trl sft --config sft_config.yaml --accelerate_config zero3
+```
+
+## Troubleshooting
+
+### CUDA Out of Memory
+
+- Reduce `--per_device_train_batch_size` and increase `--gradient_accumulation_steps`
+- Enable `--use_peft` for LoRA training
+- Use `--gradient_checkpointing` to save memory
+- Try smaller model or longer sequence truncation
+
+### Dataset Loading Issues
+
+- Verify dataset exists: check Hugging Face Hub or local path
+- Check dataset format matches expected columns
+- Use `--dataset_config` for multi-config datasets
+- Inspect dataset: `from datasets import load_dataset; ds = load_dataset(name)`
+
+### Model Loading Issues
+
+- Verify model exists on Hugging Face Hub
+- Check if gated model requires authentication: `hf auth login`
+- For local models, provide absolute path
+- Ensure sufficient disk space and memory
+
+### Slow Training
+
+- Enable dataset `--packing` for short sequences
+- Use larger `--per_device_train_batch_size` if memory allows
+- Enable `--tf32` for faster computation on Ampere GPUs
+- Use `--bf16` on supported hardware
+- Consider multi-GPU training with `--num_processes`
+
+### Generation Issues (GRPO/RLOO)
+
+- Check prompt format in dataset
+- Adjust `--temperature` and `--top_p` for generation
+- Verify the reward function (for GRPO/RLOO)
+
+## Additional Resources
+
+- **Documentation**: https://huggingface.co/docs/trl
+- **GitHub**: https://github.com/huggingface/trl
+- **Examples**: https://github.com/huggingface/trl/tree/main/examples
+
+## Best Practices
+
+1. **Start with SFT**: Always fine-tune base models with SFT before preference alignment
+2. **Use LoRA for efficiency**: Enable `--use_peft` for faster training and lower memory
+3. **Monitor training**: Use `--report_to trackio` (or `--report_to wandb` or `--report_to tensorboard`) for tracking
+4. **Save checkpoints**: TRL automatically saves checkpoints in `--output_dir`
+5. **Test on small datasets first**: Verify pipeline works before full training
+6. **Use configuration files**: Create YAML configs for reproducibility
+7. **Leverage Accelerate**: Use multi-GPU training for faster iteration
+
+When helping users with TRL:
+- Always check which training method is appropriate for their use case
+- Verify dataset format matches the expected schema
+- Recommend starting with smaller models for testing
+- Suggest LoRA for resource-constrained environments
+- Point to specific documentation sections for advanced features
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/templates/completions_dataset_card.md b/tasks/tasksmith-03a6a091b12f/tests/source/trl/templates/completions_dataset_card.md
new file mode 100644
index 0000000000000000000000000000000000000000..6246844db5738c7cc6807c9b221544f6939692c6
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/templates/completions_dataset_card.md
@@ -0,0 +1,40 @@
+---
+{{ card_data }}
+---
+
+# TRL Completion logs
+
+This dataset contains the completions generated during training using `trl`.
+
+{% if hub_model_id %}
+Find the trained model at https://huggingface.co/{{ hub_model_id }}.
+
+{% endif %}
+The completions are stored in parquet files, and each file contains the completions for a single step of training (depending on the `logging_steps` argument).
+
+Each file contains the following columns:
+
+- `step`: the step of training
+- `prompt`: the prompt used to generate the completion
+- `completion`: the completion generated by the model
+- ``: the reward(s) assigned to the completion by the reward function(s) used during training
+- `advantage`: the computed advantage for the completion
+
+Having this data stored as a simple parquet file makes it easy to load and analyze using the Datasets Viewer, Polars, Pandas, etc.
+
+You can load the dataset using the `datasets` library:
+
+```python
+import datasets
+
+dataset = datasets.load_dataset("{{ repo_id }}")
+```
+
+You can also load the dataset using Polars:
+
+```python
+import polars as pl
+
+# Login using e.g. `hf auth login` to access this dataset if it's private
+df = pl.read_parquet(f"hf://datasets/{{ repo_id }}/*.parquet")
+```
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/templates/lm_model_card.md b/tasks/tasksmith-03a6a091b12f/tests/source/trl/templates/lm_model_card.md
new file mode 100644
index 0000000000000000000000000000000000000000..ae7e33bfb5d5e5864257fd0abf04bd78d1629c5f
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/templates/lm_model_card.md
@@ -0,0 +1,55 @@
+---
+{{ card_data }}
+---
+
+# Model Card for {{ model_name }}
+
+This model is a fine-tuned version of [{{ base_model }}](https://huggingface.co/{{ base_model }}){% if dataset_name %} on the [{{ dataset_name }}](https://huggingface.co/datasets/{{ dataset_name }}) dataset{% endif %}.
+It has been trained using [TRL](https://github.com/huggingface/trl).
+
+## Quick start
+
+```python
+from transformers import pipeline
+
+question = "If you had a time machine, but could only go to the past or the future once and never return, which would you choose and why?"
+generator = pipeline("text-generation", model="{{ hub_model_id }}", device="cuda")
+output = generator([{"role": "user", "content": question}], max_new_tokens=128, return_full_text=False)[0]
+print(output["generated_text"])
+```
+
+## Training procedure
+
+{% if wandb_url %}[]({{ wandb_url }}){% endif %}
+{% if trackio_url %}[]({{ trackio_url }}){% endif %}
+{% if comet_url %}[]({{ comet_url }}){% endif %}
+
+This model was trained with {{ trainer_name }}{% if paper_id %}, a method introduced in [{{ paper_title }}](https://huggingface.co/papers/{{ paper_id }}){% endif %}.
+
+### Framework versions
+
+- TRL: {{ trl_version }}
+- Transformers: {{ transformers_version }}
+- Pytorch: {{ pytorch_version }}
+- Datasets: {{ datasets_version }}
+- Tokenizers: {{ tokenizers_version }}
+
+## Citations
+
+{% if trainer_citation %}Cite {{ trainer_name }} as:
+
+```bibtex
+{{ trainer_citation }}
+```{% endif %}
+
+Cite TRL as:
+
+```bibtex
+{% raw %}@software{vonwerra2020trl,
+ title = {{TRL: Transformers Reinforcement Learning}},
+ author = {von Werra, Leandro and Belkada, Younes and Tunstall, Lewis and Beeching, Edward and Thrush, Tristan and Lambert, Nathan and Huang, Shengyi and Rasul, Kashif and Gallouédec, Quentin},
+ license = {Apache-2.0},
+ url = {https://github.com/huggingface/trl},
+ year = {2020}
+}{% endraw %}
+```
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/templates/rm_model_card.md b/tasks/tasksmith-03a6a091b12f/tests/source/trl/templates/rm_model_card.md
new file mode 100644
index 0000000000000000000000000000000000000000..0e47e9724a6c38f262b63782507d5871bb4272c2
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/templates/rm_model_card.md
@@ -0,0 +1,55 @@
+---
+{{ card_data }}
+---
+
+# Model Card for {{ model_name }}
+
+This model is a fine-tuned version of [{{ base_model }}](https://huggingface.co/{{ base_model }}){% if dataset_name %} on the [{{ dataset_name }}](https://huggingface.co/datasets/{{ dataset_name }}) dataset{% endif %}.
+It has been trained using [TRL](https://github.com/huggingface/trl).
+
+## Quick start
+
+```python
+from transformers import pipeline
+
+text = "The capital of France is Paris."
+rewarder = pipeline(model="{{ hub_model_id }}", device="cuda")
+output = rewarder(text)[0]
+print(output["score"])
+```
+
+## Training procedure
+
+{% if wandb_url %}[]({{ wandb_url }}){% endif %}
+{% if trackio_url %}[]({{ trackio_url }}){% endif %}
+{% if comet_url %}[]({{ comet_url }}){% endif %}
+
+This model was trained with {{ trainer_name }}{% if paper_id %}, a method introduced in [{{ paper_title }}](https://huggingface.co/papers/{{ paper_id }}){% endif %}.
+
+### Framework versions
+
+- TRL: {{ trl_version }}
+- Transformers: {{ transformers_version }}
+- Pytorch: {{ pytorch_version }}
+- Datasets: {{ datasets_version }}
+- Tokenizers: {{ tokenizers_version }}
+
+## Citations
+
+{% if trainer_citation %}Cite {{ trainer_name }} as:
+
+```bibtex
+{{ trainer_citation }}
+```{% endif %}
+
+Cite TRL as:
+
+```bibtex
+{% raw %}@software{vonwerra2020trl,
+ title = {{TRL: Transformers Reinforcement Learning}},
+ author = {von Werra, Leandro and Belkada, Younes and Tunstall, Lewis and Beeching, Edward and Thrush, Tristan and Lambert, Nathan and Huang, Shengyi and Rasul, Kashif and Gallouédec, Quentin},
+ license = {Apache-2.0},
+ url = {https://github.com/huggingface/trl},
+ year = {2020}
+}{% endraw %}
+```
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/__init__.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d79d365056136a5940af7d23fb964fb8db0e62c
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/__init__.py
@@ -0,0 +1,83 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import TYPE_CHECKING
+
+from .._lazy_module import _LazyModule
+
+
+_import_structure = {
+ "callbacks": [
+ "BEMACallback",
+ "LogCompletionsCallback",
+ "RichProgressCallback",
+ "SyncRefModelCallback",
+ "WeaveCallback",
+ ],
+ "dpo_config": ["DPOConfig"],
+ "dpo_trainer": ["DPOTrainer"],
+ "grpo_config": ["GRPOConfig"],
+ "grpo_trainer": ["GRPOTrainer"],
+ "kto_config": ["KTOConfig"],
+ "kto_trainer": ["KTOTrainer"],
+ "model_config": ["ModelConfig"],
+ "reward_config": ["RewardConfig"],
+ "reward_trainer": ["RewardTrainer"],
+ "rloo_config": ["RLOOConfig"],
+ "rloo_trainer": ["RLOOTrainer"],
+ "sft_config": ["SFTConfig"],
+ "sft_trainer": ["SFTTrainer"],
+ "utils": [
+ "disable_dropout_in_model",
+ "ensure_master_addr_port",
+ "get_kbit_device_map",
+ "get_peft_config",
+ "get_quantization_config",
+ "patch_chunked_lm_head",
+ ],
+}
+
+if TYPE_CHECKING:
+ from .callbacks import (
+ BEMACallback,
+ LogCompletionsCallback,
+ RichProgressCallback,
+ SyncRefModelCallback,
+ WeaveCallback,
+ )
+ from .dpo_config import DPOConfig
+ from .dpo_trainer import DPOTrainer
+ from .grpo_config import GRPOConfig
+ from .grpo_trainer import GRPOTrainer
+ from .kto_config import KTOConfig
+ from .kto_trainer import KTOTrainer
+ from .model_config import ModelConfig
+ from .reward_config import RewardConfig
+ from .reward_trainer import RewardTrainer
+ from .rloo_config import RLOOConfig
+ from .rloo_trainer import RLOOTrainer
+ from .sft_config import SFTConfig
+ from .sft_trainer import SFTTrainer
+ from .utils import (
+ disable_dropout_in_model,
+ ensure_master_addr_port,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+ patch_chunked_lm_head,
+ )
+else:
+ import sys
+
+ sys.modules[__name__] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/base_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/base_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd20188c74b342974ace79b863b0566c23673ec3
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/base_config.py
@@ -0,0 +1,107 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+
+from transformers import TrainingArguments
+
+
+@dataclass
+class _BaseConfig(TrainingArguments):
+ """
+ Base configuration class for all TRL trainer configurations.
+
+ Subclasses [`~transformers.TrainingArguments`] and overrides fields that are common across TRL trainers or that
+ contain unescaped "%" characters which would cause argparse to raise a `TypeError` when rendering `--help` output.
+
+ Parameters:
+ logging_steps (`int` or `float`, *optional*, defaults to `10`):
+ Number of update steps between two logs if `logging_strategy="steps"`. Should be an integer or a float in
+ range `[0,1)`. If smaller than 1, will be interpreted as ratio of total training steps.
+ gradient_checkpointing (`bool`, *optional*, defaults to `True`):
+ Whether to enable gradient checkpointing to trade compute for memory. Reduces memory usage by clearing
+ activations during forward pass and recomputing them during backward pass. Enables training larger models
+ or batch sizes at the cost of ~20% slower training.
+ bf16 (`bool`, *optional*):
+ Whether to use bfloat16 (BF16) mixed precision instead of 32-bit. Generally preferred over FP16 due to
+ better numerical stability and no loss scaling required. Requires Ampere or higher NVIDIA architecture or
+ Intel XPU or using CPU (use_cpu) or Ascend NPU. If not set, it defaults to `True` if `fp16` is not set.
+ lr_scheduler_kwargs (`dict` or `str`, *optional*):
+ Additional parameters for the lr_scheduler, such as `{'num_cycles': 1}` for cosine with hard restarts. See
+ the documentation of each scheduler for possible values.
+ use_liger_kernel (`bool`, *optional*, defaults to `False`):
+ Enable [Liger Kernel](https://github.com/linkedin/Liger-Kernel) optimizations. Increases multi-GPU
+ throughput by ~20% and reduces memory usage by ~60%. Works with Flash Attention, FSDP, and DeepSpeed.
+ Currently, supports Llama, Mistral, Mixtral, and Gemma models.
+ torch_empty_cache_steps (`int`, *optional*):
+ Number of steps to wait before calling `torch..empty_cache()`. If left unset or set to None, cache
+ will not be emptied. This can help avoid CUDA out-of-memory errors by lowering peak VRAM usage at a cost of
+ about [10% slower performance](https://github.com/huggingface/transformers/issues/31372).
+ """
+
+ # Override fields from TrainingArguments to set defaults preferred by all TRL trainers.
+ logging_steps: float = field(
+ default=10,
+ metadata={
+ "help": "Log every X updates steps. Should be an integer or a float in range `[0,1)`. If smaller than 1, "
+ "will be interpreted as ratio of total training steps."
+ },
+ )
+ gradient_checkpointing: bool = field(
+ default=True,
+ metadata={
+ "help": "Enable gradient checkpointing to trade compute for memory. Reduces memory at the cost of ~20%% slower training."
+ },
+ )
+ bf16: bool | None = field(
+ default=None,
+ metadata={
+ "help": "Whether to use bf16 (mixed) precision instead of 32-bit. Requires Ampere or higher NVIDIA "
+ "architecture or Intel XPU or using CPU (use_cpu) or Ascend NPU. If not set, it defaults to `True` if "
+ "`fp16` is not set."
+ },
+ )
+ # Transformers 4.57.0 introduced a bug that caused the dtype of `lr_scheduler_kwargs` to be unparsable. This issue
+ # was fixed in https://github.com/huggingface/transformers/pull/41322 and released in 4.57.5. We add a temporary
+ # workaround here, which can be removed once we drop support for versions older than 4.57.5.
+ lr_scheduler_kwargs: dict | str | None = field(
+ default=None,
+ metadata={
+ "help": "Additional parameters for the lr_scheduler, such as {'num_cycles': 1} for cosine with hard "
+ "restarts. See the documentation of each scheduler for possible values."
+ },
+ )
+
+ # Override fields from TrainingArguments whose help strings contain unescaped "%" characters.
+ # argparse interprets "%" as a format specifier, raising TypeError when rendering --help output.
+ # Fixed upstream in transformers v5.3.0, but overridden here to support older versions.
+ # - Introduced in v5.2.0; fixed in v5.3.0
+ use_liger_kernel: bool = field(
+ default=False,
+ metadata={
+ "help": "Enable Liger Kernel optimizations. Increases throughput by ~20%% and reduces memory by ~60%%."
+ },
+ )
+ # - Introduced in v4.54.1; fixed in v5.3.0
+ torch_empty_cache_steps: int | None = field(
+ default=None,
+ metadata={
+ "help": "Number of steps to wait before calling `torch..empty_cache()`. Helps avoid CUDA OOM at a cost of ~10%% slower performance. If None, cache will not be emptied."
+ },
+ )
+
+ def __post_init__(self):
+ self.bf16 = not (self.fp16) if self.bf16 is None else self.bf16
+
+ super().__post_init__()
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/base_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/base_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..705cdf11f236ad3bf50842c08eda4afdee69c5b4
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/base_trainer.py
@@ -0,0 +1,191 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+
+import torch
+from accelerate.utils import is_peft_model
+from huggingface_hub.utils import send_telemetry
+from transformers import CONFIG_MAPPING, Trainer, is_wandb_available
+
+from .. import __version__
+from .utils import generate_model_card, get_comet_experiment_url, get_config_model_id, get_trackio_space_url
+
+
+if is_wandb_available():
+ import wandb
+
+
+# Trainer class names that may appear in telemetry topics. Any class outside this set — internal helpers,
+# in-flight subclasses not yet shipped, user-defined subclasses — is reported as "other" so unreleased or
+# private names never leak. Adding a new trainer requires an explicit entry here.
+_TELEMETRY_TRAINERS = {
+ # Stable
+ "DPOTrainer",
+ "GRPOTrainer",
+ "KTOTrainer",
+ "RewardTrainer",
+ "RLOOTrainer",
+ "SFTTrainer",
+ # Experimental
+ "A2POTrainer",
+ "AsyncGRPOTrainer",
+ "BCOTrainer",
+ "CPOTrainer",
+ "DistillationTrainer",
+ "DPPOTrainer",
+ "GFPOTrainer",
+ "GKDTrainer",
+ "GOLDTrainer",
+ "GRPOWithReplayBufferTrainer",
+ "MiniLLMTrainer",
+ "NashMDTrainer",
+ "OnlineDPOTrainer",
+ "ORPOTrainer",
+ "PAPOTrainer",
+ "PPOTrainer",
+ "PRMTrainer",
+ "SDFTTrainer",
+ "SDPOTrainer",
+ "SSDTrainer",
+ "TPOTrainer",
+ "XPOTrainer",
+}
+
+
+class _BaseTrainer(Trainer):
+ _tag_names = []
+ _name = "Base"
+ _paper = {}
+ _template_file = None
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self._send_telemetry()
+
+ def _send_telemetry(self):
+ # Only send from rank 0 to avoid multiplying pings by world size, and skip CI runs so automated tests don't
+ # bias the data. Honors `HF_HUB_DISABLE_TELEMETRY=1` and `HF_HUB_OFFLINE=1` (handled by `send_telemetry`).
+ if not self.accelerator.is_main_process or os.environ.get("CI"):
+ return
+ if self.is_deepspeed_enabled:
+ distributed = "deepspeed"
+ elif self.is_fsdp_enabled:
+ distributed = "fsdp"
+ elif self.accelerator.num_processes > 1:
+ distributed = "ddp"
+ else:
+ distributed = "none"
+ device = self.accelerator.device.type
+ if device == "cuda":
+ gpu = torch.cuda.get_device_name(0)
+ elif device == "xpu":
+ gpu = torch.xpu.get_device_name(0)
+ elif device == "npu":
+ gpu = torch.npu.get_device_name(0)
+ elif device == "mlu":
+ gpu = torch.mlu.get_device_name(0)
+ else:
+ gpu = "other"
+ # Bucketed to avoid fingerprinting individual deployments by their exact cluster size.
+ n = self.accelerator.num_processes
+ world_size = "1" if n == 1 else "2-8" if n <= 8 else "9-64" if n <= 64 else "65+"
+ # Trainer class and model arch are reported only if they come from a known upstream allowlist (TRL trainers,
+ # transformers `CONFIG_MAPPING`); anything else is reported as "other" so we never leak the names of internal,
+ # custom trainer subclasses or private model architectures.
+ cls = type(self)
+ trainer = (
+ cls.__name__ if cls.__name__ in _TELEMETRY_TRAINERS and cls.__module__.startswith("trl.") else "other"
+ )
+ model_type = self.model.config.model_type
+ model_arch = model_type if model_type in CONFIG_MAPPING else "other"
+ send_telemetry(
+ topic=f"trl/{trainer}",
+ library_name="trl",
+ library_version=__version__,
+ user_agent={
+ "model_arch": model_arch,
+ "peft": str(is_peft_model(self.model)).lower(),
+ "distributed": distributed,
+ "world_size": world_size,
+ "device": device,
+ "gpu": gpu,
+ },
+ )
+
+ def create_model_card(
+ self,
+ model_name: str | None = None,
+ dataset_name: str | None = None,
+ tags: str | list[str] | None = None,
+ ):
+ """
+ Creates a draft of a model card using the information available to the `Trainer`.
+
+ Args:
+ model_name (`str`, *optional*):
+ Name of the model.
+ dataset_name (`str`, *optional*):
+ Name of the dataset used for training.
+ tags (`str`, `list[str]`, *optional*):
+ Tags to be associated with the model card.
+ """
+ if not self.is_world_process_zero():
+ return
+
+ model_name_or_path = get_config_model_id(self.model.config)
+ if model_name_or_path and not os.path.isdir(model_name_or_path):
+ base_model = model_name_or_path
+ else:
+ base_model = None
+
+ # Normalize tags
+ if tags is None:
+ tags = set()
+ elif isinstance(tags, str):
+ tags = {tags}
+ else:
+ tags = set(tags)
+ if hasattr(self.model.config, "unsloth_version"):
+ tags.add("unsloth")
+ if "JOB_ID" in os.environ:
+ tags.add("hf_jobs")
+ tags.update(self._tag_names)
+
+ trackio_url = get_trackio_space_url()
+ # Pop existing Trackio tag and re-add the one with the proper url parameters
+ if trackio_url is not None:
+ for tag in list(tags):
+ if tag.startswith("trackio:"):
+ tags.remove(tag)
+ tags.add(f"trackio:{trackio_url}")
+
+ tags = list(tags)
+
+ model_card = generate_model_card(
+ base_model=base_model,
+ model_name=model_name,
+ hub_model_id=self.hub_model_id,
+ dataset_name=dataset_name,
+ tags=tags,
+ wandb_url=wandb.run.url if is_wandb_available() and wandb.run is not None else None,
+ trackio_url=trackio_url,
+ comet_url=get_comet_experiment_url(),
+ trainer_name=self._name,
+ trainer_citation=self._paper.get("citation"),
+ template_file=self._template_file,
+ paper_title=self._paper.get("title"),
+ paper_id=self._paper.get("id"),
+ )
+ model_card.save(os.path.join(self.args.output_dir, "README.md"))
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/callbacks.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/callbacks.py
new file mode 100644
index 0000000000000000000000000000000000000000..12e36190fd82fb287d004c30c2c26dca7e965e0a
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/callbacks.py
@@ -0,0 +1,758 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+
+import pandas as pd
+import torch
+from accelerate import Accelerator
+from accelerate.state import AcceleratorState
+from accelerate.utils import gather_object, is_wandb_available
+from transformers import (
+ GenerationConfig,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+ Trainer,
+ TrainerCallback,
+ TrainerControl,
+ TrainerState,
+ TrainingArguments,
+)
+from transformers.trainer_utils import has_length
+from transformers.utils import is_rich_available
+
+from ..data_utils import maybe_apply_chat_template
+from ..import_utils import is_weave_available
+from ..models.utils import unwrap_model_for_generation
+from .utils import log_table_to_comet_experiment
+
+
+if is_rich_available():
+ from rich.columns import Columns
+ from rich.console import Console, Group
+ from rich.live import Live
+ from rich.panel import Panel
+ from rich.progress import Progress
+ from rich.table import Table
+
+if is_wandb_available():
+ import wandb
+
+if is_weave_available():
+ import weave
+ from weave import EvaluationLogger
+ from weave.trace.context import weave_client_context
+
+
+# Logger for module-level logging
+logger = logging.getLogger(__name__)
+
+
+def _generate_completions(
+ prompts: list[str],
+ model: PreTrainedModel,
+ tokenizer: PreTrainedTokenizerBase,
+ accelerator: Accelerator,
+ generation_config: GenerationConfig | None,
+ batch_size: int = 1,
+) -> list[str]:
+ """
+ Generates completions for a list of pre-formatted prompts from the given model.
+
+ Args:
+ prompts (list[str]): A list of input prompts for which completions are to be generated.
+ model (PreTrainedModel): The pre-trained model to be used for generation.
+ tokenizer (PreTrainedTokenizerBase): The tokenizer to be used for encoding and decoding.
+ accelerator (Accelerator): The accelerator to be used for model execution.
+ generation_config (GenerationConfig): Configuration for text generation.
+ batch_size (int, *optional*): The number of prompts to process in each batch. Default is 1.
+
+ Returns:
+ list[str]: A list of generated text completions corresponding to the input prompts.
+ """
+ completions = []
+ # TODO: Override model.generation_config with generation_kwargs
+ with unwrap_model_for_generation(model, accelerator) as unwrapped_model:
+ for idx in range(0, len(prompts), batch_size):
+ batch = prompts[idx : idx + batch_size]
+ tokenized_batch = tokenizer(batch, return_tensors="pt", padding=True, truncation=True).to(model.device)
+ generations = unwrapped_model.generate(
+ **tokenized_batch,
+ generation_config=generation_config,
+ )
+ for prompt, generation in zip(tokenized_batch.input_ids, generations, strict=True):
+ # Remove prompt from generation
+ generation = generation[len(prompt) :]
+ completion = tokenizer.decode(generation, skip_special_tokens=True)
+ completions.append(completion)
+ return completions
+
+
+class SyncRefModelCallback(TrainerCallback):
+ """
+ Callback to synchronize the model with a reference model.
+ """
+
+ def __init__(
+ self,
+ ref_model: PreTrainedModel | torch.nn.Module,
+ accelerator: Accelerator | None,
+ ):
+ self.accelerator = accelerator
+ self.ref_model = ref_model
+
+ @staticmethod
+ def _sync_target_model(model, target_model, alpha):
+ for target_param, copy_param in zip(target_model.parameters(), model.parameters(), strict=True):
+ target_param.data.mul_(1.0 - alpha).add_(copy_param.data, alpha=alpha)
+
+ @staticmethod
+ def sync_target_model(model, target_model, alpha):
+ deepspeed_plugin = AcceleratorState().deepspeed_plugin
+ if deepspeed_plugin is not None and deepspeed_plugin.zero_stage == 3:
+ import deepspeed
+
+ with deepspeed.zero.GatheredParameters(
+ list(model.parameters()) + list(target_model.parameters()), modifier_rank=0
+ ):
+ if deepspeed.comm.get_rank() == 0:
+ SyncRefModelCallback._sync_target_model(model, target_model, alpha)
+ else:
+ SyncRefModelCallback._sync_target_model(model, target_model, alpha)
+
+ def on_step_end(self, args, state, control, **kwargs):
+ model: PreTrainedModel = kwargs["model"]
+
+ if self.ref_model is not None and state.global_step % args.ref_model_sync_steps == 0:
+ if self.accelerator:
+ model = self.accelerator.unwrap_model(model)
+ self.sync_target_model(model, self.ref_model, args.ref_model_mixup_alpha)
+
+
+class RichProgressCallback(TrainerCallback):
+ """
+ A [`TrainerCallback`] that displays the progress of training or evaluation using Rich.
+ """
+
+ def __init__(self):
+ if not is_rich_available():
+ raise ImportError("RichProgressCallback requires the `rich` extra. To install, run `pip install rich`.")
+
+ self.training_bar = None
+ self.evaluation_bar = None
+ self.training_task = None
+ self.evaluation_task = None
+ self.rich_group = None
+ self.rich_console = None
+ self.training_status = None
+ self.current_step = None
+
+ def on_train_begin(self, args, state, control, **kwargs):
+ if not state.is_world_process_zero:
+ return
+
+ self.training_bar = Progress()
+ self.evaluation_bar = Progress()
+ self.rich_console = Console()
+ self.training_status = self.rich_console.status("Nothing to log yet ...")
+ self.rich_group = Live(Panel(Group(self.training_bar, self.evaluation_bar, self.training_status)))
+ self.rich_group.start()
+ self.training_task = self.training_bar.add_task("[blue]Training ", total=state.max_steps)
+ self.current_step = 0
+
+ def on_step_end(self, args, state, control, **kwargs):
+ if not state.is_world_process_zero:
+ return
+
+ self.training_bar.update(self.training_task, advance=state.global_step - self.current_step, update=True)
+ self.current_step = state.global_step
+
+ def on_prediction_step(self, args, state, control, eval_dataloader=None, **kwargs):
+ if not state.is_world_process_zero:
+ return
+
+ if has_length(eval_dataloader):
+ if self.evaluation_task is None:
+ self.evaluation_task = self.evaluation_bar.add_task("[blue]Evaluation", total=len(eval_dataloader))
+ self.evaluation_bar.update(self.evaluation_task, advance=1, update=True)
+
+ def on_evaluate(self, args, state, control, **kwargs):
+ if not state.is_world_process_zero:
+ return
+
+ if self.evaluation_task is not None:
+ self.evaluation_bar.remove_task(self.evaluation_task)
+ self.evaluation_task = None
+
+ def on_predict(self, args, state, control, **kwargs):
+ if not state.is_world_process_zero:
+ return
+
+ if self.evaluation_task is not None:
+ self.evaluation_bar.remove_task(self.evaluation_task)
+ self.evaluation_task = None
+
+ def on_log(self, args, state, control, logs=None, **kwargs):
+ if not (state.is_world_process_zero and self.training_bar):
+ return
+
+ # Group keys by top-level prefix
+ grouped_logs = {}
+ for key, value in logs.items():
+ parts = key.split("/")
+ group = parts[0] if len(parts) > 1 else None
+ subkey = "/".join(parts[1:]) if len(parts) > 1 else key
+ grouped_logs.setdefault(group, {})[subkey] = value
+
+ # Create a table per group
+ tables = []
+ for group_name, metrics in grouped_logs.items():
+ table = Table(
+ title=f"[bold blue]{group_name}[/]" if group_name else None, header_style="bold magenta", box=None
+ )
+ table.add_column("Metric", justify="left", no_wrap=True)
+ table.add_column("Value", justify="right")
+
+ for metric, val in metrics.items():
+ formatted = f"{val:.3f}" if isinstance(val, (float, int)) else str(val)
+ table.add_row(metric, formatted)
+
+ tables.append(Panel(table, border_style="cyan", padding=(0, 1)))
+
+ # Arrange tables in columns using Columns
+ column_layout = Columns(tables, equal=False, expand=True)
+ self.training_status.update(
+ Panel(column_layout, title=f"[bold green]Step {state.global_step}[/bold green]", border_style="green")
+ )
+
+ def on_train_end(self, args, state, control, **kwargs):
+ if not state.is_world_process_zero:
+ return
+
+ self.rich_group.stop()
+ self.training_bar = None
+ self.evaluation_bar = None
+ self.training_task = None
+ self.evaluation_task = None
+ self.rich_group = None
+ self.rich_console = None
+ self.training_status = None
+ self.current_step = None
+
+
+class LogCompletionsCallback(TrainerCallback):
+ r"""
+ A [`~transformers.TrainerCallback`] that logs completions to Weights & Biases and/or Comet.
+
+ Usage:
+ ```python
+ trainer = DPOTrainer(...)
+ completions_callback = LogCompletionsCallback(trainer=trainer)
+ trainer.add_callback(completions_callback)
+ ```
+
+ Args:
+ trainer (`Trainer`):
+ Trainer to which the callback will be attached. The trainer's evaluation dataset must include a `"prompt"`
+ column containing the prompts for generating completions.
+ generation_config ([`~transformers.GenerationConfig`], *optional*):
+ The generation config to use for generating completions.
+ num_prompts (`int`, *optional*):
+ The number of prompts to generate completions for. If not provided, defaults to the number of examples in
+ the evaluation dataset.
+ freq (`int`, *optional*):
+ The frequency at which to log completions. If not provided, defaults to the trainer's `eval_steps`.
+ """
+
+ def __init__(
+ self,
+ trainer: Trainer,
+ generation_config: GenerationConfig | None = None,
+ num_prompts: int | None = None,
+ freq: int | None = None,
+ ):
+ self.trainer = trainer
+ self.generation_config = generation_config
+ self.freq = freq
+ self.table = []
+ self._last_logged_step = -1
+
+ if self.trainer.eval_dataset is None:
+ raise ValueError("Trainer must have an evaluation dataset to use the LogCompletionsCallback.")
+ else:
+ self.eval_dataset = self.trainer.eval_dataset
+
+ if num_prompts is not None:
+ self.eval_dataset = self.eval_dataset.select(range(num_prompts))
+
+ def on_step_end(self, args, state, control, **kwargs):
+ # Only log once per step (this method may be called multiple times)
+ if state.global_step == self._last_logged_step:
+ return
+
+ # Only log every `freq` steps (if no `freq` is provided, log every `eval_steps` steps)
+ freq = self.freq or state.eval_steps
+ if state.global_step % freq != 0:
+ return
+
+ tokenizer = kwargs["processing_class"]
+ tokenizer.padding_side = "left"
+ accelerator = self.trainer.accelerator
+ model = self.trainer.model_wrapped
+ with accelerator.split_between_processes(self.eval_dataset["prompt"]) as prompts:
+ prompts = [maybe_apply_chat_template({"prompt": prompt}, tokenizer)["prompt"] for prompt in prompts]
+ completions = _generate_completions(
+ prompts,
+ model=model,
+ tokenizer=tokenizer,
+ accelerator=accelerator,
+ generation_config=self.generation_config,
+ batch_size=args.per_device_eval_batch_size,
+ )
+ completions = gather_object(completions)
+ prompts = gather_object(prompts)
+
+ # Build the data to log
+ if self.trainer.accelerator.is_main_process:
+ global_step = [str(state.global_step)] * len(prompts)
+ data = list(zip(global_step, prompts, completions, strict=True))
+ self.table.extend(data)
+ table = pd.DataFrame(columns=["step", "prompt", "completion"], data=self.table)
+
+ if "wandb" in args.report_to:
+ wandb.log({"completions": table})
+
+ if "comet_ml" in args.report_to:
+ log_table_to_comet_experiment(
+ name="completions.csv",
+ table=table,
+ )
+
+ # Save the last logged step, so we don't log the same completions multiple times
+ self._last_logged_step = state.global_step
+
+
+class WeaveCallback(TrainerCallback):
+ r"""
+ A [`~transformers.TrainerCallback`] that logs traces and evaluations to W&B Weave. The callback uses
+ https://weave-docs.wandb.ai/guides/evaluation/evaluation_logger/ to log traces and evaluations at each evaluation
+ step.
+
+ Supports two modes based on the `scorers` parameter:
+ - **Tracing Mode** (when scorers=None): Logs predictions for data exploration and analysis
+ - **Evaluation Mode** (when scorers provided): Logs predictions with scoring and summary metrics
+
+ Both modes use Weave's EvaluationLogger for structured, consistent data logging.
+
+ The callback logs data during evaluation phases (`on_evaluate`) rather than training steps, making it more
+ efficient and semantically correct. It gracefully handles missing weave installation by logging warnings and
+ skipping weave-specific functionality. It also checks for existing weave clients before initializing new ones.
+
+ Usage:
+ ```python
+ # Tracing mode (just log predictions)
+ trainer = DPOTrainer(...)
+ weave_callback = WeaveTraceCallback(trainer=trainer) # project_name optional
+ trainer.add_callback(weave_callback)
+
+ # Or specify a project name
+ weave_callback = WeaveTraceCallback(trainer=trainer, project_name="my-llm-training")
+ trainer.add_callback(weave_callback)
+
+
+ # Evaluation mode (log predictions + scores + summary)
+ def accuracy_scorer(prompt: str, completion: str) -> float:
+ # Your scoring logic here (metadata available via eval_attributes)
+ return score
+
+
+ weave_callback = WeaveTraceCallback(
+ trainer=trainer,
+ project_name="my-llm-training", # optional and needed only if weave client is not initialized
+ scorers={"accuracy": accuracy_scorer},
+ )
+ trainer.add_callback(weave_callback)
+ ```
+
+ Args:
+ trainer (`Trainer`):
+ Trainer to which the callback will be attached. The trainer's evaluation dataset must include a `"prompt"`
+ column containing the prompts for generating completions.
+ project_name (`str`, *optional*):
+ Name of the Weave project where data will be logged. If not provided, will try to use existing weave client
+ or fall back to the active wandb run's project name. Raises an error if none of these are available.
+ scorers (`dict[str, Callable]`, *optional*):
+ Dictionary mapping scorer names to scorer functions. If `None`, operates in tracing mode (predictions
+ only). If provided, operates in evaluation mode (predictions + scores + summary). Scorer functions should
+ have signature: `scorer(prompt: str, completion: str) -> float | int`
+ generation_config ([`~transformers.GenerationConfig`], *optional*):
+ Generation config to use for generating completions.
+ num_prompts (`int` or `None`, *optional*):
+ Number of prompts to generate completions for. If not provided, defaults to the number of examples in the
+ evaluation dataset.
+ dataset_name (`str`, *optional*, defaults to `"eval_dataset"`):
+ Name for the dataset metadata in Weave.
+ model_name (`str`, *optional*):
+ Name for the model metadata in Weave. If not provided, attempts to extract from model config.
+ """
+
+ def __init__(
+ self,
+ trainer: Trainer,
+ project_name: str | None = None,
+ scorers: dict[str, callable] | None = None,
+ generation_config: GenerationConfig | None = None,
+ num_prompts: int | None = None,
+ dataset_name: str = "eval_dataset",
+ model_name: str | None = None,
+ ):
+ self.trainer = trainer
+ self.project_name = project_name
+ self.scorers = scorers or {}
+ self.generation_config = generation_config
+ self.dataset_name = dataset_name
+ self.model_name = model_name
+ self._last_logged_step = -1
+ self._weave_initialized = False
+ self._eval_logger = None
+
+ if self.trainer.eval_dataset is None:
+ raise ValueError("Trainer must have an evaluation dataset to use the WeaveCallback.")
+ else:
+ self.eval_dataset = self.trainer.eval_dataset
+
+ if num_prompts is not None:
+ self.eval_dataset = self.eval_dataset.select(range(num_prompts))
+
+ def _initialize_weave(self):
+ """Initialize Weave and EvaluationLogger if not already initialized."""
+ if not self._weave_initialized:
+ if not is_weave_available():
+ logger.warning("Weave is not available. Please install weave to enable logging: `pip install weave`")
+ return
+
+ if wc := weave_client_context.get_weave_client():
+ self._weave_client = wc
+ else:
+ if self.project_name is None:
+ if is_wandb_available():
+ if wandb.run is not None:
+ self.project_name = wandb.run.entity + "/" + wandb.run.project
+ logger.info(f"Using project name from active wandb run: {self.project_name}")
+
+ if self.project_name is None:
+ raise ValueError(
+ "No existing Weave client found and no project_name provided. "
+ "Please either initialize weave with `weave.init('project-name')`, "
+ "provide a project_name to the `WeaveTraceCallback`, "
+ "or ensure an active wandb run exists."
+ )
+
+ self._weave_client = weave.init(self.project_name)
+ logger.info(f"Initialized Weave with project: {self.project_name}")
+
+ if self.model_name is None:
+ self.model_name = getattr(self.trainer.model_wrapped.config, "_name_or_path", "unknown_model")
+
+ self._EvaluationLogger = EvaluationLogger
+
+ self._weave_initialized = True
+
+ @property
+ def is_evaluation_mode(self) -> bool:
+ """True if scorers are provided (evaluation mode), False for tracing mode."""
+ return bool(self.scorers)
+
+ def on_train_begin(self, args, state, control, **kwargs):
+ """Initialize Weave when training begins."""
+ self._initialize_weave()
+
+ def on_evaluate(self, args, state, control, **kwargs):
+ if state.global_step == self._last_logged_step:
+ return
+
+ self._initialize_weave()
+
+ if not self._weave_initialized:
+ logger.debug("Weave not initialized, skipping logging")
+ return
+
+ tokenizer = kwargs["processing_class"]
+ tokenizer.padding_side = "left"
+ accelerator = self.trainer.accelerator
+ model = self.trainer.model_wrapped
+
+ with accelerator.split_between_processes(self.eval_dataset["prompt"]) as prompts:
+ prompts = [maybe_apply_chat_template({"prompt": prompt}, tokenizer)["prompt"] for prompt in prompts]
+
+ completions = _generate_completions(
+ prompts=prompts,
+ model=model,
+ tokenizer=tokenizer,
+ accelerator=accelerator,
+ generation_config=self.generation_config,
+ batch_size=args.per_device_eval_batch_size,
+ )
+
+ all_prompts = gather_object(prompts)
+ all_completions = gather_object(completions)
+
+ if self.trainer.accelerator.is_main_process:
+ eval_attributes = {
+ "training_step": state.global_step,
+ "model_name": self.model_name,
+ "generation_config": (self.generation_config.to_dict() if self.generation_config else None),
+ }
+
+ eval_logger = self._EvaluationLogger(
+ model=self.model_name,
+ dataset=self.dataset_name,
+ eval_attributes=eval_attributes,
+ )
+
+ successful_predictions = 0
+ total_score_values = {} # For summary statistics
+
+ for prompt, completion in zip(all_prompts, all_completions, strict=True):
+ try:
+ pred_logger = eval_logger.log_prediction(inputs={"prompt": prompt}, output=completion)
+
+ if self.is_evaluation_mode:
+ for scorer_name, scorer_func in self.scorers.items():
+ try:
+ score = scorer_func(prompt, completion)
+ pred_logger.log_score(scorer=scorer_name, score=score)
+
+ if scorer_name not in total_score_values:
+ total_score_values[scorer_name] = []
+ total_score_values[scorer_name].append(score)
+
+ except Exception as scorer_e:
+ logger.warning(f"Failed to apply scorer '{scorer_name}': {scorer_e}")
+
+ pred_logger.finish()
+ successful_predictions += 1
+
+ except Exception as pred_e:
+ logger.warning(f"Failed to log prediction for prompt: {pred_e}")
+ # Continue with other predictions even if one fails
+
+ if self.is_evaluation_mode and total_score_values:
+ try:
+ summary_stats = {
+ "total_predictions": len(all_prompts),
+ "successful_predictions": successful_predictions,
+ }
+
+ for scorer_name, scores in total_score_values.items():
+ if scores: # Only if we have valid scores
+ summary_stats[f"avg_{scorer_name}"] = sum(scores) / len(scores)
+
+ eval_logger.log_summary(summary_stats)
+
+ except Exception as summary_e:
+ logger.warning(f"Failed to log summary: {summary_e}")
+ else:
+ try:
+ eval_logger.finish()
+ except Exception as finish_e:
+ logger.warning(f"Failed to finish evaluation logger: {finish_e}")
+
+ self._last_logged_step = state.global_step
+
+
+class BEMACallback(TrainerCallback):
+ # docstyle-ignore
+ r"""
+ A [`~transformers.TrainerCallback`] that implements [BEMA](https://huggingface.co/papers/2508.00180)
+ (Bias-Corrected Exponential Moving Average) by [Adam Block](https://huggingface.co/abblock) and [Cyril
+ Zhang](https://huggingface.co/cyrilzhang). Code from https://github.com/abblock/bema under MIT license.
+
+ BEMA computes model weights that scale like:
+
+ $$
+ \theta_t' = \alpha_t \cdot (\theta_t - \theta_0) + \text{EMA}_t
+ $$
+
+ where \\( \theta_t \\) is the current model weights, \\( \theta_0 \\) is a snapshot of the model weights at the
+ first `update_after` step, \\( \text{EMA}_t \\) is the exponential moving average of the model weights, and
+ \\( \alpha_t \\) is a scaling factor that decays with the number of steps \\( t \\) as
+
+ $$
+ \alpha_t = (\rho + \gamma \cdot t)^{-\eta}.
+ $$
+
+ The EMA is computed as:
+
+ $$
+ \text{EMA}_t = (1 - \beta_t) \cdot \text{EMA}_{t-1} + \beta_t \cdot \theta_t
+ $$
+
+ where \\( \beta_t \\) is a decay factor that decays with the number of steps \\( t \\) as
+
+ $$
+ \beta_t = (\rho + \gamma \cdot t)^{-\kappa}.
+ $$
+
+ Args:
+ update_freq (`int`, *optional*, defaults to `400`):
+ Update the BEMA weights every X steps. Denoted this as \\( \phi \\) in the paper.
+ ema_power (`float`, *optional*, defaults to `0.5`):
+ Power for the EMA decay factor. Denoted \\( \kappa \\) in the paper. To disable EMA, set this to `0.0`.
+ bias_power (`float`, *optional*, defaults to `0.2`):
+ Power for the BEMA scaling factor. Denoted \\( \eta \\) in the paper. To disable BEMA, set this to `0.0`.
+ lag (`int`, *optional*, defaults to `10`):
+ Initial offset in the weight decay schedule that controls early-stage smoothness by acting as a virtual
+ starting age for the updates. Denoted as \\( \rho \\) in the paper.
+ update_after (`int`, *optional*, defaults to `0`):
+ Burn-in time before starting to update the BEMA weights. Denoted \\( \tau \\) in the paper.
+ multiplier (`float`, *optional*, defaults to `1.0`):
+ Initial value for the EMA decay factor. Denoted as \\( \gamma \\) in the paper.
+ min_ema_multiplier (`float`, *optional*, defaults to `0.0`):
+ Minimum value for the EMA decay factor.
+ device (`str`, *optional*, defaults to `"cpu"`):
+ Device to use for the BEMA buffers, e.g. `"cpu"` or `"cuda"`. Note that in most cases, this device SHOULD
+ BE DIFFERENT from the device used for training in order to avoid OOM.
+
+ Example:
+
+ ```python
+ from trl import BEMACallback
+
+ trainer = Trainer(..., callbacks=[BEMACallback()])
+ ```
+ """
+
+ def __init__(
+ self,
+ update_freq: int = 400,
+ ema_power: float = 0.5,
+ bias_power: float = 0.2,
+ lag: int = 10,
+ update_after: int = 0,
+ multiplier: float = 1.0,
+ min_ema_multiplier: float = 0.0,
+ device: str = "cpu",
+ ):
+ # User-provided hyperparams
+ self.update_freq = update_freq
+ self.ema_power = ema_power
+ self.bias_power = bias_power
+ self.lag = lag
+ self.update_after = update_after
+ self.multiplier = multiplier
+ self.min_ema_multiplier = min_ema_multiplier
+ self.device = device
+
+ # Internal state
+ self.param_names = [] # references to training model param names
+ self.thetat_params = [] # references to training model params
+ self.theta0_params = [] # θ₀ buffers (on self.device)
+ self.ema_params = [] # EMA buffers (on self.device)
+ self.running_model = None # a copy of the model to run BEMA on
+
+ @staticmethod
+ def _unwrap_model(model):
+ """
+ Helper function to unwrap model from various wrappers including DataParallel, DistributedDataParallel,
+ DeepSpeed, and FSDP.
+ """
+ # Handle DeepSpeed
+ if hasattr(model, "module") and hasattr(model, "engine"):
+ # DeepSpeed engine
+ return model.module
+
+ # Handle FSDP
+ if hasattr(model, "_fsdp_wrapped_module"):
+ # FSDP wrapped model
+ return model._fsdp_wrapped_module
+
+ # Handle DataParallel/DistributedDataParallel
+ if hasattr(model, "module"):
+ return model.module
+
+ return model
+
+ @torch.no_grad()
+ def on_train_begin(
+ self, args: TrainingArguments, state: TrainerState, control: TrainerControl, model: PreTrainedModel, **kwargs
+ ):
+ model = self._unwrap_model(model)
+
+ # Create a new instance and load state_dict
+ self.running_model = type(model)(model.config).to(self.device)
+ self.running_model.load_state_dict(model.state_dict())
+
+ # Cache trainable parameters once in a fixed order
+ for name, param in model.named_parameters():
+ if not param.requires_grad:
+ continue
+ self.param_names.append(name)
+ self.thetat_params.append(param)
+
+ # Clone θ₀ and EMA on the same device as model
+ theta0 = param.detach().clone().to(self.device)
+ self.theta0_params.append(theta0)
+ self.ema_params.append(theta0.clone()) # initialize EMA with θ₀
+
+ def _ema_beta(self, step: int) -> float:
+ """Compute the EMA decay factor βₜ = (ρ + γ·t)⁻ᵏᵃᵖᵖᵃ."""
+ beta = (self.lag + self.multiplier * step) ** (-self.ema_power)
+ return max(beta, self.min_ema_multiplier)
+
+ def _bema_alpha(self, step: int) -> float:
+ """Compute the BEMA scaling factor αₜ = (ρ + γ·t)⁻ᵉᵗᵃ."""
+ return (self.lag + self.multiplier * step) ** (-self.bias_power)
+
+ def _update_bema_weights(self, step: int):
+ beta = self._ema_beta(step)
+ alpha = self._bema_alpha(step)
+
+ # Compute EMA + BEMA in-place and write directly to running_model
+ for thetat, theta0, ema, run_param in zip(
+ self.thetat_params, self.theta0_params, self.ema_params, self.running_model.parameters(), strict=True
+ ):
+ thetat = thetat.detach().to(self.device)
+ ema.mul_(1 - beta).add_(thetat, alpha=beta) # EMA update: ema = (1 - beta) * ema + beta * θₜ
+ run_param.copy_(ema + alpha * (thetat - theta0)) # BEMA update: run_param = ema + alpha * (θₜ - θ₀)
+
+ @torch.no_grad()
+ def on_step_end(
+ self, args: TrainingArguments, state: TrainerState, control: TrainerControl, model: PreTrainedModel, **kwargs
+ ):
+ step = state.global_step
+
+ # If we haven't reached the update_after step, skip the BEMA update
+ if step < self.update_after:
+ return
+
+ # Snapshot θ₀ and EMA at first update
+ if step == self.update_after:
+ for thetat_param, theta0_param, ema_param in zip(
+ self.thetat_params, self.theta0_params, self.ema_params, strict=True
+ ):
+ theta0_param.copy_(thetat_param)
+ ema_param.copy_(thetat_param)
+
+ # Update BEMA weights every `update_freq` steps
+ elif (step - self.update_after) % self.update_freq == 0:
+ self._update_bema_weights(step)
+ logger.info(f"Updated BEMA weights at step {step}")
+
+ @torch.no_grad()
+ def on_train_end(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs):
+ if state.is_world_process_zero:
+ save_directory = f"{args.output_dir}/bema"
+ self.running_model.save_pretrained(save_directory)
+ logger.info(f"Saved BEMA model to {save_directory}")
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/dpo_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/dpo_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d22eba6b48dcb8df0b77c78f9f853e3f121cb07
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/dpo_config.py
@@ -0,0 +1,354 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import warnings
+from dataclasses import dataclass, field
+from typing import Any
+
+from .base_config import _BaseConfig
+
+
+@dataclass
+class DPOConfig(_BaseConfig):
+ # docstyle-ignore
+ r"""
+ Configuration class for the [`DPOTrainer`].
+
+ This class includes only the parameters that are specific to DPO training. For a full list of training arguments,
+ please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may
+ differ from those in [`~transformers.TrainingArguments`].
+
+ Using [`~transformers.HfArgumentParser`] we can turn this class into
+ [argparse](https://docs.python.org/3/library/argparse#module-argparse) arguments that can be specified on the
+ command line.
+
+ Parameters:
+ > Parameters that control the model
+
+ model_init_kwargs (`dict[str, Any]`, *optional*):
+ Keyword arguments for [`~transformers.AutoModelForCausalLM.from_pretrained`], used when the `model`
+ argument of the [`DPOTrainer`] is provided as a string.
+ trust_remote_code (`bool`, *optional*, defaults to `False`):
+ Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to
+ [`~transformers.AutoModelForCausalLM.from_pretrained`] and
+ [`~transformers.AutoProcessor.from_pretrained`].
+ disable_dropout (`bool`, *optional*, defaults to `True`):
+ Whether to disable dropout in the model and reference model.
+
+ > Parameters that control the data preprocessing
+
+ dataset_num_proc (`int`, *optional*):
+ Number of processes to use for processing the dataset.
+ max_length (`int` or `None`, *optional*, defaults to `1024`):
+ Maximum length of the tokenized sequence. Sequences longer than `max_length` are truncated from the left or
+ right depending on the `truncation_mode`. If `None`, no truncation is applied.
+ truncation_mode (`str`, *optional*, defaults to `"keep_start"`):
+ Truncation mode to use when the sequence exceeds `max_length`. The only supported value is
+ `"keep_start"`. The `"keep_end"` value is deprecated and will be removed in v2.0.0.
+ padding_free (`bool`, *optional*, defaults to `False`):
+ Whether to perform forward passes without padding by flattening all sequences in the batch into a single
+ continuous sequence. This reduces memory usage by eliminating padding overhead. Currently, this is only
+ supported with the FlashAttention 2 or 3, which can efficiently handle the flattened batch structure.
+ pad_to_multiple_of (`int`, *optional*):
+ If set, the sequences will be padded to a multiple of this value.
+ precompute_ref_log_probs (`bool`, *optional*, defaults to `False`):
+ Whether to precompute the reference model log probabilities for the entire training dataset before
+ training. This allows to save memory during training, as the reference model does not need to be kept in
+ memory.
+ precompute_ref_batch_size (`int`, *optional*):
+ Batch size to use when precomputing reference model log probabilities. This can be set higher than the
+ training batch size to speed up preprocessing. If `None`, defaults to `per_device_train_batch_size` for
+ training and `per_device_eval_batch_size` for evaluation.
+
+ > Parameters that control the training
+
+ loss_type (`list[str]`, *optional*, defaults to `["sigmoid"]`):
+ Type of loss to use. Possible values are: `'sigmoid'`, `'hinge'`, `'ipo'`, `'exo_pair'`, `'nca_pair'`,
+ `'robust'`, `'bco_pair'`, `'sppo_hard'`, `'aot'`, `'aot_unpaired'`, `'apo_zero'`, `'apo_down'`,
+ `'discopop'`, `'sft'`, `'sigmoid_norm'`. If multiple loss types are provided, they will be combined using
+ the weights specified in `loss_weights`.
+ loss_weights (`list[float]`, *optional*):
+ List of loss weights for multi-loss combinations. Used when combining multiple loss types. Example: `[0.8,
+ 0.2, 1.0]` for MPO. If not provided, defaults to equal weights (`1.0`) for all loss types.
+ ld_alpha (`float`, *optional*):
+ α parameter from the LD-DPO paper, which controls the weighting of the verbose token log-probabilities in
+ responses. If `None`, no weighting is applied to the verbose part, and the loss is equivalent to the
+ standard DPO loss. Must be in [0.0, 1.0]: `ld_alpha=1.0` applies no weighting, and `ld_alpha=0.0` masks
+ tokens beyond shared lengths.
+ f_divergence_type (`str`, *optional*, defaults to `"reverse_kl"`):
+ f-divergence regularizer between policy and reference (f-DPO paper). Possible values are: `reverse_kl`
+ (default), `forward_kl`, `js_divergence`, `alpha_divergence`.
+ f_alpha_divergence_coef (`float`, *optional*, defaults to `0.5`):
+ α coefficient for the α-divergence u^-α regularizer, used only when `f_divergence_type='alpha_divergence'`.
+ label_smoothing (`float`, *optional*, defaults to `0.0`):
+ Label smoothing parameter used in Robust DPO and EXO. In Robust DPO, it is interpreted as the probability
+ that a preference label is flipped and must lie in [0.0, 0.5); a typical value recommended by the Robust
+ DPO paper is 0.1. In EXO, it corresponds to the ε label smoothing parameter, for which the paper recommends
+ a typical value of 1e-3.
+ beta (`float`, *optional*, defaults to `0.1`):
+ Parameter controlling the deviation from the reference model. Higher β means less deviation from the
+ reference model. For the IPO loss (`loss_type='ipo'`), this value is the regularization parameter denoted
+ by τ in the [paper](https://huggingface.co/papers/2310.12036).
+ use_weighting (`bool`, *optional*, defaults to `False`):
+ Whether to apply WPO-style weighting (https://huggingface.co/papers/2406.11827) to preference pairs using
+ the policy's length-normalized sequence probabilities.
+ discopop_tau (`float`, *optional*, defaults to `0.05`):
+ τ/temperature parameter from the DiscoPOP paper, which controls the shape of the log-ratio modulated loss
+ when using `loss_type='discopop'`. The paper recommends the default value `discopop_tau=0.05`.
+ activation_offloading (`bool`, *optional*, defaults to `False`):
+ Whether to offload the activations to the CPU.
+ sync_ref_model (`bool`, *optional*, defaults to `False`):
+ Whether to synchronize the reference model with the active model every `ref_model_sync_steps` steps, using
+ the `ref_model_mixup_alpha` parameter. This synchronization originates from the
+ [TR-DPO](https://huggingface.co/papers/2404.09656) paper. `sync_ref_model=True` is not yet compatible with
+ PEFT or `precompute_ref_log_probs=True`.
+ ref_model_mixup_alpha (`float`, *optional*, defaults to `0.6`):
+ α parameter from the TR-DPO paper, which controls the mix between the current policy and the previous
+ reference policy during updates. The reference policy is updated according to the equation: `π_ref = α *
+ π_θ + (1 - α) * π_ref_prev`. To use this parameter, you must set `sync_ref_model=True`.
+ ref_model_sync_steps (`int`, *optional*, defaults to `512`):
+ τ parameter from the TR-DPO paper, which determines how frequently the current policy is synchronized with
+ the reference policy. To use this parameter, you must set `sync_ref_model=True`.
+
+ > Deprecated parameters
+
+ pad_token:
+
+
+
+ Parameter `pad_token` is deprecated and will be removed in version v2.0.0. Set `tokenizer.pad_token`
+ directly and pass it as `processing_class` to the trainer instead.
+
+
+
+ > [!NOTE]
+ > These parameters have default values different from [`~transformers.TrainingArguments`]:
+ > - `logging_steps`: Defaults to `10` instead of `500`.
+ > - `gradient_checkpointing`: Defaults to `True` instead of `False`.
+ > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`.
+ > - `learning_rate`: Defaults to `1e-6` instead of `5e-5`.
+ """
+
+ _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs"]
+
+ # Parameters whose default values are overridden from TrainingArguments
+ learning_rate: float = field(
+ default=1e-6,
+ metadata={"help": "The initial learning rate for AdamW."},
+ )
+
+ # Parameters that control the model
+ model_init_kwargs: dict[str, Any] | str | None = field(
+ default=None,
+ metadata={
+ "help": "Keyword arguments for `AutoModelForCausalLM.from_pretrained`, used when the `model` argument of "
+ "the `DPOTrainer` is provided as a string."
+ },
+ )
+ trust_remote_code: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. "
+ "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoProcessor.from_pretrained`."
+ },
+ )
+ disable_dropout: bool = field(
+ default=True,
+ metadata={"help": "Whether to disable dropout in the model and reference model."},
+ )
+
+ # Parameters that control the data preprocessing
+ dataset_num_proc: int | None = field(
+ default=None,
+ metadata={"help": "Number of processes to use for processing the dataset."},
+ )
+ max_length: int | None = field(
+ default=1024,
+ metadata={
+ "help": "Maximum length of the tokenized sequence. Sequences longer than `max_length` are truncated from "
+ "the left or right depending on the `truncation_mode`. If `None`, no truncation is applied."
+ },
+ )
+ truncation_mode: str = field(
+ default="keep_start",
+ metadata={
+ "help": "Truncation mode to use when the sequence exceeds `max_length`. The only supported value is "
+ "`'keep_start'`. The `'keep_end'` value is deprecated and will be removed in v2.0.0.",
+ "choices": ["keep_end", "keep_start"],
+ },
+ )
+ padding_free: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to perform forward passes without padding by flattening all sequences in the batch into "
+ "a single continuous sequence. This reduces memory usage by eliminating padding overhead. Currently, this "
+ "is only supported with the FlashAttention 2 or 3, which can efficiently handle the flattened batch "
+ "structure."
+ },
+ )
+ pad_to_multiple_of: int | None = field(
+ default=None,
+ metadata={"help": "If set, the sequences will be padded to a multiple of this value."},
+ )
+ precompute_ref_log_probs: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to precompute the reference model log probabilities for the entire training dataset "
+ "before training. This allows to save memory during training, as the reference model does not need to be "
+ "kept in memory."
+ },
+ )
+ precompute_ref_batch_size: int | None = field(
+ default=None,
+ metadata={
+ "help": "Batch size to use when precomputing reference model log probabilities. This can be set higher "
+ "than the training batch size to speed up preprocessing. If `None`, defaults to "
+ "`per_device_train_batch_size` for training and `per_device_eval_batch_size` for evaluation."
+ },
+ )
+
+ # Parameters that control the training
+ loss_type: list[str] = field(
+ default_factory=lambda: ["sigmoid"],
+ metadata={
+ "help": "Type of loss to use. Possible values are: `'sigmoid'`, `'hinge'`, `'ipo'`, `'exo_pair'`, "
+ "`'nca_pair'`, `'robust'`, `'bco_pair'`, `'sppo_hard'`, `'aot'`, `'aot_unpaired'`, `'apo_zero'`, "
+ "`'apo_down'`, `'discopop'`, `'sft'`, `'sigmoid_norm'`. If multiple loss types are provided, they will be "
+ "combined using the weights specified in `loss_weights`.",
+ },
+ )
+ loss_weights: list[float] | None = field(
+ default=None,
+ metadata={
+ "help": "List of loss weights for multi-loss combinations. Used when combining multiple loss types. "
+ "Example: `[0.8, 0.2, 1.0]` for MPO. If not provided, defaults to equal weights (`1.0`) for all loss "
+ "types."
+ },
+ )
+ ld_alpha: float | None = field(
+ default=None,
+ metadata={
+ "help": "α parameter from the LD-DPO paper, which controls the weighting of the verbose token "
+ "log-probabilities in responses. If `None`, no weighting is applied to the verbose part, and the loss is "
+ "equivalent to the standard DPO loss. Must be in [0.0, 1.0]: `ld_alpha=1.0` applies no weighting, and "
+ "`ld_alpha=0.0` masks tokens beyond shared lengths.",
+ },
+ )
+ f_divergence_type: str = field(
+ default="reverse_kl",
+ metadata={
+ "help": "f-divergence regularizer between policy and reference (f-DPO paper). Possible values are: "
+ "`reverse_kl` (default), `forward_kl`, `js_divergence`, `alpha_divergence`.",
+ },
+ )
+ f_alpha_divergence_coef: float = field(
+ default=0.5,
+ metadata={
+ "help": "α coefficient for the α-divergence u^-α regularizer, used only when "
+ "`f_divergence_type='alpha_divergence'`."
+ },
+ )
+ label_smoothing: float = field(
+ default=0.0,
+ metadata={
+ "help": "Label smoothing parameter used in Robust DPO and EXO. In Robust DPO, it is interpreted as the "
+ "probability that a preference label is flipped and must lie in [0.0, 0.5); a typical value recommended "
+ "by the Robust DPO paper is 0.1. In EXO, it corresponds to the ε label smoothing parameter, for which the "
+ "paper recommends a typical value of 1e-3."
+ },
+ )
+ beta: float = field(
+ default=0.1,
+ metadata={
+ "help": "Parameter controlling the deviation from the reference model. Higher β means less deviation from "
+ "the reference model. For the IPO loss (`loss_type='ipo'`), this value is the regularization parameter "
+ "denoted by τ in the [paper](https://huggingface.co/papers/2310.12036)."
+ },
+ )
+ use_weighting: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to apply WPO-style weighting (https://huggingface.co/papers/2406.11827) to preference "
+ "pairs using the policy's length-normalized sequence probabilities."
+ },
+ )
+ discopop_tau: float = field(
+ default=0.05,
+ metadata={
+ "help": "τ/temperature parameter from the DiscoPOP paper, which controls the shape of the log-ratio "
+ "modulated loss when using `loss_type='discopop'`. The paper recommends the default value "
+ "`discopop_tau=0.05`."
+ },
+ )
+ activation_offloading: bool = field(
+ default=False,
+ metadata={"help": "Whether to offload the activations to the CPU."},
+ )
+ sync_ref_model: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to synchronize the reference model with the active model every `ref_model_sync_steps` "
+ "steps, using the `ref_model_mixup_alpha` parameter. This synchronization originates from the "
+ "[TR-DPO](https://huggingface.co/papers/2404.09656) paper. `sync_ref_model=True` is not yet compatible "
+ "with PEFT or `precompute_ref_log_probs=True`."
+ },
+ )
+ ref_model_mixup_alpha: float = field(
+ default=0.6,
+ metadata={
+ "help": "α parameter from the TR-DPO paper, which controls the mix between the current policy and the "
+ "previous reference policy during updates. The reference policy is updated according to the equation: "
+ "`π_ref = α * π_θ + (1 - α) * π_ref_prev`. To use this parameter, you must set `sync_ref_model=True`."
+ },
+ )
+ ref_model_sync_steps: int = field(
+ default=512,
+ metadata={
+ "help": "τ parameter from the TR-DPO paper, which determines how frequently the current policy is "
+ "synchronized with the reference policy. To use this parameter, you must set `sync_ref_model=True`."
+ },
+ )
+
+ # Deprecated parameters
+ pad_token: str | None = field(
+ default=None,
+ metadata={
+ "help": "Deprecated. Set `tokenizer.pad_token` directly and pass it as `processing_class` to the trainer instead."
+ },
+ )
+
+ def __post_init__(self):
+ if isinstance(self.loss_type, str):
+ self.loss_type = [self.loss_type]
+ if self.loss_weights is not None and len(self.loss_weights) != len(self.loss_type):
+ raise ValueError(
+ "`loss_weights` must have the same length as `loss_type` when combining multiple losses. "
+ f"Got {len(self.loss_weights)} weights for {len(self.loss_type)} loss types."
+ )
+ if self.pad_token is not None:
+ warnings.warn(
+ "`pad_token` is deprecated and will be removed in v2.0.0. "
+ "Set `tokenizer.pad_token` directly and pass it as `processing_class` to the trainer instead.",
+ FutureWarning,
+ stacklevel=3,
+ )
+ if self.truncation_mode == "keep_end":
+ warnings.warn(
+ "The `'keep_end'` truncation mode is deprecated and will be removed in v2.0.0. "
+ "Use `truncation_mode='keep_start'` (the default) instead.",
+ FutureWarning,
+ stacklevel=3,
+ )
+
+ super().__post_init__()
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/dpo_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/dpo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d58d09cc1793b2aebc979a9edfc6e8a3dc0c822
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/dpo_trainer.py
@@ -0,0 +1,1621 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import contextlib
+import json
+import os
+import textwrap
+from collections import defaultdict
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import torch
+import torch.nn.functional as F
+import transformers
+from accelerate import PartialState
+from accelerate.logging import get_logger
+from accelerate.utils import is_peft_model, tqdm
+from datasets import Dataset, IterableDataset, IterableDatasetDict, concatenate_datasets
+from datasets.fingerprint import Hasher
+from packaging.version import Version
+from torch.utils.data import DataLoader
+from transformers import (
+ AutoProcessor,
+ DataCollator,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+ ProcessorMixin,
+)
+from transformers.data.data_collator import DataCollatorMixin
+from transformers.trainer_callback import TrainerCallback
+from transformers.trainer_utils import EvalPrediction
+from transformers.utils import is_liger_kernel_available, is_peft_available
+
+from ..data_utils import apply_chat_template, extract_prompt, is_conversational, prepare_multimodal_messages
+from ..models import get_act_offloading_ctx_manager, prepare_deepspeed, prepare_fsdp
+from ..models.utils import disable_gradient_checkpointing
+from .base_trainer import _BaseTrainer
+from .callbacks import SyncRefModelCallback
+from .dpo_config import DPOConfig
+from .utils import (
+ create_model_from_path,
+ disable_dropout_in_model,
+ entropy_from_logits,
+ flush_left,
+ get_config_model_id,
+ hash_module,
+ pad,
+ selective_log_softmax,
+ use_adapter,
+)
+
+
+if is_peft_available():
+ import peft
+ from peft import LoraConfig, PeftConfig, PeftModel, get_peft_model
+
+
+if is_liger_kernel_available():
+ from liger_kernel.chunked_loss import LigerFusedLinearDPOLoss
+
+
+logger = get_logger(__name__)
+
+
+FLASH_ATTENTION_VARIANTS = {
+ "flash_attention_2",
+ "flash_attention_3",
+ "kernels-community/flash-attn2",
+ "kernels-community/flash-attn3",
+ "kernels-community/vllm-flash-attn3",
+}
+
+
+def get_dataset_column_names(dataset: Dataset | IterableDataset) -> list[str]:
+ return list(next(iter(dataset)).keys()) if dataset.column_names is None else dataset.column_names
+
+
+@dataclass
+class DataCollatorForPreference(DataCollatorMixin):
+ """
+ Data collator used for preference data. Inputs are dynamically padded to the maximum length of a batch.
+
+ This collator expects each example in the input list to be a dictionary containing the keys `"prompt_ids"`,
+ `"chosen_ids"` and `"rejected_ids"`. The collator returns a dictionary containing the following keys:
+ - `"input_ids"`: Tensor of input IDs, padded to the maximum length of the batch. The first half of the batch
+ corresponds to the `"chosen_ids"` and the second half to the `"rejected_ids"`.
+ - `"attention_mask"`: Tensor of attention mask, padded to the maximum length of the batch.
+ - `"completion_mask"`: Tensor indicating the positions of the completion tokens, padded to the maximum length of
+ the batch.
+
+ Optionally, the examples can contain a `"ref_chosen_logps"` and `"ref_rejected_logps"` keys, in which case the
+ returned dictionary will also contain these keys with the corresponding tensors.
+
+ Args:
+ pad_token_id (`int`):
+ Token ID to use for padding.
+ max_length (`int`, *optional*):
+ Maximum length of the sequences after concatenation. Sequences longer than `max_length` are truncated
+ before padding, which avoids allocating oversized tensors for batches containing very long sequences.
+ truncation_mode (`str`, *optional*, defaults to `"keep_start"`):
+ Truncation mode when a concatenated sequence exceeds `max_length`. Possible values are `"keep_end"` and
+ `"keep_start"`.
+ pad_to_multiple_of (`int`, *optional*):
+ If set, the sequences will be padded to a multiple of this value.
+ return_tensors (`str`, *optional*, defaults to `"pt"`):
+ Type of Tensor to return. Only `"pt"` is currently supported.
+
+ Examples:
+ ```python
+ >>> from trl.trainer.dpo_trainer import DataCollatorForPreference
+
+ >>> collator = DataCollatorForPreference(pad_token_id=0)
+ >>> examples = [
+ ... {"prompt_ids": [1, 2, 3], "chosen_ids": [4, 5], "rejected_ids": [6]},
+ ... {"prompt_ids": [7, 8], "chosen_ids": [9], "rejected_ids": [10, 11]},
+ ... ]
+ >>> collator(examples)
+ {'input_ids': tensor([[ 1, 2, 3, 4, 5],
+ [ 7, 8, 9, 0, 0],
+ [ 1, 2, 3, 6, 0],
+ [ 7, 8, 10, 11, 0]]),
+ 'attention_mask': tensor([[1, 1, 1, 1, 1],
+ [1, 1, 1, 0, 0],
+ [1, 1, 1, 1, 0],
+ [1, 1, 1, 1, 0]]),
+ 'completion_mask': tensor([[0, 0, 0, 1, 1],
+ [0, 0, 1, 0, 0],
+ [0, 0, 0, 1, 0],
+ [0, 0, 1, 1, 0]])}
+ ```
+ """
+
+ pad_token_id: int
+ max_length: int | None = None
+ truncation_mode: str = "keep_start"
+ pad_to_multiple_of: int | None = None
+ return_tensors: str = "pt"
+
+ def torch_call(self, examples: list[dict[str, Any]]) -> dict[str, Any]:
+ prompt_chosen_ids = [example["prompt_ids"] + example["chosen_ids"] for example in examples]
+ prompt_rejected_ids = [example["prompt_ids"] + example["rejected_ids"] for example in examples]
+ chosen_mask = [[0] * len(example["prompt_ids"]) + [1] * len(example["chosen_ids"]) for example in examples]
+ rejected_mask = [[0] * len(example["prompt_ids"]) + [1] * len(example["rejected_ids"]) for example in examples]
+
+ if self.max_length is not None:
+ if self.truncation_mode == "keep_start":
+ sl = slice(None, self.max_length)
+ elif self.truncation_mode == "keep_end":
+ sl = slice(-self.max_length, None)
+ else:
+ raise ValueError(
+ f"Unsupported truncation mode: {self.truncation_mode}, expected 'keep_start' or 'keep_end'"
+ )
+ prompt_chosen_ids = [ids[sl] for ids in prompt_chosen_ids]
+ prompt_rejected_ids = [ids[sl] for ids in prompt_rejected_ids]
+ chosen_mask = [m[sl] for m in chosen_mask]
+ rejected_mask = [m[sl] for m in rejected_mask]
+
+ chosen_attention_mask = [[1] * len(ids) for ids in prompt_chosen_ids]
+ rejected_attention_mask = [[1] * len(ids) for ids in prompt_rejected_ids]
+ input_ids = prompt_chosen_ids + prompt_rejected_ids
+ attention_mask = chosen_attention_mask + rejected_attention_mask
+ completion_mask = chosen_mask + rejected_mask
+
+ # Convert to tensor
+ input_ids = [torch.tensor(ids) for ids in input_ids]
+ attention_mask = [torch.tensor(m, dtype=torch.long) for m in attention_mask]
+ completion_mask = [torch.tensor(m, dtype=torch.long) for m in completion_mask]
+ if "ref_chosen_logps" in examples[0]:
+ ref_chosen_logps = torch.tensor([example["ref_chosen_logps"] for example in examples])
+ if "ref_rejected_logps" in examples[0]:
+ ref_rejected_logps = torch.tensor([example["ref_rejected_logps"] for example in examples])
+
+ # Pad
+ output = {}
+ output["input_ids"] = pad(
+ input_ids,
+ padding_value=self.pad_token_id,
+ padding_side="right",
+ pad_to_multiple_of=self.pad_to_multiple_of,
+ )
+ output["attention_mask"] = pad(
+ attention_mask,
+ padding_value=0,
+ padding_side="right",
+ pad_to_multiple_of=self.pad_to_multiple_of,
+ )
+ output["completion_mask"] = pad(
+ completion_mask,
+ padding_value=0,
+ padding_side="right",
+ pad_to_multiple_of=self.pad_to_multiple_of,
+ )
+ if "ref_chosen_logps" in examples[0]:
+ output["ref_chosen_logps"] = ref_chosen_logps
+ if "ref_rejected_logps" in examples[0]:
+ output["ref_rejected_logps"] = ref_rejected_logps
+ return output
+
+
+@dataclass
+class DataCollatorForVisionPreference(DataCollatorMixin):
+ """
+ Data collator for vision-preference tasks.
+
+ Unlike text-only datasets, where the collator typically receives pre-tokenized inputs ready for batching,
+ vision-language data processing involves converting images into pixel values. This conversion is disk-intensive,
+ making upfront preprocessing of the entire dataset impractical. Therefore, this collator performs tokenization and
+ image processing on-the-fly to efficiently prepare batches.
+
+ Each input example should be a dictionary containing at least:
+ - An `"images"` key holding a list of images, or an `"image"` key holding a single image.
+ - Keys `"prompt"` `"chosen"` and `"rejected"` for the prompt and preference responses.
+
+ The collator outputs a dictionary including:
+ - `"input_ids"`: Tensor of token IDs.
+ - `"attention_mask"`: Tensor indicating attention mask.
+ - `"completion_mask"`: Tensor indicating which tokens correspond to completions.
+ - `"pixel_values"`: Tensor representing image pixel values.
+
+ Additional keys may be present depending on the processor, such as `"image_grid_thw"` or `"image_position_ids"`.
+
+ Args:
+ processor ([`~transformers.ProcessorMixin`]):
+ The processor used to tokenize text and process images. It must be a subclass of
+ [`~transformers.ProcessorMixin`] and include a `tokenizer` with a defined `pad_token_id`.
+ max_length (`int`, *optional*):
+ Maximum sequence length. Sequences longer than `max_length` are truncated before padding, which avoids
+ allocating oversized tensors for batches containing very long sequences. Only `"keep_start"` truncation
+ applies to vision datasets; `"keep_end"` is rejected upstream.
+ pad_to_multiple_of (`int`, *optional*):
+ If set, the sequences will be padded to a multiple of this value.
+ return_tensors (`str`, *optional*, defaults to `"pt"`):
+ The tensor type to return. Currently, only `"pt"` (PyTorch tensors) is supported.
+
+ Example:
+ ```python
+ >>> from trl.trainer.dpo_trainer import DataCollatorForVisionPreference
+ >>> from transformers import AutoProcessor
+
+ >>> processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-VL-7B-Instruct")
+ >>> collator = DataCollatorForVisionPreference(processor)
+ >>> examples = [
+ ... {
+ ... "images": [Image.open("image_0.png")],
+ ... "prompt": [{"role": "user", "content": "What is this?"}],
+ ... "chosen": [{"role": "assistant", "content": "This is a cat."}],
+ ... "rejected": [{"role": "assistant", "content": "This is a dog."}],
+ ... },
+ ... {
+ ... "images": [Image.open("image_1.png")],
+ ... "prompt": [{"role": "user", "content": "Describe this image."}],
+ ... "chosen": [{"role": "assistant", "content": "A beautiful landscape."}],
+ ... "rejected": [{"role": "assistant", "content": "An urban cityscape."}],
+ ... },
+ ... ]
+ >>> collator(examples)
+ {'input_ids': tensor([[151644, 8948, 198, 2610, 525, 264, 10950, 17847, 13, 151645, 198, 151644, 872, 198, 151652, 151655, 151655, 151655, 151655, 151653, 3838, 374, 419, 30, 151645, 198, 151644, 77091, 198, 1986, 374, 264, 8251, 13, 151645, 198],
+ [151644, 8948, 198, 2610, 525, 264, 10950, 17847, 13, 151645, 198, 151644, 872, 198, 151652, 151655, 151655, 151655, 151655, 151653, 74785, 419, 2168, 13, 151645, 198, 151644, 77091, 198, 32, 6233, 18414, 13, 151645, 198, 151643],
+ [151644, 8948, 198, 2610, 525, 264, 10950, 17847, 13, 151645, 198, 151644, 872, 198, 151652, 151655, 151655, 151655, 151655, 151653, 3838, 374, 419, 30, 151645, 198, 151644, 77091, 198, 1986, 374, 264, 5562, 13, 151645, 198],
+ [151644, 8948, 198, 2610, 525, 264, 10950, 17847, 13, 151645, 198, 151644, 872, 198, 151652, 151655, 151655, 151655, 151655, 151653, 74785, 419, 2168, 13, 151645, 198, 151644, 77091, 198, 2082, 15662, 3283, 57518, 13, 151645, 198]]),
+ 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]),
+ 'pixel_values': tensor([[-1.3251, 0.1347, -0.4784, ..., 0.4537, -0.0156, 1.2358],
+ [ 0.5727, 0.4997, -0.9164, ..., -0.5701, 0.7950, -0.7123],
+ [-0.0550, -0.8288, 1.0690, ..., -0.1293, -0.1151, 1.6055],
+ ...,
+ [ 0.2953, 0.5581, 0.1785, ..., -0.7123, -0.7977, 0.1693],
+ [-0.7558, 1.0398, 1.3464, ..., -0.5417, -0.5417, 0.4395],
+ [ 0.8063, 0.6895, 0.4267, ..., -0.4422, 1.3354, 0.1266]]),
+ 'image_grid_thw': tensor([[1, 4, 4],
+ [1, 4, 4],
+ [1, 4, 4],
+ [1, 4, 4]]),
+ 'completion_mask': tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1]])}
+ ```
+ """
+
+ processor: ProcessorMixin
+ max_length: int | None = None
+ pad_to_multiple_of: int | None = None
+ return_tensors: str = "pt"
+
+ def torch_call(self, examples: list[dict[str, Any]]) -> dict[str, Any]:
+ if self.pad_to_multiple_of is not None:
+ raise NotImplementedError(
+ "Padding to a multiple of a value is not yet implemented for vision-language modeling and "
+ "prompt-completion data."
+ )
+ if "image" in examples[0]:
+ for example in examples:
+ example["images"] = [example.pop("image")]
+ images = [example["images"] for example in examples] * 2 # repeat for chosen and rejected
+ # Transformers requires at least one image in the batch, otherwise it throws an error
+ if all(img_list == [] for img_list in images):
+ images = None
+ if is_conversational(examples[0]): # conversational case
+ for example in examples:
+ example["prompt"] = prepare_multimodal_messages(example["prompt"], images=example["images"])
+ example["chosen"] = prepare_multimodal_messages(example["chosen"])
+ example["rejected"] = prepare_multimodal_messages(example["rejected"])
+ examples = [apply_chat_template(example, self.processor) for example in examples]
+
+ prompts = [example["prompt"] for example in examples] * 2 # repeat for chosen and rejected
+ chosens = [example["chosen"] for example in examples]
+ rejecteds = [example["rejected"] for example in examples]
+
+ processed_prompts = self.processor(
+ images=images,
+ text=prompts,
+ padding=True,
+ padding_side="left",
+ return_tensors=self.return_tensors,
+ add_special_tokens=False, # to avoid adding the BOS, twice see https://huggingface.co/blog/qgallouedec/gotchas-in-tokenizer-behavior#7-chat-template-and-tokenization-dont-compose-due-to-special-tokens
+ )
+ processed_chosens = self.processor(
+ text=chosens,
+ padding=True,
+ padding_side="right",
+ return_tensors=self.return_tensors,
+ add_special_tokens=False, # to avoid adding the BOS, twice see https://huggingface.co/blog/qgallouedec/gotchas-in-tokenizer-behavior#7-chat-template-and-tokenization-dont-compose-due-to-special-tokens
+ )
+ processed_rejecteds = self.processor(
+ text=rejecteds,
+ padding=True,
+ padding_side="right",
+ return_tensors=self.return_tensors,
+ add_special_tokens=False, # to avoid adding the BOS, twice see https://huggingface.co/blog/qgallouedec/gotchas-in-tokenizer-behavior#7-chat-template-and-tokenization-dont-compose-due-to-special-tokens
+ )
+
+ # Concatenate prompts and completions
+ prompt_ids, prompt_mask = processed_prompts["input_ids"], processed_prompts["attention_mask"]
+ chosen_ids, chosen_mask = processed_chosens["input_ids"], processed_chosens["attention_mask"]
+ rejected_ids, rejected_mask = processed_rejecteds["input_ids"], processed_rejecteds["attention_mask"]
+ pad_token_id = self.processor.tokenizer.pad_token_id or self.processor.tokenizer.eos_token_id
+ completion_ids = torch.cat(tuple(pad([chosen_ids, rejected_ids], padding_value=pad_token_id)))
+ completion_mask = torch.cat(tuple(pad([chosen_mask, rejected_mask], padding_value=0)))
+ input_ids = torch.cat((prompt_ids, completion_ids), dim=1)
+ attention_mask = torch.cat((prompt_mask, completion_mask), dim=1)
+ completion_mask = torch.cat((torch.zeros_like(prompt_mask), completion_mask), dim=1)
+ if "token_type_ids" in processed_prompts: # special case for Gemma
+ prompt_token_type_ids = processed_prompts["token_type_ids"]
+ chosen_type_ids = processed_chosens["token_type_ids"]
+ rejected_type_ids = processed_rejecteds["token_type_ids"]
+ completion_token_type_ids = torch.cat(tuple(pad([chosen_type_ids, rejected_type_ids], padding_value=0)))
+ token_type_ids = torch.cat((prompt_token_type_ids, completion_token_type_ids), dim=1)
+ if "mm_token_type_ids" in processed_prompts: # special case for Qwen2.5-VL
+ prompt_mm_token_type_ids = processed_prompts["mm_token_type_ids"]
+ mm_token_type_ids = torch.cat((prompt_mm_token_type_ids, torch.zeros_like(completion_ids)), dim=1)
+
+ # Flush left to reduce padding
+ if "token_type_ids" in processed_prompts and "mm_token_type_ids" in processed_prompts:
+ attention_mask, input_ids, completion_mask, token_type_ids, mm_token_type_ids = flush_left(
+ attention_mask, input_ids, completion_mask, token_type_ids, mm_token_type_ids
+ )
+ elif "token_type_ids" in processed_prompts:
+ attention_mask, input_ids, completion_mask, token_type_ids = flush_left(
+ attention_mask, input_ids, completion_mask, token_type_ids
+ )
+ elif "mm_token_type_ids" in processed_prompts:
+ attention_mask, input_ids, completion_mask, mm_token_type_ids = flush_left(
+ attention_mask, input_ids, completion_mask, mm_token_type_ids
+ )
+ else:
+ attention_mask, input_ids, completion_mask = flush_left(attention_mask, input_ids, completion_mask)
+
+ if self.max_length is not None:
+ input_ids = input_ids[:, : self.max_length]
+ attention_mask = attention_mask[:, : self.max_length]
+ completion_mask = completion_mask[:, : self.max_length]
+ if "token_type_ids" in processed_prompts:
+ token_type_ids = token_type_ids[:, : self.max_length]
+ if "mm_token_type_ids" in processed_prompts:
+ mm_token_type_ids = mm_token_type_ids[:, : self.max_length]
+
+ # Build the output dictionary
+ output = processed_prompts # we take processed_prompts because it contains the images
+ output["input_ids"] = input_ids
+ output["attention_mask"] = attention_mask
+ output["completion_mask"] = completion_mask
+ if "token_type_ids" in processed_prompts:
+ output["token_type_ids"] = token_type_ids
+ if "mm_token_type_ids" in processed_prompts:
+ output["mm_token_type_ids"] = mm_token_type_ids
+ return output
+
+
+class DPOTrainer(_BaseTrainer):
+ """
+ Trainer for Direct Preference Optimization (DPO) method. This algorithm was initially proposed in the paper [Direct
+ Preference Optimization: Your Language Model is Secretly a Reward Model](https://huggingface.co/papers/2305.18290).
+ This class is a wrapper around the [`~transformers.Trainer`] class and inherits all of its attributes and methods.
+
+ Example:
+
+ ```python
+ from trl import DPOTrainer
+ from datasets import load_dataset
+
+ dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
+
+ trainer = DPOTrainer(
+ model="Qwen/Qwen2.5-0.5B-Instruct",
+ train_dataset=dataset,
+ )
+ trainer.train()
+ ```
+
+ Args:
+ model (`str` or [`~transformers.PreTrainedModel`] or [`~peft.PeftModel`]):
+ Model to be trained. Can be either:
+
+ - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a
+ path to a *directory* containing model weights saved using
+ [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded
+ using `.from_pretrained` (where `` is derived from the model
+ config) with the keyword arguments in `args.model_init_kwargs`.
+ - A [`~transformers.PreTrainedModel`] object. Only causal language models are supported.
+ - A [`~peft.PeftModel`] object. Only causal language models are supported.
+ ref_model ([`~transformers.PreTrainedModel`], *optional*):
+ Reference model used to compute the reference log probabilities.
+
+ - If provided, this model is used directly as the reference policy.
+ - If `None`, the trainer will automatically use the initial policy corresponding to `model`, i.e. the model
+ state before DPO training starts.
+ args ([`DPOConfig`], *optional*):
+ Configuration for this trainer. If `None`, a default configuration is used.
+ data_collator ([`~transformers.DataCollator`], *optional*):
+ Function to use to form a batch from a list of elements of the processed `train_dataset` or `eval_dataset`.
+ Will default to [`~trainer.dpo_trainer.DataCollatorForPreference`] if the model is a language model and
+ [`~trainer.dpo_trainer.DataCollatorForVisionPreference`] if the model is a vision-language model. Custom
+ collators must truncate sequences before padding; the trainer does not apply post-collation truncation.
+ train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]):
+ Dataset to use for training. This trainer supports both [language modeling](#language-modeling) type and
+ [prompt-completion](#prompt-completion) type. The format of the samples can be either:
+
+ - [Standard](dataset_formats#standard): Each sample contains plain text.
+ - [Conversational](dataset_formats#conversational): Each sample contains structured messages (e.g., role
+ and content).
+ eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`):
+ Dataset to use for evaluation. It must meet the same requirements as `train_dataset`.
+ processing_class ([`~transformers.PreTrainedTokenizerBase`] or [`~transformers.ProcessorMixin`], *optional*):
+ Processing class used to process the data. The padding side must be set to "left". If `None`, the
+ processing class is loaded from the model's name with [`~transformers.AutoProcessor.from_pretrained`]. A
+ padding token, `tokenizer.pad_token`, must be set. If the processing class has not set a padding token,
+ `tokenizer.eos_token` will be used as the default.
+ compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*):
+ The function that will be used to compute metrics at evaluation. Must take a
+ [`~transformers.EvalPrediction`] and return a dictionary string to metric values. When passing
+ [`SFTConfig`] with `batch_eval_metrics` set to `True`, your `compute_metrics` function must take a boolean
+ `compute_result` argument. This will be triggered after the last eval batch to signal that the function
+ needs to calculate and return the global summary statistics rather than accumulating the batch-level
+ statistics.
+ callbacks (list of [`~transformers.TrainerCallback`], *optional*):
+ List of callbacks to customize the training loop. Will add those to the list of default callbacks detailed
+ in [here](https://huggingface.co/docs/transformers/main_classes/callback).
+
+ If you want to remove one of the default callbacks used, use the [`~transformers.Trainer.remove_callback`]
+ method.
+ optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *optional*, defaults to `(None, None)`):
+ A tuple containing the optimizer and the scheduler to use. Will default to an instance of `AdamW` on your
+ model and a scheduler given by [`~transformers.get_linear_schedule_with_warmup`] controlled by `args`.
+ peft_config ([`~peft.PeftConfig`], *optional*):
+ PEFT configuration used to wrap the model. If `None`, the model is not wrapped.
+ """
+
+ _tag_names = ["trl", "dpo"]
+ _name = "DPO"
+ _paper = {
+ "title": "Direct Preference Optimization: Your Language Model is Secretly a Reward Model",
+ "id": "2305.18290",
+ # docstyle-ignore
+ "citation": textwrap.dedent("""\
+ @inproceedings{rafailov2023direct,
+ title = {{Direct Preference Optimization: Your Language Model is Secretly a Reward Model}},
+ author = {Rafael Rafailov and Archit Sharma and Eric Mitchell and Christopher D. Manning and Stefano Ermon and Chelsea Finn},
+ year = 2023,
+ booktitle = {Advances in Neural Information Processing Systems 36: Annual Conference on Neural Information Processing Systems 2023, NeurIPS 2023, New Orleans, LA, USA, December 10 - 16, 2023},
+ url = {http://papers.nips.cc/paper_files/paper/2023/hash/a85b405ed65c6477a4fe8302b5e06ce7-Abstract-Conference.html},
+ editor = {Alice Oh and Tristan Naumann and Amir Globerson and Kate Saenko and Moritz Hardt and Sergey Levine},
+ }"""),
+ }
+
+ def __init__(
+ self,
+ model: "str | PreTrainedModel | PeftModel",
+ ref_model: PreTrainedModel | None = None,
+ args: DPOConfig | None = None,
+ data_collator: DataCollator | None = None,
+ train_dataset: Dataset | IterableDataset | None = None,
+ eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None,
+ processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None,
+ compute_metrics: Callable[[EvalPrediction], dict] | None = None,
+ callbacks: list[TrainerCallback] | None = None,
+ optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None),
+ peft_config: "PeftConfig | None" = None,
+ ):
+ # Args
+ if args is None:
+ model_name = model if isinstance(model, str) else get_config_model_id(model.config)
+ model_name = model_name.split("/")[-1]
+ args = DPOConfig(f"{model_name}-DPO")
+
+ if train_dataset is None:
+ raise ValueError("`train_dataset` is required")
+ elif isinstance(train_dataset, IterableDataset):
+ # IterableDataset requires dispatch_batches=False because Accelerate's dispatch mode may try to concatenate
+ # batches from multiple processes, leading to mismatch errors.
+ if args.accelerator_config.dispatch_batches is True:
+ logger.warning(
+ "You are using an `IterableDataset` for training with `dispatch_batches=True`. `dispatch_batches` "
+ "is forced to `False` when using an `IterableDataset`. To remove this warning, unset "
+ "`dispatch_batches` in `DPOConfig` or set it to `False`."
+ )
+ args.accelerator_config.dispatch_batches = False
+
+ # Model
+ if isinstance(model, str):
+ model_init_kwargs = args.model_init_kwargs or {}
+ # Distributed training requires device_map=None ("auto" fails)
+ if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]:
+ model_init_kwargs["device_map"] = None
+ model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+ model = create_model_from_path(model, **model_init_kwargs)
+ else:
+ if args.model_init_kwargs is not None:
+ logger.warning(
+ "You passed `model_init_kwargs` to the `DPOConfig`, but your model is already instantiated. "
+ "The `model_init_kwargs` will be ignored."
+ )
+ # Non-quantized models do not have the `is_loaded_in_{8,4}bit` attributes, whereas quantized models do
+ _is_quantized_model = getattr(model, "is_loaded_in_4bit", False) or getattr(model, "is_loaded_in_8bit", False)
+ if ref_model is model:
+ raise ValueError(
+ "`model` and `ref_model` cannot be the same object. In most cases you should omit `ref_model` and "
+ "we'll initialize it to a copy of `model` for you."
+ )
+
+ # Processing class
+ if processing_class is None:
+ processing_class = AutoProcessor.from_pretrained(
+ get_config_model_id(model.config), trust_remote_code=args.trust_remote_code
+ )
+
+ # Handle pad token for processors or tokenizers
+ if isinstance(processing_class, ProcessorMixin):
+ self._tokenizer = processing_class.tokenizer
+ self._is_vlm = True
+ elif isinstance(processing_class, PreTrainedTokenizerBase):
+ self._tokenizer = processing_class
+ self._is_vlm = False
+ else:
+ raise TypeError("The `processing_class` must be either a `PreTrainedTokenizerBase` or a `ProcessorMixin`")
+
+ if self._tokenizer.pad_token is None:
+ self._tokenizer.pad_token = self._tokenizer.eos_token
+
+ # PEFT
+ if peft_config is not None:
+ if not is_peft_available():
+ raise ImportError(
+ "You passed `peft_config` but the `peft` library is not installed. "
+ "Install it with `pip install trl[peft]`."
+ )
+ if not isinstance(peft_config, PeftConfig):
+ raise TypeError(
+ f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), "
+ f"got {type(peft_config).__name__}."
+ )
+ if is_peft_model(model):
+ raise ValueError(
+ "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first merge "
+ "and unload the existing adapter, save the resulting base model, and then pass that base model along "
+ "with the new `peft_config` to the trainer."
+ )
+ # Create PEFT model
+ # ZeRO-3 + PEFT for non-quantized models:
+ # - PEFT's default autocast_adapter_dtype=True upcasts LoRA adapter params to fp32 even when the base model is bf16.
+ # - ZeRO-3's _allgather_params_coalesced allocates output buffers using the dtype of the first persistent parameter,
+ # so mixed-dtype persistent_parameters (bf16 base + fp32 LoRA) cause a TypeError on the first optimizer step.
+ # - Passing autocast_adapter_dtype=False keeps adapter params in the base model dtype (bf16), fixing the mismatch.
+ # - This is safe: the fp32 upcast is a QLoRA-specific concern (low-bit quantized base models), not needed for
+ # non-quantized bf16 training.
+ # - See:
+ # - TRL issue: https://github.com/huggingface/trl/issues/6089
+ # - Upstream issue: https://github.com/deepspeedai/DeepSpeed/issues/8072
+ # - autocast_adapter_dtype was introduced in PEFT 0.12.0; before, no upcast existed: no need to pass the kwarg
+ get_peft_model_kwargs = {}
+ if (
+ args.deepspeed_plugin is not None
+ and args.deepspeed_plugin.zero_stage == 3
+ and not _is_quantized_model
+ and Version(peft.__version__) >= Version("0.12.0")
+ ):
+ get_peft_model_kwargs["autocast_adapter_dtype"] = False
+ model = get_peft_model(model, peft_config, **get_peft_model_kwargs)
+
+ elif is_peft_model(model) and ref_model is None:
+ # If the model is a PEFT model with a pretrained adapter, we need to create a "ref" adapter that is a copy
+ # of the "default" adapter, so that we can use it as the reference model during DPO training. PEFT only
+ # supports one adapter per model when the LoRA config uses `target_parameters` (see peft#3340), so in that
+ # case we skip the "ref" adapter and compute the reference log probs with adapters disabled, i.e. with the
+ # base model.
+ default_config = model.peft_config["default"]
+ if isinstance(default_config, LoraConfig) and default_config.target_parameters:
+ logger.warning(
+ "PEFT can't add a frozen reference adapter alongside one that uses `target_parameters` "
+ "(peft#3340), so the reference log probs are computed from the base model (adapters disabled). "
+ "If you wrapped the model only to apply LoRA, pass a `peft_config` to the trainer instead; if you "
+ "wrapped it deliberately (pretrained adapter or custom init), note that the base model matches "
+ "your adapter only when it's freshly zero-initialized. If it is, this warning is safe to ignore."
+ )
+ else:
+ model.add_adapter("ref", default_config)
+ for name, param in model.named_parameters():
+ if ".default." in name:
+ ref_name = name.replace(".default.", ".ref.")
+ ref_param = model.get_parameter(ref_name)
+ ref_param.data.copy_(param.data)
+
+ # When using gradient checkpointing with PEFT, we need to enable input gradients. transformers.Trainer normally
+ # handles this, but a bug currently prevents it; see https://github.com/huggingface/transformers/issues/42489
+ if is_peft_model(model) and args.gradient_checkpointing:
+ model.enable_input_require_grads()
+
+ # When using QLoRA, the PEFT adapter weights are converted to bf16 to follow the recommendations from the
+ # original paper (see https://huggingface.co/papers/2305.14314, paragraph 3). Normally, this can be done by
+ # passing `autocast_adapter_dtype=False` to `get_peft_model`, but this option is not yet supported for
+ # quantized models. See: https://github.com/huggingface/peft/issues/2889
+ if _is_quantized_model:
+ for param in model.parameters():
+ if param.requires_grad:
+ param.data = param.data.to(torch.bfloat16)
+
+ # Data collator
+ self.padding_free = args.padding_free
+ if self.padding_free:
+ logger.warning(
+ "`padding_free=True` is temporarily unavailable after a refactor and is currently disabled. Falling "
+ "back to standard padding (`padding_free=False`). This feature is planned to return in a future "
+ "update; for now, please set `padding_free=False` explicitly."
+ )
+ self.padding_free = False
+ dataset_sample = next(iter(train_dataset))
+ self._is_vision_dataset = "image" in dataset_sample or "images" in dataset_sample
+ if self._is_vision_dataset and not self._is_vlm:
+ raise ValueError(
+ "The dataset appears to be vision-related (contains 'image' or 'images' keys), but the provided "
+ "model does not seem to be a vision-language model. Please check your model and dataset."
+ )
+ if self._is_vision_dataset and args.max_length is not None and args.truncation_mode == "keep_end":
+ raise ValueError(
+ "truncation_mode='keep_end' is not supported for vision-language models. Image tokens reside "
+ "inside the prompt portion of the sequence; depending on the example, keep_end may silently "
+ "drop them, causing pixel_values to be forwarded to the model with no corresponding visual "
+ "tokens in input_ids. Use truncation_mode='keep_start' (the default) or set max_length=None."
+ )
+ if self._is_vision_dataset and args.precompute_ref_log_probs:
+ raise ValueError(
+ "`precompute_ref_log_probs=True` is not supported for vision datasets. For vision-language "
+ "models, all data processing is performed on the fly rather than upfront, and running a full "
+ "forward pass of the reference model over the entire dataset is not supported for large "
+ "multimodal models. Set `precompute_ref_log_probs=False`."
+ )
+ if data_collator is None and not self._is_vision_dataset:
+ # Get the pad token: if not provided, use the one from the processing class or the eos token
+ # if the processing class does not have a pad token.
+ pad_token = args.pad_token or self._tokenizer.pad_token or self._tokenizer.eos_token
+ if pad_token not in self._tokenizer.get_vocab():
+ raise ValueError(
+ f"The specified `pad_token` ('{pad_token}') is not found in the vocabulary of the given "
+ f"`processing_class` ({processing_class.__class__.__name__}). Ensure that the `pad_token` exists "
+ "in the vocabulary before using it as a padding token."
+ )
+ self._tokenizer.pad_token = pad_token
+ data_collator = DataCollatorForPreference(
+ pad_token_id=self._tokenizer.pad_token_id,
+ max_length=args.max_length,
+ truncation_mode=args.truncation_mode,
+ pad_to_multiple_of=args.pad_to_multiple_of,
+ )
+ elif data_collator is None and self._is_vision_dataset:
+ data_collator = DataCollatorForVisionPreference(
+ processor=processing_class,
+ max_length=args.max_length,
+ pad_to_multiple_of=args.pad_to_multiple_of,
+ )
+
+ # Training arguments
+ self.beta = args.beta
+ self.precompute_ref_logps = args.precompute_ref_log_probs
+ self.loss_types = args.loss_type # args.loss_type is already a list
+ self.loss_weights = args.loss_weights or [1.0] * len(self.loss_types)
+ self.ld_alpha = args.ld_alpha
+ self.f_divergence_type = args.f_divergence_type
+ self.f_alpha_divergence_coef = args.f_alpha_divergence_coef
+ self.label_smoothing = args.label_smoothing
+ self.use_weighting = args.use_weighting
+ if self.use_weighting and any(loss_type in {"aot", "aot_unpaired"} for loss_type in self.loss_types):
+ raise NotImplementedError(
+ "WPO-style weighting is not implemented for 'aot' or 'aot_unpaired' because those losses sort "
+ "samples, which would misalign per-pair weights."
+ )
+ if "robust" in self.loss_types and not (0.0 <= self.label_smoothing < 0.5):
+ logger.warning(
+ "The `label_smoothing` parameter should lie in [0.0, 0.5) for the 'robust' loss. You provided "
+ f"{self.label_smoothing}."
+ )
+ if "exo_pair" in self.loss_types and self.label_smoothing == 0.0:
+ raise ValueError(
+ "Label smoothing must be greater than 0.0 when using 'exo_pair' loss. The EXO paper recommends a "
+ "value of 1e-3."
+ )
+ self.use_liger_kernel = args.use_liger_kernel
+ if args.use_liger_kernel:
+ if not is_liger_kernel_available():
+ raise ImportError(
+ "You set `use_liger_kernel=True` but the liger kernel is not available. "
+ "Please install liger-kernel first: `pip install liger-kernel`"
+ )
+ if len(self.loss_types) != 1:
+ raise NotImplementedError(
+ "Multiple loss types are not yet supported when using Liger kernel. If you need this feature, "
+ "please open a feature request at https://github.com/huggingface/trl/issues."
+ )
+ self.liger_loss_fn = LigerFusedLinearDPOLoss(beta=args.beta, loss_type=self.loss_types[0])
+ if compute_metrics is not None:
+ raise ValueError(
+ "compute_metrics is not supported with the Liger kernel. compute_metrics requires to be able to "
+ "recover the logits from the forward pass, but Liger kernel does not materialize logits."
+ )
+ if self.precompute_ref_logps:
+ raise ValueError(
+ "Liger DPO loss does not support precomputing reference log probabilities. Either disable "
+ "`precompute_ref_log_probs` or set `use_liger_kernel` to False."
+ )
+ if is_peft_model(model):
+ raise NotImplementedError("Liger DPO loss is not implemented for PEFT models.")
+
+ # Dataset
+ # Skip dataset preparation if it's a VLM, where preprocessing (e.g., image-to-pixel conversion) is too costly
+ # and done on the fly instead.
+ skip_prepare_dataset = self._is_vision_dataset
+ if not skip_prepare_dataset:
+ train_dataset = self._prepare_dataset(train_dataset, processing_class, args, "train")
+ if eval_dataset is not None:
+ if isinstance(eval_dataset, dict):
+ eval_dataset = {
+ key: self._prepare_dataset(dataset, processing_class, args, key)
+ for key, dataset in eval_dataset.items()
+ }
+ else:
+ eval_dataset = self._prepare_dataset(eval_dataset, processing_class, args, "eval")
+
+ # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was
+ # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream
+ # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we
+ # default to the recommended non-reentrant behavior here, while preserving any user-provided value.
+ if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"):
+ args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {}
+ args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False)
+
+ super().__init__(
+ model=model,
+ args=args,
+ data_collator=data_collator,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=processing_class,
+ compute_metrics=compute_metrics,
+ callbacks=callbacks,
+ optimizers=optimizers,
+ )
+
+ # Initialize activation offloading context
+ if self.args.activation_offloading:
+ self.maybe_activation_offload_context = get_act_offloading_ctx_manager(model=self.model)
+ else:
+ self.maybe_activation_offload_context = contextlib.nullcontext()
+
+ # Reference model
+ if ref_model is None:
+ if is_peft_model(self.model) or args.precompute_ref_log_probs:
+ # If PEFT is used, the reference model is not needed since the adapter can be disabled to revert to the
+ # initial model. If precompute_ref_log_probs is True, the reference model does not need to be kept in
+ # memory during training.
+ self.ref_model = None
+ else:
+ ref_model_init_kwargs = args.model_init_kwargs or {}
+ # Distributed training requires device_map=None ("auto" fails)
+ if self.args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]:
+ ref_model_init_kwargs["device_map"] = None
+ ref_model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+ ref_model_path = get_config_model_id(self.model.config)
+ self.ref_model = create_model_from_path(ref_model_path, **ref_model_init_kwargs)
+ else:
+ self.ref_model = ref_model
+
+ # Disable dropout in the models
+ if args.disable_dropout:
+ disable_dropout_in_model(model)
+ if self.ref_model is not None:
+ disable_dropout_in_model(self.ref_model)
+
+ # Initialize the metrics
+ self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)}
+ self._total_train_tokens = 0
+
+ # Gradient accumulation requires scaled loss. Normally, loss scaling in the parent class depends on whether the
+ # model accepts loss-related kwargs. Since we compute our own loss, this check is irrelevant. We set
+ # self.model_accepts_loss_kwargs to False to enable scaling.
+ self.model_accepts_loss_kwargs = False
+
+ # Add tags to the model
+ self.model.add_model_tags(self._tag_names)
+
+ if self.ref_model is not None:
+ if self.is_deepspeed_enabled:
+ self.ref_model = prepare_deepspeed(self.ref_model, self.accelerator)
+ elif self.is_fsdp_enabled:
+ self.ref_model = prepare_fsdp(self.ref_model, self.accelerator)
+ else:
+ self.ref_model = self.accelerator.prepare_model(self.ref_model, evaluation_mode=True)
+
+ if args.sync_ref_model:
+ if is_peft_model(self.model):
+ raise NotImplementedError(
+ "You passed `sync_ref_model=True` while using a PEFT model, which is currently not supported. "
+ "With PEFT, DPOTrainer does not keep a separate reference model in memory; instead, it recovers "
+ "reference behavior by temporarily disabling the adapter. As a result, there is no standalone "
+ "`ref_model` instance to synchronize. Use `sync_ref_model=False`, or opt for full fine-tuning if "
+ "you need a synced reference model. If you need `sync_ref_model` to work with PEFT, please open a "
+ "feature request at https://github.com/huggingface/trl/issues."
+ )
+ if args.precompute_ref_log_probs:
+ raise ValueError(
+ "You cannot use `sync_ref_model=True` together with `precompute_ref_log_probs=True`. "
+ "`precompute_ref_log_probs=True` assumes a fixed reference model, but with `sync_ref_model=True` "
+ "the reference model is periodically updated during training, making any precomputed reference "
+ "log-probs stale. Set `precompute_ref_log_probs=False` or disable `sync_ref_model`."
+ )
+ self.add_callback(SyncRefModelCallback(ref_model=self.ref_model, accelerator=self.accelerator))
+
+ if args.precompute_ref_log_probs:
+ if isinstance(self.train_dataset, IterableDataset) or isinstance(
+ self.eval_dataset, (IterableDataset, IterableDatasetDict)
+ ):
+ raise ValueError(
+ "`precompute_ref_log_probs=True` is not supported with IterableDataset. Please use a map-style "
+ "Dataset or set `precompute_ref_log_probs=False`."
+ )
+
+ self.train_dataset = self._precompute_ref_logps(
+ self.train_dataset,
+ "train",
+ self.args.precompute_ref_batch_size or self.args.per_device_train_batch_size,
+ )
+ if self.eval_dataset is not None:
+ if isinstance(self.eval_dataset, dict):
+ self.eval_dataset = {
+ name: self._precompute_ref_logps(
+ dataset, name, self.args.precompute_ref_batch_size or self.args.per_device_eval_batch_size
+ )
+ for name, dataset in self.eval_dataset.items()
+ }
+ else:
+ self.eval_dataset = self._precompute_ref_logps(
+ self.eval_dataset,
+ "eval",
+ self.args.precompute_ref_batch_size or self.args.per_device_eval_batch_size,
+ )
+
+ def _tokenize(
+ self,
+ processing_class: PreTrainedTokenizerBase | ProcessorMixin,
+ input: str | list,
+ **kwargs,
+ ) -> dict[str, list]:
+ """Tokenize a single example for dataset preprocessing.
+
+ Dispatches to `apply_chat_template` for conversational input (list of message dicts) and to `__call__` for
+ non-conversational input (str). For VLMs, normalizes the batch dimension that processors emit even for single
+ examples.
+
+ Args:
+ processing_class ([`~transformers.PreTrainedTokenizerBase`] or [`~transformers.ProcessorMixin`]):
+ The tokenizer or processor to use.
+ input (`str` or `list`):
+ A string for non-conversational input, or a list of message dicts for conversational input.
+ **kwargs:
+ Forwarded to `apply_chat_template` (e.g. `add_generation_prompt`, `return_assistant_tokens_mask`).
+
+ Returns:
+ `dict` with at least an `"input_ids"` key mapping to a flat `list[int]`.
+ """
+ if isinstance(input, list): # conversational: list of message dicts
+ if self._is_vlm:
+ input = prepare_multimodal_messages(input)
+ result = processing_class.apply_chat_template(input, tokenize=True, return_dict=True, **kwargs)
+ else: # non-conversational: plain text string
+ result = processing_class(text=input)
+ # VLMs emit a batch dimension even for single examples; unwrap it
+ if self._is_vlm:
+ return {k: v[0] for k, v in result.items()}
+ return result
+
+ def _prepare_dataset(
+ self,
+ dataset: Dataset | IterableDataset,
+ processing_class: PreTrainedTokenizerBase | ProcessorMixin,
+ args: DPOConfig,
+ dataset_name: str,
+ ) -> Dataset | IterableDataset:
+ # Build the kwargs for the `map` function
+ map_kwargs = {}
+ if isinstance(dataset, Dataset): # IterableDataset does not support num_proc
+ map_kwargs["num_proc"] = args.dataset_num_proc
+
+ with PartialState().main_process_first():
+ # Extract the prompt if needed
+ first_example = next(iter(dataset))
+ if "prompt" not in first_example:
+ if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc`
+ map_kwargs["desc"] = f"Extracting prompt from {dataset_name} dataset"
+ dataset = dataset.map(extract_prompt, **map_kwargs)
+
+ # Add EOS token if needed: non-conversational only
+ first_example = next(iter(dataset))
+ if not is_conversational(first_example):
+ if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc`
+ map_kwargs["desc"] = f"Adding EOS to {dataset_name} dataset"
+
+ def add_eos(example, eos_token):
+ if not example["chosen"].endswith(eos_token):
+ example["chosen"] = example["chosen"] + eos_token
+ if not example["rejected"].endswith(eos_token):
+ example["rejected"] = example["rejected"] + eos_token
+ return example
+
+ dataset = dataset.map(add_eos, fn_kwargs={"eos_token": self._tokenizer.eos_token}, **map_kwargs)
+
+ # Tokenize the dataset
+ if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc`
+ map_kwargs["desc"] = f"Tokenizing {dataset_name} dataset"
+
+ def tokenize_fn(example, processing_class):
+ tools = example.get("tools")
+ tools = json.loads(tools) if isinstance(tools, str) else tools
+ output = {}
+ if is_conversational(example):
+ prompt_ids = self._tokenize(
+ processing_class,
+ example["prompt"],
+ tools=tools,
+ add_generation_prompt=True,
+ **example.get("chat_template_kwargs", {}),
+ )["input_ids"]
+ prompt_chosen_ids = self._tokenize(
+ processing_class,
+ example["prompt"] + example["chosen"],
+ tools=tools,
+ **example.get("chat_template_kwargs", {}),
+ )["input_ids"]
+ prompt_rejected_ids = self._tokenize(
+ processing_class,
+ example["prompt"] + example["rejected"],
+ tools=tools,
+ **example.get("chat_template_kwargs", {}),
+ )["input_ids"]
+ else:
+ prompt_ids = self._tokenize(processing_class, example["prompt"])["input_ids"]
+ prompt_chosen_ids = self._tokenize(processing_class, example["prompt"] + example["chosen"])[
+ "input_ids"
+ ]
+ prompt_rejected_ids = self._tokenize(processing_class, example["prompt"] + example["rejected"])[
+ "input_ids"
+ ]
+
+ # Check if the tokenized prompt starts with the tokenized prompt+completion
+ if not prompt_chosen_ids[: len(prompt_ids)] == prompt_ids:
+ logger.warning(
+ "Mismatch between tokenized prompt and the start of tokenized prompt+chosen. "
+ "This may be due to unexpected tokenizer behavior, whitespace issues, or special "
+ "token handling. Verify that the tokenizer is processing text consistently."
+ )
+ if not prompt_rejected_ids[: len(prompt_ids)] == prompt_ids:
+ logger.warning(
+ "Mismatch between tokenized prompt and the start of tokenized prompt+rejected. "
+ "This may be due to unexpected tokenizer behavior, whitespace issues, or special "
+ "token handling. Verify that the tokenizer is processing text consistently."
+ )
+
+ output["prompt_ids"] = prompt_ids
+ output["chosen_ids"] = prompt_chosen_ids[len(prompt_ids) :]
+ output["rejected_ids"] = prompt_rejected_ids[len(prompt_ids) :]
+ return output
+
+ dataset = dataset.map(tokenize_fn, fn_kwargs={"processing_class": processing_class}, **map_kwargs)
+
+ return dataset
+
+ def _set_signature_columns_if_needed(self):
+ # If `self.args.remove_unused_columns` is True, non-signature columns are removed.
+ # By default, this method sets `self._signature_columns` to the model's expected inputs (usually, "input_ids"
+ # and "attention_mask").
+ if self._signature_columns is None:
+ if self._is_vision_dataset:
+ self._signature_columns = [
+ "prompt",
+ "chosen",
+ "rejected",
+ "image",
+ "images",
+ "tools",
+ "chat_template_kwargs",
+ ]
+ else:
+ self._signature_columns = [
+ "prompt_ids",
+ "chosen_ids",
+ "rejected_ids",
+ "ref_chosen_logps",
+ "ref_rejected_logps",
+ ]
+
+ def _precompute_ref_logps(self, dataset: Dataset, name: str, batch_size: int) -> Dataset:
+ model_hash = hash_module(self.ref_model or self.model)
+ fingerprint = Hasher.hash((dataset._fingerprint, model_hash))
+ cache_file = dataset._get_cache_file_path(fingerprint)
+
+ if os.path.exists(cache_file):
+ return concatenate_datasets([dataset, Dataset.from_file(cache_file)], axis=1)
+
+ dataloader = DataLoader(
+ dataset,
+ batch_size=batch_size,
+ collate_fn=self.data_collator,
+ num_workers=self.args.dataloader_num_workers,
+ pin_memory=self.args.dataloader_pin_memory,
+ shuffle=False,
+ )
+ data_loader = self.accelerator.prepare(dataloader)
+ ref_chosen_logps = []
+ ref_rejected_logps = []
+ for padded_batch in tqdm(iterable=data_loader, desc=f"Computing reference log probs for {name} dataset"):
+ ref_chosen_logp, ref_rejected_logp = self.compute_ref_log_probs(padded_batch)
+ ref_chosen_logp, ref_rejected_logp = self.accelerator.gather_for_metrics(
+ (ref_chosen_logp, ref_rejected_logp)
+ )
+ ref_chosen_logps.append(ref_chosen_logp.cpu())
+ ref_rejected_logps.append(ref_rejected_logp.cpu())
+
+ ref_chosen_logps = torch.cat(ref_chosen_logps)
+ ref_rejected_logps = torch.cat(ref_rejected_logps)
+
+ if self.accelerator.is_main_process:
+
+ def add_ref_logps(batch, indices):
+ return {
+ "ref_chosen_logps": ref_chosen_logps[indices],
+ "ref_rejected_logps": ref_rejected_logps[indices],
+ }
+
+ dataset.map(
+ add_ref_logps,
+ with_indices=True,
+ batched=True,
+ remove_columns=dataset.column_names,
+ new_fingerprint=fingerprint,
+ desc=f"Caching reference log probs for {name} dataset",
+ )
+ self.accelerator.wait_for_everyone()
+
+ return concatenate_datasets([dataset, Dataset.from_file(cache_file)], axis=1)
+
+ def compute_ref_log_probs(self, inputs):
+ """Computes reference log probabilities for a single padded batch."""
+ device = self.accelerator.device
+
+ _non_model_keys = {"completion_mask", "ref_chosen_logps", "ref_rejected_logps"}
+ model_kwargs = {k: v for k, v in inputs.items() if k not in _non_model_keys}
+ model_kwargs["use_cache"] = False
+
+ with torch.no_grad(), disable_gradient_checkpointing(self.model, self.args.gradient_checkpointing_kwargs):
+ if self.ref_model is None:
+ if is_peft_model(self.model):
+ model = self.accelerator.unwrap_model(self.model)
+ with use_adapter(model, adapter_name="ref" if "ref" in model.peft_config else None):
+ ref_outputs = self.model(**model_kwargs)
+ else:
+ ref_outputs = self.model(**model_kwargs)
+ else:
+ ref_outputs = self.ref_model(**model_kwargs)
+
+ input_ids = inputs["input_ids"]
+ completion_mask = inputs["completion_mask"]
+ shift_labels = input_ids[..., 1:]
+ shift_completion_mask = completion_mask[..., 1:]
+ ref_shift_logits = ref_outputs.logits[..., :-1, :]
+ ref_per_token_logps = selective_log_softmax(ref_shift_logits, shift_labels)
+ ref_per_token_logps[shift_completion_mask == 0] = 0.0
+
+ if self.ld_alpha is None:
+ ref_logps = ref_per_token_logps.sum(dim=1)
+ else:
+ comp_pos = shift_completion_mask.cumsum(dim=1)
+ comp_lens = shift_completion_mask.sum(dim=1).long()
+ chosen_lens, rejected_lens = comp_lens.chunk(2, dim=0)
+ shared_lens = torch.minimum(chosen_lens, rejected_lens)
+ shared_lens = torch.cat([shared_lens, shared_lens], dim=0).to(device)
+ shared_mask = (comp_pos > 0) & (comp_pos <= shared_lens.unsqueeze(1))
+ tail_mask = comp_pos > shared_lens.unsqueeze(1)
+ shared_logps = (ref_per_token_logps * shared_mask).sum(dim=1)
+ tail_logps = (ref_per_token_logps * tail_mask).sum(dim=1)
+ ref_logps = shared_logps + self.ld_alpha * tail_logps
+
+ ref_chosen_logps, ref_rejected_logps = ref_logps.chunk(2, dim=0)
+ return ref_chosen_logps, ref_rejected_logps
+
+ def _compute_loss_liger(self, model, inputs, return_outputs):
+ if return_outputs:
+ raise RuntimeError(
+ "return_outputs=True is not supported with the Liger DPO loss. The Liger loss computes the loss "
+ "without materializing logits, so outputs cannot be returned."
+ )
+
+ mode = "train" if self.model.training else "eval"
+
+ _non_model_keys = {"completion_mask", "ref_chosen_logps", "ref_rejected_logps"}
+ model_kwargs = {k: v for k, v in inputs.items() if k not in _non_model_keys}
+ model_kwargs["use_cache"] = False
+
+ # `base_model` gives the backbone model (skipping `lm_head`) — text decoder for LMs, multimodal wrapper for
+ # VLMs (so vision-token injection runs before the text decoder). `get_decoder()` won't do: on VLMs it
+ # returns just the text stack and feeds image-placeholder IDs through it.
+ # Pre-5.0 transformers VLMs set `base_model_prefix = ""` so `base_model is self` (re-runs `lm_head`).
+ # Fall back to `.model` there.
+ if self._is_vlm and Version(transformers.__version__) < Version("5.0.0"):
+ backbone, ref_backbone = model.model, self.ref_model.model
+ else:
+ backbone, ref_backbone = model.base_model, self.ref_model.base_model
+
+ outputs = backbone(**model_kwargs)
+ hidden_states = outputs.last_hidden_state[:, :-1].contiguous()
+ lm_head = model.get_output_embeddings()
+ weight = lm_head.weight
+ bias = lm_head.bias
+
+ with torch.no_grad(), disable_gradient_checkpointing(self.model, self.args.gradient_checkpointing_kwargs):
+ ref_outputs = ref_backbone(**model_kwargs)
+ ref_lm_head = self.ref_model.get_output_embeddings()
+ ref_hidden_states = ref_outputs.last_hidden_state[:, :-1].contiguous()
+ ref_weight = ref_lm_head.weight
+ ref_bias = ref_lm_head.bias
+
+ input_ids = model_kwargs["input_ids"]
+ completion_mask = inputs["completion_mask"]
+ shift_completion_mask = completion_mask[:, 1:]
+ labels = input_ids[:, 1:].clone()
+ labels[shift_completion_mask == 0] = -100
+
+ loss, metrics = self.liger_loss_fn(
+ weight, hidden_states, labels, bias, ref_hidden_states, ref_weight, ref_bias
+ )
+
+ (
+ chosen_logps,
+ rejected_logps,
+ chosen_logits_mean,
+ rejected_logits_mean,
+ nll_loss,
+ chosen_rewards,
+ rejected_rewards,
+ ) = metrics
+
+ if mode == "train":
+ num_tokens_in_batch = self.accelerator.gather_for_metrics(inputs["attention_mask"].sum()).sum().item()
+ self._total_train_tokens += num_tokens_in_batch
+ self._metrics[mode]["num_tokens"] = [self._total_train_tokens]
+
+ avg_chosen_logits = self.accelerator.gather_for_metrics(chosen_logits_mean).mean().item()
+ avg_rejected_logits = self.accelerator.gather_for_metrics(rejected_logits_mean).mean().item()
+ self._metrics[mode]["logits/chosen"].append(avg_chosen_logits)
+ self._metrics[mode]["logits/rejected"].append(avg_rejected_logits)
+
+ agg_chosen_rewards = self.accelerator.gather(chosen_rewards)
+ agg_rejected_rewards = self.accelerator.gather(rejected_rewards)
+ self._metrics[mode]["rewards/chosen"].append(agg_chosen_rewards.mean().item())
+ self._metrics[mode]["rewards/rejected"].append(agg_rejected_rewards.mean().item())
+
+ reward_accuracies = (chosen_rewards > rejected_rewards).float()
+ agg_reward_accuracies = self.accelerator.gather(reward_accuracies)
+ self._metrics[mode]["rewards/accuracies"].append(agg_reward_accuracies.mean().item())
+
+ margins = chosen_rewards - rejected_rewards
+ agg_margins = self.accelerator.gather(margins)
+ self._metrics[mode]["rewards/margins"].append(agg_margins.mean().item())
+
+ self._metrics[mode]["logps/chosen"].append(self.accelerator.gather(chosen_logps).mean().item())
+ self._metrics[mode]["logps/rejected"].append(self.accelerator.gather(rejected_logps).mean().item())
+
+ return loss
+
+ def _compute_loss(self, model, inputs, return_outputs):
+ mode = "train" if self.model.training else "eval"
+ device = self.accelerator.device
+
+ _non_model_keys = {"completion_mask", "ref_chosen_logps", "ref_rejected_logps"}
+ model_kwargs = {k: v for k, v in inputs.items() if k not in _non_model_keys}
+ model_kwargs["use_cache"] = False
+ outputs = model(**model_kwargs)
+
+ input_ids = inputs["input_ids"]
+ completion_mask = inputs["completion_mask"]
+ shift_logits = outputs.logits[..., :-1, :]
+ shift_labels = input_ids[..., 1:]
+ shift_completion_mask = completion_mask[..., 1:]
+ per_token_logps = selective_log_softmax(shift_logits, shift_labels)
+ per_token_logps[shift_completion_mask == 0] = 0.0 # mask out non-completion tokens
+ if self.ld_alpha is None:
+ logps = per_token_logps.sum(dim=1) # sum over sequence length
+ else:
+ comp_pos = shift_completion_mask.cumsum(dim=1)
+ comp_lens = shift_completion_mask.sum(dim=1).long()
+ chosen_lens, rejected_lens = comp_lens.chunk(2, dim=0)
+ shared_lens = torch.minimum(chosen_lens, rejected_lens)
+ shared_lens = torch.cat([shared_lens, shared_lens], dim=0).to(device)
+ shared_mask = (comp_pos > 0) & (comp_pos <= shared_lens.unsqueeze(1)) # shared: 1 <= pos <= shared_len
+ tail_mask = comp_pos > shared_lens.unsqueeze(1) # tail: pos > shared_len
+ shared_logps = (per_token_logps * shared_mask).sum(dim=1)
+ tail_logps = (per_token_logps * tail_mask).sum(dim=1)
+ logps = shared_logps + self.ld_alpha * tail_logps
+ chosen_logps, rejected_logps = logps.chunk(2, dim=0) # batch is [chosen, rejected]
+
+ if self.precompute_ref_logps:
+ ref_chosen_logps, ref_rejected_logps = inputs["ref_chosen_logps"], inputs["ref_rejected_logps"]
+ else:
+ # When gradient checkpointing is enabled with use_reentrant=True (default), calling the model inside a
+ # torch.no_grad() block triggers a harmless PyTorch warning ("None of the inputs have requires_grad=True").
+ # Temporarily disable checkpointing to avoid this warning during inference.
+ with torch.no_grad(), disable_gradient_checkpointing(self.model, self.args.gradient_checkpointing_kwargs):
+ if is_peft_model(model) and self.ref_model is None:
+ # When training a PEFT adapter, how we obtain the reference depends on the setup:
+ # - New adapter: disabling adapters yields the base model.
+ # - Re-training an existing adapter: an initial copy is loaded under the name "ref".
+ model = self.accelerator.unwrap_model(model)
+ with use_adapter(model, adapter_name="ref" if "ref" in model.peft_config else None):
+ ref_outputs = self.model(**model_kwargs)
+ else:
+ ref_outputs = self.ref_model(**model_kwargs)
+
+ ref_shift_logits = ref_outputs.logits[..., :-1, :]
+ ref_per_token_logps = selective_log_softmax(ref_shift_logits, shift_labels)
+ ref_per_token_logps[shift_completion_mask == 0] = 0.0 # mask out non-completion tokens
+ if self.ld_alpha is None:
+ ref_logps = ref_per_token_logps.sum(dim=1) # sum over sequence length
+ else:
+ # reuse comp_pos/shared_mask/tail_mask computed above (they depend only on completion_mask)
+ ref_shared_logps = (ref_per_token_logps * shared_mask).sum(dim=1)
+ ref_tail_logps = (ref_per_token_logps * tail_mask).sum(dim=1)
+ ref_logps = ref_shared_logps + self.ld_alpha * ref_tail_logps
+ ref_chosen_logps, ref_rejected_logps = ref_logps.chunk(2, dim=0) # batch is [chosen, rejected]
+
+ # Get the log ratios for the chosen and rejected responses
+ chosen_logratios = chosen_logps - ref_chosen_logps
+ rejected_logratios = rejected_logps - ref_rejected_logps
+
+ if self.f_divergence_type == "reverse_kl": # standard DPO
+ chosen_scores = chosen_logratios
+ rejected_scores = rejected_logratios
+ elif self.f_divergence_type == "forward_kl":
+ # f'(t) = 1 - 1/t -> drop constant -> -exp(-logratio)
+ chosen_scores = -torch.exp(-chosen_logratios)
+ rejected_scores = -torch.exp(-rejected_logratios)
+ elif self.f_divergence_type == "js_divergence":
+ # f'(t) = log(2t/(t+1)) -> drop log 2
+ chosen_scores = F.logsigmoid(chosen_logratios)
+ rejected_scores = F.logsigmoid(rejected_logratios)
+ elif self.f_divergence_type == "alpha_divergence":
+ # alpha-divergence: f'(t) = (t^(α-1) - 1)/(α-1)
+ if abs(self.f_alpha_divergence_coef - 1.0) < 1e-6: # limit case f'(t) -> log(t), fall back to reverse_kl
+ chosen_scores = chosen_logratios
+ rejected_scores = rejected_logratios
+ else:
+ coef = 1.0 / (self.f_alpha_divergence_coef - 1.0)
+ t_chosen = (self.f_alpha_divergence_coef - 1.0) * chosen_logratios
+ t_rejected = (self.f_alpha_divergence_coef - 1.0) * rejected_logratios
+ dtype = t_chosen.dtype
+ # Clamp max so exp(.) stays representable after casting back
+ clamp_max = {torch.float16: 11.0, torch.bfloat16: 80.0, torch.float32: 80.0}[dtype]
+ t_chosen_float = torch.clamp(t_chosen.float(), max=clamp_max)
+ t_rejected_float = torch.clamp(t_rejected.float(), max=clamp_max)
+ chosen_scores = torch.exp(t_chosen_float).to(dtype) * coef
+ rejected_scores = torch.exp(t_rejected_float).to(dtype) * coef
+ else:
+ raise ValueError(f"Unknown f_divergence_type: {self.f_divergence_type}")
+
+ delta_score = chosen_scores - rejected_scores
+
+ loss = 0.0
+ for loss_type, loss_weight in zip(self.loss_types, self.loss_weights, strict=True):
+ if loss_type == "sigmoid":
+ per_sequence_loss = -F.logsigmoid(self.beta * delta_score)
+
+ elif loss_type == "hinge":
+ per_sequence_loss = torch.relu(1 - self.beta * delta_score)
+
+ elif loss_type == "ipo":
+ # IPO uses sequence-level log-prob differences; in code these are token-summed over the completion,
+ # which makes the squared loss scale with completion length. We therefore normalize by the number of
+ # completion tokens (average per token) to make β/loss comparable across variable lengths. This length
+ # normalization is not explicitly discussed in the IPO paper; we confirmed this choice with the IPO
+ # authors, and the results reported in the paper correspond to this normalized form.
+ chosen_mask, rejected_mask = completion_mask.chunk(2, dim=0)
+ chosen_avg_score = chosen_scores / chosen_mask.sum(dim=1).clamp(min=1.0)
+ rejected_avg_score = rejected_scores / rejected_mask.sum(dim=1).clamp(min=1.0)
+ ipo_delta = chosen_avg_score - rejected_avg_score
+ # (Eq. 17) of the paper where beta is the regularization parameter for the IPO loss, denoted by τ.
+ per_sequence_loss = (ipo_delta - 1 / (2 * self.beta)) ** 2
+
+ elif loss_type == "exo_pair":
+ # Implements EXO-pref from the paper https://huggingface.co/papers/2402.00856, (Eq. 16)
+ # Minimize KL(p_fθ || p_rh) for K=2; p_fθ = softmax(βπ * (log πθ − log π_ref)) over {chosen, rejected}
+ # p_rh = [(1−ε), ε]; expanded KL gives the weighted logsigmoid form below
+ epsilon = torch.tensor(self.label_smoothing, device=device)
+ qw = torch.sigmoid(self.beta * delta_score)
+ log_qw = F.logsigmoid(self.beta * delta_score)
+ log_pw = torch.log1p(-epsilon)
+ ql = torch.sigmoid(-self.beta * delta_score)
+ log_ql = F.logsigmoid(-self.beta * delta_score)
+ log_pl = torch.log(epsilon)
+ per_sequence_loss = qw * (log_qw - log_pw) + ql * (log_ql - log_pl)
+
+ elif loss_type == "nca_pair":
+ chosen_rewards = self.beta * chosen_scores
+ rejected_rewards = self.beta * rejected_scores
+ per_sequence_loss = (
+ -F.logsigmoid(chosen_rewards)
+ - 0.5 * F.logsigmoid(-chosen_rewards)
+ - 0.5 * F.logsigmoid(-rejected_rewards)
+ )
+
+ elif loss_type == "robust":
+ clean_loss_term = -(1 - self.label_smoothing) * F.logsigmoid(self.beta * delta_score)
+ flipped_loss_term = -self.label_smoothing * F.logsigmoid(-self.beta * delta_score)
+ per_sequence_loss = (clean_loss_term - flipped_loss_term) / (1 - 2 * self.label_smoothing)
+
+ elif loss_type == "bco_pair":
+ chosen_rewards = self.beta * chosen_scores
+ rejected_rewards = self.beta * rejected_scores
+ per_sequence_loss = -F.logsigmoid(chosen_rewards) - F.logsigmoid(-rejected_rewards)
+
+ elif loss_type == "sppo_hard":
+ # In the paper (https://huggingface.co/papers/2405.00675), SPPO employs a soft probability approach,
+ # estimated using the PairRM score. The probability calculation is conducted outside of the trainer
+ # class. The version described here is the hard probability version, where P in Equation (4.7) of
+ # Algorithm 1 is set to 1 for the winner and 0 for the loser.
+ winner_margin_error = (chosen_scores - 0.5 / self.beta) ** 2
+ loser_margin_error = (rejected_scores + 0.5 / self.beta) ** 2
+ per_sequence_loss = winner_margin_error + loser_margin_error
+
+ elif loss_type == "aot":
+ logratios = chosen_logps - rejected_logps
+ ref_logratios = ref_chosen_logps - ref_rejected_logps
+ logratios_sorted, _ = torch.sort(logratios, dim=0)
+ ref_logratios_sorted, _ = torch.sort(ref_logratios, dim=0)
+ delta = logratios_sorted - ref_logratios_sorted
+ per_sequence_loss = (
+ -F.logsigmoid(self.beta * delta) * (1 - self.label_smoothing)
+ - F.logsigmoid(-self.beta * delta) * self.label_smoothing
+ )
+
+ elif loss_type == "aot_unpaired":
+ chosen_logratios_sorted, _ = torch.sort(chosen_logratios, dim=0)
+ rejected_logratios_sorted, _ = torch.sort(rejected_logratios, dim=0)
+ delta = chosen_logratios_sorted - rejected_logratios_sorted
+ per_sequence_loss = (
+ -F.logsigmoid(self.beta * delta) * (1 - self.label_smoothing)
+ - F.logsigmoid(-self.beta * delta) * self.label_smoothing
+ )
+
+ elif loss_type == "apo_zero":
+ # Eqn (7) of the APO paper (https://huggingface.co/papers/2408.06266)
+ # Use this loss when you believe the chosen outputs are better than your model's default output
+ # Increase chosen likelihood and decrease rejected likelihood
+ losses_chosen = 1 - torch.sigmoid(self.beta * chosen_logratios)
+ losses_rejected = torch.sigmoid(self.beta * rejected_logratios)
+ per_sequence_loss = losses_chosen + losses_rejected
+
+ elif loss_type == "apo_down":
+ # Eqn (8) of the APO paper (https://huggingface.co/papers/2408.06266)
+ # Use this loss when you believe the chosen outputs are worse than your model's default output.
+ # Decrease chosen likelihood and decrease rejected likelihood more
+ losses_chosen = torch.sigmoid(self.beta * chosen_logratios)
+ losses_rejected = 1 - torch.sigmoid(self.beta * delta_score)
+ per_sequence_loss = losses_chosen + losses_rejected
+
+ elif loss_type == "discopop":
+ # Eqn (5) of the DiscoPOP paper (https://huggingface.co/papers/2406.08414)
+ logits = delta_score * self.beta
+ # Modulate the mixing coefficient based on the log ratio magnitudes
+ log_ratio_modulation = torch.sigmoid(logits / self.args.discopop_tau)
+ logistic_component = -F.logsigmoid(logits)
+ exp_component = torch.exp(-logits)
+ # Blend between logistic and exponential component based on log ratio modulation
+ per_sequence_loss = (
+ logistic_component * (1 - log_ratio_modulation) + exp_component * log_ratio_modulation
+ )
+
+ elif loss_type == "sft":
+ chosen_logits, _ = shift_logits.chunk(2, dim=0)
+ chosen_labels, _ = shift_labels.chunk(2, dim=0)
+ chosen_mask, _ = shift_completion_mask.chunk(2, dim=0)
+ batch_loss = F.cross_entropy(chosen_logits[chosen_mask.bool()], chosen_labels[chosen_mask.bool()])
+ # Implementation convenience: expand the scalar SFT loss to a per-sequence tensor so it matches the
+ # shape of other losses; only the mean is used, so this is a no-op numerically.
+ per_sequence_loss = batch_loss.expand(chosen_logits.size(0))
+
+ elif loss_type == "sigmoid_norm":
+ chosen_mask, rejected_mask = completion_mask.chunk(2, dim=0)
+ chosen_avg_score = chosen_scores / chosen_mask.sum(dim=1).clamp(min=1.0)
+ rejected_avg_score = rejected_scores / rejected_mask.sum(dim=1).clamp(min=1.0)
+ delta = chosen_avg_score - rejected_avg_score
+ per_sequence_loss = -F.logsigmoid(self.beta * delta)
+
+ else:
+ raise ValueError(
+ f"Unknown loss type: {loss_type}. Should be one of ['sigmoid', 'hinge', 'ipo', 'exo_pair', "
+ "'nca_pair', 'robust', 'bco_pair', 'sppo_hard', 'aot', 'aot_unpaired', 'apo_zero', 'apo_down', "
+ "'discopop', 'sft', 'sigmoid_norm']"
+ )
+
+ if self.use_weighting:
+ # Eq (2) of the WPO paper: https://huggingface.co/papers/2406.11827
+ completion_lengths = shift_completion_mask.sum(dim=1).clamp_min(1)
+ with torch.no_grad():
+ lse1 = torch.logsumexp(shift_logits, dim=-1)
+ lse2 = torch.logsumexp(2.0 * shift_logits, dim=-1)
+ log_denom = lse2 - 2.0 * lse1
+ aligned_logps = (per_token_logps - log_denom) * shift_completion_mask
+ mean_logps = aligned_logps.sum(dim=1) / completion_lengths
+ weights = torch.exp(mean_logps)
+ chosen_weights, rejected_weights = weights.chunk(2, dim=0)
+ per_sequence_loss *= chosen_weights * rejected_weights
+
+ loss += per_sequence_loss.mean() * loss_weight
+
+ # Log the metrics
+ # Entropy
+ per_token_entropy = entropy_from_logits(shift_logits.detach())
+ mask = shift_completion_mask
+ entropy_sum = (per_token_entropy * mask).sum()
+ total_tokens = mask.sum()
+
+ # Gather counts across ranks and weight-average
+ entropy_sum = self.accelerator.gather_for_metrics(entropy_sum).sum()
+ total_tokens = self.accelerator.gather_for_metrics(total_tokens).sum()
+ entropy = (entropy_sum / total_tokens).item() if total_tokens > 0 else 0.0
+ self._metrics[mode]["entropy"].append(entropy)
+
+ # Number of tokens
+ if mode == "train":
+ num_tokens_in_batch = self.accelerator.gather_for_metrics(inputs["attention_mask"].sum()).sum().item()
+ self._total_train_tokens += num_tokens_in_batch
+ self._metrics[mode]["num_tokens"] = [self._total_train_tokens]
+
+ # Average logits for chosen and rejected completions
+ chosen_logits, rejected_logits = shift_logits.detach().chunk(2, dim=0)
+ chosen_mask, rejected_mask = shift_completion_mask.chunk(2, dim=0)
+ total_chosen_logits = chosen_logits[chosen_mask.bool()].mean(-1).sum()
+ total_chosen_tokens = chosen_mask.sum()
+ total_rejected_logits = rejected_logits[rejected_mask.bool()].mean(-1).sum()
+ total_rejected_tokens = rejected_mask.sum()
+ total_chosen_logits = self.accelerator.gather_for_metrics(total_chosen_logits).sum().item()
+ total_chosen_tokens = self.accelerator.gather_for_metrics(total_chosen_tokens).sum().item()
+ total_rejected_logits = self.accelerator.gather_for_metrics(total_rejected_logits).sum().item()
+ total_rejected_tokens = self.accelerator.gather_for_metrics(total_rejected_tokens).sum().item()
+ avg_chosen_logits = total_chosen_logits / total_chosen_tokens if total_chosen_tokens > 0 else 0.0
+ avg_rejected_logits = total_rejected_logits / total_rejected_tokens if total_rejected_tokens > 0 else 0.0
+ self._metrics[mode]["logits/chosen"].append(avg_chosen_logits)
+ self._metrics[mode]["logits/rejected"].append(avg_rejected_logits)
+
+ # Token accuracy for the chosen completions
+ predictions = chosen_logits.argmax(dim=-1)
+ chosen_mask = shift_completion_mask[: len(shift_completion_mask) // 2].bool()
+ chosen_labels = shift_labels[: len(shift_labels) // 2]
+ correct_predictions = (predictions == chosen_labels) & chosen_mask
+ total_tokens = chosen_mask.sum()
+ correct_tokens = correct_predictions.sum()
+ correct_tokens = self.accelerator.gather_for_metrics(correct_tokens)
+ total_tokens = self.accelerator.gather_for_metrics(total_tokens)
+ total_sum = total_tokens.sum()
+ accuracy = (correct_tokens.sum() / total_sum).item() if total_sum > 0 else 0.0
+ self._metrics[mode]["mean_token_accuracy"].append(accuracy)
+
+ # Rewards for chosen and rejected completions
+ chosen_rewards = self.beta * chosen_logratios.detach()
+ rejected_rewards = self.beta * rejected_logratios.detach()
+ agg_chosen_rewards = self.accelerator.gather(chosen_rewards)
+ agg_rejected_rewards = self.accelerator.gather(rejected_rewards)
+ self._metrics[mode]["rewards/chosen"].append(agg_chosen_rewards.mean().item())
+ self._metrics[mode]["rewards/rejected"].append(agg_rejected_rewards.mean().item())
+
+ # Reward accuracy
+ reward_accuracies = (chosen_rewards > rejected_rewards).float()
+ agg_reward_accuracies = self.accelerator.gather(reward_accuracies)
+ self._metrics[mode]["rewards/accuracies"].append(agg_reward_accuracies.mean().item())
+
+ # Reward margins
+ margins = chosen_rewards - rejected_rewards
+ agg_margins = self.accelerator.gather(margins)
+ self._metrics[mode]["rewards/margins"].append(agg_margins.mean().item())
+
+ # Average log probabilities for chosen and rejected completions
+ self._metrics[mode]["logps/chosen"].append(self.accelerator.gather(chosen_logps).mean().item())
+ self._metrics[mode]["logps/rejected"].append(self.accelerator.gather(rejected_logps).mean().item())
+
+ return (loss, outputs) if return_outputs else loss
+
+ def evaluate(
+ self,
+ eval_dataset: Dataset | dict[str, Dataset] | None = None,
+ ignore_keys: list[str] | None = None,
+ metric_key_prefix: str = "eval",
+ ) -> dict[str, float]:
+ # When a dataset is passed directly to `evaluate` (e.g. a held-out test set), preprocess it the same way
+ # `__init__` does, so that `evaluate` accepts the same dataset types as the trainer. `_prepare_dataset` is
+ # idempotent: it skips datasets that are already tokenized. A `str` selects a dataset that was already prepared
+ # at init time, so it's left untouched.
+ if not self._is_vision_dataset and eval_dataset is not None and not isinstance(eval_dataset, str):
+ if isinstance(eval_dataset, dict):
+ eval_dataset = {
+ key: self._prepare_dataset(dataset, self.processing_class, self.args, key)
+ for key, dataset in eval_dataset.items()
+ }
+ else:
+ eval_dataset = self._prepare_dataset(eval_dataset, self.processing_class, self.args, "eval")
+ # With `precompute_ref_log_probs`, `_compute_loss` reads the reference log-probs from the batch, so they
+ # must be precomputed here as well, mirroring `__init__`.
+ if self.precompute_ref_logps:
+ batch_size = self.args.precompute_ref_batch_size or self.args.per_device_eval_batch_size
+ if isinstance(eval_dataset, dict):
+ eval_dataset = {
+ name: self._precompute_ref_logps(dataset, name, batch_size)
+ for name, dataset in eval_dataset.items()
+ }
+ else:
+ eval_dataset = self._precompute_ref_logps(eval_dataset, "eval", batch_size)
+ return super().evaluate(
+ eval_dataset=eval_dataset, ignore_keys=ignore_keys, metric_key_prefix=metric_key_prefix
+ )
+
+ def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
+ try:
+ if self.use_liger_kernel:
+ return self._compute_loss_liger(model, inputs, return_outputs)
+ return self._compute_loss(model, inputs, return_outputs)
+ except ValueError as e:
+ if "Image features and image tokens do not match" in str(e) and self.args.max_length is not None:
+ raise ValueError(
+ f"The current `max_length` ({self.args.max_length}) is too short and causes image placeholder "
+ f"tokens in `input_ids` to be truncated, while the corresponding image features remain intact. "
+ f"Please increase `max_length` or set it to `None` to disable truncation."
+ ) from e
+ raise
+
+ # Override training step to add activation offloading context.
+ def training_step(self, *args, **kwargs):
+ with self.maybe_activation_offload_context:
+ return super().training_step(*args, **kwargs)
+
+ def log(self, logs: dict[str, float], start_time: float | None = None) -> None:
+ mode = "train" if self.model.training else "eval"
+ metrics = {key: sum(val) / len(val) for key, val in self._metrics[mode].items()} # average the metrics
+ # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs`
+ # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format.
+ if mode == "eval":
+ metrics = {f"eval_{key}": val for key, val in metrics.items()}
+ logs.update(metrics)
+ super().log(logs, start_time)
+ self._metrics[mode].clear()
+
+ # During eval, Trainer calls prediction_step. If no labels are present in the inputs, it only runs forward and
+ # returns logits. We override prediction_step to force compute_loss, because this trainer doesn't involve labels.
+ def prediction_step(self, model, inputs, prediction_loss_only, ignore_keys: list[str] | None = None):
+ inputs = self._prepare_inputs(inputs)
+ with torch.no_grad(), self.compute_loss_context_manager():
+ if prediction_loss_only:
+ loss = self.compute_loss(model, inputs, return_outputs=False) # logits aren't materialized with liger
+ logits, labels = None, None
+ else:
+ loss, outputs = self.compute_loss(model, inputs, return_outputs=True)
+ logits, labels = outputs.logits, inputs["input_ids"]
+ return loss, logits, labels
+
+ # Ensure the model card is saved along with the checkpoint
+ def _save_checkpoint(self, model, trial):
+ if self.args.hub_model_id is None:
+ model_name = Path(self.args.output_dir).name
+ else:
+ model_name = self.args.hub_model_id.split("/")[-1]
+ self.create_model_card(model_name=model_name)
+ super()._save_checkpoint(model, trial)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/grpo_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/grpo_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..5736b6c0ddcd1816a26de16f09dd91f70cb57c00
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/grpo_config.py
@@ -0,0 +1,1061 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import warnings
+from dataclasses import dataclass, field
+from typing import Any
+
+from .base_config import _BaseConfig
+
+
+@dataclass
+class GRPOConfig(_BaseConfig):
+ # docstyle-ignore
+ r"""
+ Configuration class for the [`GRPOTrainer`].
+
+ This class includes only the parameters that are specific to GRPO training. For a full list of training arguments,
+ please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may
+ differ from those in [`~transformers.TrainingArguments`].
+
+ Using [`~transformers.HfArgumentParser`] we can turn this class into
+ [argparse](https://docs.python.org/3/library/argparse#module-argparse) arguments that can be specified on the
+ command line.
+
+ Parameters:
+ > Parameters that control the model and reference model
+
+ model_init_kwargs (`str`, `dict[str, Any]`, *optional*):
+ Keyword arguments for [`~transformers.AutoModelForCausalLM.from_pretrained`], used when the `model`
+ argument of the [`GRPOTrainer`] is provided as a string.
+ trust_remote_code (`bool`, *optional*, defaults to `False`):
+ Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to
+ [`~transformers.AutoModelForCausalLM.from_pretrained`] and
+ [`~transformers.AutoProcessor.from_pretrained`]. Also applied to reward-model and reward-tokenizer loads.
+ router_aux_loss_coef (`float`, *optional*, defaults to `0.001`):
+ Coefficient of the load-balancing auxiliary loss. Only has an effect when training a Mixture-of-Experts
+ (MoE) model; for other models it does nothing. The auxiliary loss is added to the training loss with this
+ weight. Set to `0.0` to disable it.
+ disable_dropout (`bool`, *optional*, defaults to `False`):
+ Whether to disable dropout in the model. This is useful for training with a reference model, as it prevents
+ the model from generating different logprobs for the same input.
+ cast_lm_head_to_fp32 (`bool`, *optional*, defaults to `False`):
+ Whether to cast the language modeling head of the policy and reference models to float32. As recommended by
+ the [ScaleRL](https://huggingface.co/papers/2510.13786) recipe. This flag is only supported when the model
+ has untied word embedding and language modeling head layers i.e. `tie_word_embeddings` in the model config
+ is False.
+
+ > Parameters that control the data preprocessing
+
+ remove_unused_columns (`bool`, *optional*, defaults to `False`):
+ Whether to only keep the column `"prompt"` in the dataset. If you use a custom reward function that
+ requires any column other than `"prompts"` and `"completions"`, you should keep this to `False`.
+ num_generations (`int`, *optional*, defaults to `8`):
+ Number of generations per prompt to sample. The effective batch size (num_processes * per_device_batch_size
+ * gradient_accumulation_steps) must be evenly divisible by this value.
+ num_generations_eval (`int` or `None`, *optional*):
+ Number of generations to sample during evaluation. This allows using fewer generations during evaluation to
+ save computation. If `None`, uses the value of `num_generations`.
+ max_completion_length (`int` or `None`, *optional*, defaults to `256`):
+ Maximum length of the generated completion.
+ ds3_gather_for_generation (`bool`, *optional*, defaults to `True`):
+ This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for generation,
+ improving generation speed. However, disabling this option allows training models that exceed the VRAM
+ capacity of a single GPU, albeit at the cost of slower generation. Disabling this option is not compatible
+ with vLLM generation.
+ shuffle_dataset (`bool`, *optional*, defaults to `True`):
+ Whether to shuffle the training dataset.
+ pad_to_multiple_of (`int`, *optional*):
+ If set, the prompts ids and completions ids will be padded to a multiple of this value.
+
+ > Parameters that control generation
+
+ generation_batch_size (`int`, *optional*):
+ Batch size to use for generation. If `None`, it defaults to the effective training batch size:
+ `per_device_train_batch_size * num_processes * steps_per_generation`. In other words, there is one
+ generation batch processed per optimization step. Mutually exclusive with `steps_per_generation`.
+ steps_per_generation (`int`, *optional*):
+ Number of steps per generation. If `None`, it defaults to `gradient_accumulation_steps`. Mutually exclusive
+ with `generation_batch_size`.
+ temperature (`float`, defaults to `1.0`):
+ Temperature for sampling. The higher the temperature, the more random the completions.
+ top_p (`float`, *optional*, defaults to `1.0`):
+ Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. Set to
+ `1.0` to consider all tokens.
+ top_k (`int`, *optional*, defaults to `0`):
+ Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, top-k-filtering is
+ disabled and all tokens are considered.
+ min_p (`float`, *optional*):
+ Minimum token probability, which will be scaled by the probability of the most likely token. It must be a
+ value between `0.0` and `1.0`. Typical values are in the `0.01-0.2` range.
+ generation_kwargs (`dict[str, Any]`, *optional*):
+ Additional keyword arguments to pass to [`~transformers.GenerationConfig`] (if using transformers) or
+ `SamplingParams` (if using vLLM) when sampling completions. This can be used to further customize the
+ generation behavior, such as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that conflict
+ with the other generation parameters (like `min_p`, `top_p`, etc.), they will override them.
+ chat_template_kwargs (`dict[str, Any]`, *optional*):
+ Additional keyword arguments to pass to the `apply_chat_template` function when generating completions.
+ repetition_penalty (`float`, *optional*, defaults to `1.0`):
+ Float that penalizes new tokens based on whether they appear in the prompt and the generated text so far.
+ Values > `1.0` encourage the model to use new tokens, while values < `1.0` encourage the model to repeat
+ tokens.
+ cache_implementation (`str`, *optional*):
+ Implementation of the cache method for faster generation when `use_vllm` is set to `False`.
+
+ > Parameters that control generation acceleration powered by vLLM
+
+ use_vllm (`bool`, *optional*, defaults to `False`):
+ Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for generation
+ instead of the default model.generate(). Requires `vllm` to be installed.
+ vllm_mode (`str`, *optional*, defaults to `"colocate"`):
+ Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `"server"` or
+ `"colocate"`.
+
+ - `"server"`: The trainer will send generation requests to a separate vLLM server. Make sure a TRL vLLM
+ server is running (start with `trl vllm-serve`).
+ - `"colocate"`: vLLM will run in the same process and share the training GPUs. This avoids the need for a
+ separate server but may cause resource contention with training.
+ vllm_model_impl (`str`, *optional*, defaults to `"vllm"`):
+ Model implementation to use for vLLM. Must be one of `"transformers"` or `"vllm"`. `"transformers"`: Use
+ the `transformers` backend for model implementation. `"vllm"`: Use the `vllm` library for model
+ implementation.
+ vllm_structured_outputs_regex (`str`, *optional*):
+ Regex for vLLM structured outputs. If `None` (default), structured outputs is disabled.
+
+ > Parameters that control the vLLM server (only used when `vllm_mode` is `"server"`)
+
+ vllm_server_base_url (`str`, *optional*):
+ Base URL for the vLLM server (e.g., `"http://localhost:8000"`). If provided, `vllm_server_host` and
+ `vllm_server_port` are ignored.
+ vllm_server_host (`str`, *optional*, defaults to `"0.0.0.0"`):
+ Host of the vLLM server to connect to. Ignored if `vllm_server_base_url` is provided.
+ vllm_server_port (`int`, *optional*, defaults to `8000`):
+ Port of the vLLM server to connect to. Ignored if `vllm_server_base_url` is provided.
+ vllm_server_timeout (`float`, *optional*, defaults to `240.0`):
+ Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up after the
+ timeout, a `ConnectionError` is raised.
+ vllm_group_port (`int`, *optional*, defaults to `51216`):
+ Port number for the weight update group. This is used to communicate with the vLLM server. Unless the port
+ is occupied, there is no need to change it.
+
+ > Parameters that control colocated vLLM execution (only used when `vllm_mode` is `"colocate"`)
+
+ vllm_gpu_memory_utilization (`float`, *optional*, defaults to `0.3`):
+ Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set to
+ `"colocate"`. If you are using `vllm_mode="server"`, this parameter must be passed separately when
+ launching the vLLM server via the `--vllm_gpu_memory_utilization` flag.
+ vllm_max_model_length (`int`, *optional*):
+ Context window for vLLM. Set it to at least the maximum prompt length in the dataset plus
+ `max_completion_length`; if omitted, it is inferred from the model config.
+ vllm_tensor_parallel_size (`int`, *optional*, defaults to `1`):
+ Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set to
+ `"colocate"`. If you are using `vllm_mode="server"`, this parameter must be passed separately when
+ launching the vLLM server via the `--vllm_tensor_parallel_size` flag.
+ vllm_enable_sleep_mode (`bool`, *optional*, defaults to `False`):
+ Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory usage low, but
+ waking the engine adds host–device transfer latency.
+
+ > Parameters that control generation acceleration powered by transformers continuous batching
+
+ use_transformers_continuous_batching (`bool`, *optional*, defaults to `False`):
+ Whether to use transformers' continuous batching engine for generating completions. Requires
+ `transformers>=5.8.0`.
+ transformers_continuous_batching_config (`dict`, *optional*):
+ Keyword arguments for [`~transformers.generation.ContinuousBatchingConfig`].
+
+ > Parameters that control the training
+
+ beta (`float`, *optional*, defaults to `0.0`):
+ KL coefficient. If `0.0` (default), the reference model is not loaded, reducing memory usage and improving
+ training speed. [DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement
+ learning](https://huggingface.co/papers/2501.12948) use a value of `0.001`.
+ num_iterations (`int`, *optional*, defaults to `1`):
+ Number of iterations per batch (denoted as μ in the algorithm).
+ epsilon (`float`, *optional*, defaults to `0.2`):
+ Epsilon value for clipping.
+ delta (`float`, *optional*):
+ Enables the upper clipping bound in two-sided GRPO loss when set to a float. If `None` (default), standard
+ GRPO clipping is used. Recommended to be greater than `1 + ε` when enabled. This method is introduced in
+ the [INTELLECT-2 tech report](https://huggingface.co/papers/2505.07291).
+ epsilon_high (`float`, *optional*):
+ Upper-bound epsilon value for clipping. If not specified, it defaults to the same value as the lower-bound
+ specified in argument `epsilon`. Paper [DAPO](https://huggingface.co/papers/2503.14476) recommends `0.28`.
+ When used with `loss_type='cispo'`, this corresponds to the ε_max param specified in the [ScaleRL
+ paper](https://huggingface.co/papers/2510.13786) and the recommended value is `5.0`.
+ sapo_temperature_neg (`float`, *optional*, defaults to `1.05`):
+ Temperature for tokens with non-positive advantage scores used in the `sapo` loss function. This parameter
+ is introduced in the [Soft Adaptive Policy Optimization paper](https://huggingface.co/papers/2511.20347).
+ sapo_temperature_pos (`float`, *optional*, defaults to `1.0`):
+ Temperature for tokens with positive advantage scores used in the `sapo` loss function. This parameter is
+ introduced in the [Soft Adaptive Policy Optimization paper](https://huggingface.co/papers/2511.20347).
+ vespo_k_pos (`float`, *optional*, defaults to `2.0`):
+ k parameter for positive advantages, it is the power exponent in the VESPO loss. Controls how aggressively
+ we down-weight samples with low importance weights (when the importance sampling ratio < 1).
+ vespo_lambda_pos (`float`, *optional*, defaults to `3.0`):
+ lambda parameter for positive advantages, it is the decay factor in the VESPO loss. Controls how
+ aggressively we down-weight samples with high importance weights (when the importance sampling ratio > 1).
+ vespo_k_neg (`float`, *optional*, defaults to `3.0`):
+ k parameter for negative advantages, it is the power exponent in the VESPO loss. Controls how aggressively
+ we down-weight samples with low importance weights (when the importance sampling ratio < 1).
+ vespo_lambda_neg (`float`, *optional*, defaults to `2.0`):
+ lambda parameter for negative advantages, it is the exponential decay factor in the VESPO loss. Controls
+ how aggressively we down-weight samples with high importance weights (when the importance sampling ratio >
+ 1).
+ importance_sampling_level (`str`, *optional*, defaults to `"token"`):
+ Controls whether importance sampling ratios are computed at the `"token"` or `"sequence"` level. `"token"`
+ keeps the raw per-token log-probability ratios (one weight per token). `"sequence"` averages the
+ log-probability ratios across valid tokens to produce a single ratio per sequence. The [GSPO
+ paper](https://huggingface.co/papers/2507.18071) shows that sequence-level sampling often yields more
+ stable training and better alignment with sequence-level rewards.
+ reward_weights (`list[float]`, *optional*):
+ Weights for each reward function. Must match the number of reward functions. If `None`, all rewards are
+ weighted equally with weight `1.0`.
+ multi_objective_aggregation (`str`, *optional*, defaults to `"sum_then_normalize"`):
+ Method to aggregate multiple reward functions. Supported values are:
+
+ - `"sum_then_normalize"` (default): First sums the weighted rewards from each reward function, then applies
+ reward scaling/normalization as specified by `scale_rewards` (see `scale_rewards` for details).
+ - `"normalize_then_sum"`: First normalizes/scales each reward function across generations (within each
+ group), then sums the normalized rewards using the specified weights. The aggregated reward is then
+ normalized at the batch level when forming advantages. This is the suggested approach from the paper
+ [GDPO: Group reward-Decoupled Normalization Policy Optimization for Multi-reward RL
+ Optimization](https://huggingface.co/papers/2601.05242).
+ scale_rewards (`str` or `bool`, *optional*, defaults to `"group"`):
+ Specifies the scaling strategy for rewards. Supported values are:
+
+ - `True` or `"group"` (default): rewards are scaled by the standard deviation within each group, ensuring
+ unit variance within a group.
+ - `"batch"`: rewards are scaled by the standard deviation across the entire batch, as recommended in the
+ [PPO Lite paper](https://huggingface.co/papers/2508.08221).
+ - `False` or `"none"`: no scaling is applied. The [Dr. GRPO
+ paper](https://huggingface.co/papers/2503.20783) recommends not scaling rewards, as scaling by the
+ standard deviation introduces a question-level difficulty bias.
+ loss_type (`str`, *optional*, defaults to `"dapo"`):
+ Specifies the loss formulation to use. Supported values are:
+
+ - `"grpo"`: Aggregates token-level losses by normalizing over sequence length. Not recommended due to
+ length bias—this approach tends to prefer shorter completions with positive advantages and longer ones
+ with negative advantages.
+ - `"dr_grpo"`: Aggregates token-level losses by normalizing with a global constant. This method was
+ introduced in the [Dr. GRPO paper](https://huggingface.co/papers/2503.20783) to eliminate length bias.
+ The value of the constant corresponds to `max_completion_length`.
+ - `"dapo"` (default): Aggregates token-level losses by normalizing with the number of active token in the
+ global accumulated batch. This method was introduced in the [DAPO
+ paper](https://huggingface.co/papers/2503.14476) to eliminate length bias.
+ - `"bnpo"`: Aggregates token-level losses by normalizing with the number of active token in the local
+ batch. Note that normalization is performed over the local batch only, so results may slightly vary
+ depending on the local batch size, despite a constant effective batch size. When using
+ `per_device_train_batch_size==1`, the loss is equivalent to the GRPO loss.
+ - `"cispo"`: Clips the importance sampling weights instead of the advantage scaled importance weights. The
+ clipped weights are then multiplied with the advantages and policy model's log probs. Individual token
+ losses are aggregated by normalizing with the number of active tokens in the global accumulated batch.
+ This method was introduced in the [MiniMax-M1 paper](https://huggingface.co/papers/2506.13585).
+ - `"sapo"`: Soft Adaptive Policy Optimization loss, as introduced in the [Soft Adaptive Policy Optimization
+ paper](https://huggingface.co/papers/2511.20347). Replaces hard clipping with a smooth,
+ temperature-controlled gate that adaptively attenuates off-policy updates while preserving useful
+ learning signals.
+ - `"luspo"`: Length-Unbiased Sequence Policy Optimization loss. A sequence-level loss that scales each
+ sequence's loss by its length. This is a modification of GSPO and requires
+ `importance_sampling_level="sequence"`. Introduced in the [LUSPO
+ paper](https://huggingface.co/papers/2602.05261).
+ - `"vespo"`: Variational Sequence-Level Soft Policy Optimization. Replaces hard clipping with a smooth,
+ asymmetric Gamma weighting function applied directly to sequence-level importance weights. Introduced in
+ the [VESPO paper](https://huggingface.co/papers/2602.10693).
+ mask_truncated_completions (`bool`, *optional*, defaults to `False`):
+ When enabled, truncated completions are excluded from the loss calculation, preventing them from being
+ incorrectly penalized and introducing noise during training. According to the
+ [DAPO](https://huggingface.co/papers/2503.14476) paper, this is a good practice for training stability.
+ sync_ref_model (`bool`, *optional*, defaults to `False`):
+ Whether to synchronize the reference model with the active model every `ref_model_sync_steps` steps, using
+ the `ref_model_mixup_alpha` parameter. This synchronization originates from the
+ [TR-DPO](https://huggingface.co/papers/2404.09656) paper.
+ ref_model_mixup_alpha (`float`, *optional*, defaults to `0.6`):
+ α parameter from the [TR-DPO](https://huggingface.co/papers/2404.09656) paper, which controls the mix
+ between the current policy and the previous reference policy during updates. The reference policy is
+ updated according to the equation: `π_ref = α * π_θ + (1 - α) * π_ref_prev`. To use this parameter, you
+ must set `sync_ref_model=True`.
+ ref_model_sync_steps (`int`, *optional*, defaults to `512`):
+ τ parameter from the [TR-DPO](https://huggingface.co/papers/2404.09656) paper, which determines how
+ frequently the current policy is synchronized with the reference policy. To use this parameter, you must
+ set `sync_ref_model=True`.
+ top_entropy_quantile (`float`, *optional*, defaults to `1.0`):
+ ρ parameter from [Beyond the 80/20 Rule](https://huggingface.co/papers/2506.01939). Keeps in the policy
+ loss term only the top-ρ quantile of tokens by entropy of the probability distribution at each sequence
+ position, improving results. Range: `[0.0-1.0]`. A value of `0.0` masks all but the highest entropy token;
+ `1.0` keeps all tokens. The paper recommends a value of `0.2`. If used with
+ `mask_truncated_completions=True`, only tokens from non-truncated completions are considered.
+ max_tool_calling_iterations (`int`, *optional*):
+ Maximum number of tool-calling turns when training an agent. If `None`, there is no limit and generation
+ stops when the model generates a response turn with no tool calls or when the total response length reaches
+ `max_model_length`.
+ vllm_importance_sampling_correction (`bool`, *optional*, defaults to `True`):
+ Whether to apply Importance Sampling (IS) to correct for the mismatch between vLLM completion logprobs and
+ recomputed training logprobs. If set to `False`, no IS is applied regardless of
+ `vllm_importance_sampling_mode`. When `True`, the selected mode determines how the IS ratios are computed
+ and constrained.
+ vllm_importance_sampling_mode (`str`, *optional*, defaults to `"sequence_mask"`):
+ Specifies how Importance Sampling is performed when `vllm_importance_sampling_correction=True`. Possible
+ values are:
+
+ - `"token_truncate"`: Token-level truncated IS (default). Per-token ratios are clipped to
+ [C_min, C_max].
+ - `"token_mask"`: Token-level masked IS. Per-token ratios outside [C_min, C_max] are set to zero.
+ - `"sequence_truncate"`: Sequence-level truncated IS. A single sequence ratio is clipped to
+ [C_min, C_max] and applied to all tokens in the sequence.
+ - `"sequence_mask"`: Sequence-level masked IS. Sequences with ratios outside [C_min, C_max] are masked
+ out.
+ vllm_importance_sampling_clip_max (`float`, *optional*, defaults to `3.0`):
+ Importance sampling upper bound C_max used by `vllm_importance_sampling_mode`. For `*_truncate` modes,
+ importance ratios are clipped from above at C_max. For `*_mask` modes, ratios larger than C_max are set to
+ zero.
+ vllm_importance_sampling_clip_min (`float`, *optional*):
+ Importance sampling lower bound C_min used by `vllm_importance_sampling_mode`. For `*_truncate` modes,
+ ratios are clipped from below at C_min. For `*_mask` modes, ratios below C_min are set to zero. To strictly
+ mask ratios below C_min without upper bound, set `vllm_importance_sampling_clip_max=None`.
+ off_policy_mask_threshold (`float`, *optional*):
+ Threshold for off-policy sequence masking. If `None`, off-policy sequence masking is disabled. When set,
+ sequences with negative advantages and high KL divergence are masked out to stabilize training. This
+ parameter corresponds to the `delta` threshold in Equation 9 of the [DeepSeek-V3.2
+ paper](https://huggingface.co/papers/2512.02556). It expects a positive value (e.g., 0.5).
+ use_bias_correction_kl (`bool`, *optional*, defaults to `False`):
+ Whether to use the unbiased KL divergence estimator with importance sampling correction. This corrects the
+ KL divergence estimate by multiplying it with the importance sampling ratio. This is described in the
+ [DeepSeek-V3.2 paper](https://huggingface.co/papers/2512.02556).
+
+ > Parameters that control the logging
+
+ log_completions (`bool`, *optional*, defaults to `False`):
+ Whether to log a sample of (prompt, completion) pairs every `logging_steps` steps. If `rich` is installed,
+ it prints the sample. If `wandb` and/or `trackio` logging is enabled, it logs it to `wandb` and/or
+ `trackio`.
+ num_completions_to_print (`int`, *optional*):
+ Number of completions to print with `rich`. If `None`, all completions are logged.
+ log_unique_prompts (`bool`, *optional*, defaults to `False`):
+ Whether to log unique prompts. If `True`, only unique prompts are logged. If `False`, all prompts are
+ logged.
+ log_completions_hub_repo (`str`, *optional*):
+ Hugging Face Hub repository to save the completions. Should be a complete repository name like
+ `'username/reponame'` or `'orgname/reponame'`, or just `'reponame'` in which case the repository will be
+ created in the currently-logged-in Hugging Face user's namespace. Note that this repository will be public
+ unless you set `hub_private_repo=True` or your organization's default is to create private repositories."
+
+ > Deprecated parameters
+
+ use_transformers_paged:
+
+
+
+ Parameter `use_transformers_paged` is deprecated and will be removed in version v2.0.0. Use
+ `use_transformers_continuous_batching` instead.
+
+
+
+ vllm_importance_sampling_cap:
+
+
+
+ Parameter `vllm_importance_sampling_cap` is deprecated and will be removed in v2.0.0. Use
+ `vllm_importance_sampling_clip_max` instead.
+
+
+
+ > [!NOTE]
+ > These parameters have default values different from [`~transformers.TrainingArguments`]:
+ > - `logging_steps`: Defaults to `10` instead of `500`.
+ > - `gradient_checkpointing`: Defaults to `True` instead of `False`.
+ > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`.
+ > - `learning_rate`: Defaults to `1e-6` instead of `5e-5`.
+ """
+
+ _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + [
+ "model_init_kwargs",
+ "transformers_continuous_batching_config",
+ ]
+
+ # Parameters whose default values are overridden from TrainingArguments
+ learning_rate: float = field(
+ default=1e-6,
+ metadata={"help": "The initial learning rate for AdamW."},
+ )
+
+ # Parameters that control the model and reference model
+ model_init_kwargs: dict[str, Any] | str | None = field(
+ default=None,
+ metadata={
+ "help": "Keyword arguments for `transformers.AutoModelForCausalLM.from_pretrained`, used when the `model` "
+ "argument of the `GRPOTrainer` is provided as a string."
+ },
+ )
+ trust_remote_code: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. "
+ "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoProcessor.from_pretrained`. Also applied to "
+ "reward-model and reward-tokenizer loads."
+ },
+ )
+ router_aux_loss_coef: float = field(
+ default=0.001,
+ metadata={
+ "help": "Coefficient of the load-balancing auxiliary loss. Only has an effect when training a "
+ "Mixture-of-Experts (MoE) model; for other models it does nothing. The auxiliary loss is added to the "
+ "training loss with this weight. Set to `0.0` to disable it."
+ },
+ )
+ disable_dropout: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to disable dropout in the model. This is useful for training with a reference model, as "
+ "it prevents the model from generating different logprobs for the same input."
+ },
+ )
+ cast_lm_head_to_fp32: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to cast the language modeling head of the policy and reference, models to float32."
+ "As recommended by the [ScaleRL](https://huggingface.co/papers/2510.13786) recipe. This flag is only "
+ "supported when the model has untied word embedding and language modeling head layers i.e. "
+ "`tie_word_embeddings` in the model config is False."
+ },
+ )
+
+ # Parameters that control the data preprocessing
+ # The default value remove_unused_columns is overwritten from the parent class, because in GRPO we usually rely on
+ # additional columns to compute the reward
+ remove_unused_columns: bool | None = field(
+ default=False,
+ metadata={
+ "help": "Whether to only keep the column 'prompt' in the dataset. If you use a custom reward function "
+ "that requires any column other than 'prompts' and 'completions', you should keep this to `False`."
+ },
+ )
+ num_generations: int | None = field(
+ default=8,
+ metadata={
+ "help": "Number of generations to sample. The effective batch size (num_processes * per_device_batch_size "
+ "* gradient_accumulation_steps) must be evenly divisible by this value."
+ },
+ )
+ num_generations_eval: int | None = field(
+ default=None,
+ metadata={
+ "help": "Number of generations to sample during evaluation. This allows using fewer generations during "
+ "evaluation to save computation. If `None`, uses the value of `num_generations`."
+ },
+ )
+ max_completion_length: int | None = field(
+ default=256,
+ metadata={"help": "Maximum length of the generated completion."},
+ )
+ ds3_gather_for_generation: bool = field(
+ default=True,
+ metadata={
+ "help": "This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for "
+ "generation, improving generation speed. However, disabling this option allows training models that "
+ "exceed the VRAM capacity of a single GPU, albeit at the cost of slower generation. Disabling this option "
+ "is not compatible with vLLM generation."
+ },
+ )
+ shuffle_dataset: bool | None = field(
+ default=True,
+ metadata={"help": "Whether to shuffle the training dataset."},
+ )
+ pad_to_multiple_of: int | None = field(
+ default=None,
+ metadata={"help": "If set, the prompts ids and completions ids will be padded to a multiple of this value."},
+ )
+
+ # Parameters that control generation
+ generation_batch_size: int | None = field(
+ default=None,
+ metadata={
+ "help": "Batch size to use for generation. If `None`, it defaults to the effective training batch size: "
+ "`per_device_train_batch_size * num_processes * steps_per_generation`."
+ },
+ )
+ steps_per_generation: int | None = field(
+ default=None,
+ metadata={"help": "Number of steps per generation. If `None`, it defaults to `gradient_accumulation_steps`."},
+ )
+ temperature: float = field(
+ default=1.0,
+ metadata={"help": "Temperature for sampling. The higher the temperature, the more random the completions."},
+ )
+ top_p: float = field(
+ default=1.0,
+ metadata={
+ "help": "Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. "
+ "Set to 1.0 to consider all tokens."
+ },
+ )
+ top_k: int = field(
+ default=0,
+ metadata={
+ "help": "Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, "
+ "top-k-filtering is disabled and all tokens are considered."
+ },
+ )
+ min_p: float | None = field(
+ default=None,
+ metadata={
+ "help": "Minimum token probability, which will be scaled by the probability of the most likely token. It "
+ "must be a value between 0.0 and 1.0. Typical values are in the 0.01-0.2 range."
+ },
+ )
+ generation_kwargs: dict | None = field(
+ default=None,
+ metadata={
+ "help": "Additional keyword arguments to pass to `GenerationConfig` (if using transformers) or "
+ "`SamplingParams` (if using vLLM) when sampling completions. This can be used to further customize the "
+ "generation behavior, such as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that "
+ "conflict with the other generation parameters (like `min_p`, `top_p`, etc.), they will override them."
+ },
+ )
+ chat_template_kwargs: dict | None = field(
+ default=None,
+ metadata={
+ "help": "Additional keyword arguments to pass to the `apply_chat_template` function when generating "
+ "completions."
+ },
+ )
+ repetition_penalty: float = field(
+ default=1.0,
+ metadata={
+ "help": "Float that penalizes new tokens based on whether they appear in the prompt and the generated "
+ "text so far. Values > 1.0 encourage the model to use new tokens, while values < 1.0 encourage the model "
+ "to repeat tokens."
+ },
+ )
+ cache_implementation: str | None = field(
+ default=None,
+ metadata={"help": "Implementation of the cache method for faster generation when use_vllm is set to False."},
+ )
+
+ # Parameters that control generation acceleration powered by vLLM
+ use_vllm: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for "
+ "generation instead of the default model.generate(). Requires `vllm` to be installed."
+ },
+ )
+ vllm_mode: str = field(
+ default="colocate",
+ metadata={
+ "help": "Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `'server'` or "
+ "`'colocate'`. `'server'`: The trainer will send generation requests to a separate vLLM server. Make sure "
+ "a TRL vLLM server is running (start with `trl vllm-serve`). `'colocate'`: vLLM will run in the same "
+ "process and share the training GPUs. This avoids the need for a separate server but may cause resource "
+ "contention with training."
+ },
+ )
+ vllm_model_impl: str = field(
+ default="vllm",
+ metadata={
+ "help": "Model implementation to use for vLLM. Must be one of `transformers` or `vllm`. `transformers`: "
+ "Use the `transformers` backend for model implementation. `vllm`: Use the `vllm` library for "
+ "model implementation."
+ },
+ )
+ vllm_enable_sleep_mode: bool = field(
+ default=False,
+ metadata={
+ "help": "Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory "
+ "usage low, but waking the engine adds host–device transfer latency."
+ },
+ )
+ vllm_structured_outputs_regex: str | None = field(
+ default=None,
+ metadata={"help": "Regex for vLLM structured outputs. If `None` (default), structured outputs is disabled."},
+ )
+
+ # Parameters that control the vLLM server (only used when `vllm_mode` is `"server"`)
+ vllm_server_base_url: str | None = field(
+ default=None,
+ metadata={
+ "help": "Base URL for the vLLM server (e.g., 'http://localhost:8000'). If provided, `vllm_server_host` "
+ "and `vllm_server_port` are ignored."
+ },
+ )
+ vllm_server_host: str = field(
+ default="0.0.0.0",
+ metadata={"help": "Host of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."},
+ )
+ vllm_server_port: int = field(
+ default=8000,
+ metadata={"help": "Port of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."},
+ )
+ vllm_server_timeout: float = field(
+ default=240.0,
+ metadata={
+ "help": "Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up "
+ "after the timeout, a `ConnectionError` is raised."
+ },
+ )
+ vllm_group_port: int = field(
+ default=51216,
+ metadata={
+ "help": "Port number for the weight update group. This is used to communicate with the vLLM server. "
+ "Unless the port is occupied, there is no need to change it.",
+ },
+ )
+
+ # Parameters that control colocated vLLM execution (only used when `vllm_mode` is `"colocate"`)
+ vllm_gpu_memory_utilization: float = field(
+ default=0.3,
+ metadata={
+ "help": "Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set "
+ "to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when "
+ "launching the vLLM server via the `--vllm_gpu_memory_utilization` flag."
+ },
+ )
+ vllm_max_model_length: int | None = field(
+ default=None,
+ metadata={
+ "help": "Context window for vLLM. Set it to at least the maximum prompt length in the dataset plus "
+ "`max_completion_length`; if omitted, it is inferred from the model config."
+ },
+ )
+ vllm_tensor_parallel_size: int = field(
+ default=1,
+ metadata={
+ "help": "Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set "
+ "to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when "
+ "launching the vLLM server via the `--vllm_tensor_parallel_size` flag."
+ },
+ )
+
+ # Parameters that control the training
+ beta: float = field(
+ default=0.0,
+ metadata={
+ "help": "KL coefficient. If `0.0` (default), the reference model is not loaded, reducing memory usage and "
+ "improving training speed. [DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement "
+ "learning](https://huggingface.co/papers/2501.12948) use a value of `0.001`."
+ },
+ )
+ num_iterations: int = field(
+ default=1,
+ metadata={"help": "Number of iterations per batch (denoted as μ in the algorithm)."},
+ )
+ epsilon: float = field(
+ default=0.2,
+ metadata={"help": "Epsilon value for clipping."},
+ )
+ delta: float | None = field(
+ default=None,
+ metadata={
+ "help": "Enables the upper clipping bound in two-sided GRPO loss when set to a float. If `None` "
+ "(default), standard GRPO clipping is used. Recommended to be greater than `1 + ε` when enabled. This "
+ "method is introduced in the [INTELLECT-2 tech report](https://huggingface.co/papers/2505.07291)."
+ },
+ )
+ epsilon_high: float | None = field(
+ default=None,
+ metadata={
+ "help": "Upper-bound epsilon value for clipping. If not specified, it defaults to the same value as the "
+ "lower-bound specified in argument `epsilon`. Paper DAPO recommends `0.28`. "
+ "When used with `loss_type='cispo'`, this corresponds to the ε_max param specified in the "
+ "[ScaleRL paper](https://huggingface.co/papers/2510.13786) and the recommended value is `5.0`."
+ },
+ )
+ sapo_temperature_neg: float = field(
+ default=1.05,
+ metadata={
+ "help": "Temperature for tokens with non-positive advantage scores used in the `sapo` loss function. "
+ "This parameter is introduced in the [Soft Adaptive Policy Optimization "
+ "paper](https://huggingface.co/papers/2511.20347)."
+ },
+ )
+ sapo_temperature_pos: float = field(
+ default=1.0,
+ metadata={
+ "help": "Temperature for tokens with positive advantage scores used in the `sapo` loss function. "
+ "This parameter is introduced in the [Soft Adaptive Policy Optimization "
+ "paper](https://huggingface.co/papers/2511.20347)."
+ },
+ )
+ vespo_k_pos: float = field(
+ default=2.0,
+ metadata={
+ "help": "k parameter for positive advantages, it is the power exponent in the VESPO loss. Controls how "
+ "aggressively we down-weight samples with low importance weights (when the importance sampling ratio < 1)."
+ },
+ )
+ vespo_lambda_pos: float = field(
+ default=3.0,
+ metadata={
+ "help": "lambda parameter for positive advantages, it is the decay factor in the VESPO loss. Controls "
+ "how aggressively we down-weight samples with high importance weights (when the importance sampling ratio "
+ "> 1)."
+ },
+ )
+ vespo_k_neg: float = field(
+ default=3.0,
+ metadata={
+ "help": "k parameter for negative advantages, it is the power exponent in the VESPO loss. Controls how "
+ "aggressively we down-weight samples with low importance weights (when the importance sampling ratio < 1)."
+ },
+ )
+ vespo_lambda_neg: float = field(
+ default=2.0,
+ metadata={
+ "help": "lambda parameter for negative advantages, it is the exponential decay factor in the VESPO loss. "
+ "Controls how aggressively we down-weight samples with high importance weights (when the importance "
+ "sampling ratio > 1)."
+ },
+ )
+ importance_sampling_level: str = field(
+ default="token",
+ metadata={
+ "help": "Controls whether importance sampling ratios are computed at the `'token'` or `'sequence'` level. "
+ "`'token'` keeps the raw per-token log-probability ratios (one weight per token). `'sequence'` averages "
+ "the log-probability ratios across valid tokens to produce a single ratio per sequence. The GSPO paper "
+ "shows that sequence-level sampling often yields more stable training and better alignment with "
+ "sequence-level rewards."
+ },
+ )
+ reward_weights: list[float] | None = field(
+ default=None,
+ metadata={
+ "help": "Weights for each reward function. Must match the number of reward functions. If `None`, all "
+ "rewards are weighted equally with weight `1.0`."
+ },
+ )
+ multi_objective_aggregation: str = field(
+ default="sum_then_normalize",
+ metadata={
+ "help": "Method to aggregate multiple reward functions. Supported values are: "
+ "`'sum_then_normalize'` (default): First sums the weighted rewards from each reward function, then "
+ "applies reward scaling/normalization as specified by `scale_rewards` (see `scale_rewards` for details). "
+ "`'normalize_then_sum'`: First normalizes/scales each reward function across generations (within each "
+ "group), then sums the normalized rewards using the specified weights. The aggregated reward is then "
+ "normalized at the batch level when forming advantages. This is the suggested approach from the paper "
+ "GDPO: Group reward-Decoupled Normalization Policy Optimization for Multi-reward RL Optimization."
+ },
+ )
+ scale_rewards: str = field(
+ default="group",
+ metadata={
+ "help": "Specifies the scaling strategy for rewards. Supported values are: "
+ "`True` or `group'` (default): rewards are scaled by the standard deviation within each group, ensuring "
+ "unit variance within a group. "
+ "`'batch'`: rewards are scaled by the standard deviation across the entire batch, as recommended in the "
+ "PPO Lite paper. "
+ "`False` or `'none'`: no scaling is applied. The Dr. GRPO paper recommends not scaling rewards, as "
+ "scaling by the standard deviation introduces a question-level difficulty bias."
+ },
+ )
+ loss_type: str = field(
+ default="dapo",
+ metadata={
+ "help": "Specifies the loss formulation to use. Supported values are 'grpo', 'dapo', 'bnpo', and "
+ "'dr_grpo'. "
+ "'grpo': Aggregates token-level losses by normalizing over sequence length. Not recommended due to length "
+ "bias—this approach tends to prefer shorter completions with positive advantages and longer ones with "
+ "negative advantages. "
+ "'dapo' (default): Aggregates token-level losses by normalizing with the number of active token in the "
+ "global accumulated batch. This method was introduced in the DAPO paper to eliminate length bias. "
+ "'dr_grpo': Aggregates token-level losses by normalizing with a global constant. This method was "
+ "introduced in the Dr. GRPO paper to eliminate length bias. The value of the constant corresponds to "
+ "`max_completion_length`. "
+ "'bnpo': Aggregates token-level losses by normalizing with the number of active token in the local batch. "
+ "Note that normalization is performed over the local batch only, so results may slightly vary depending "
+ "on the local batch size, despite a constant effective batch size. When using "
+ "`per_device_train_batch_size==1`, the loss is equivalent to the GRPO loss."
+ "'cispo': Clips the importance sampling weights instead of the advantage scaled importance weights. "
+ "The clipped weights are then multiplied with the advantages and policy model's log probs. "
+ "Individual token losses are aggregated by normalizing with the number of active tokens in "
+ "the global accumulated batch. This method was introduced in the "
+ "[MiniMax-M1 paper](https://huggingface.co/papers/2506.13585). "
+ "'sapo': Soft Adaptive Policy Optimization loss, as introduced in the "
+ "[Soft Adaptive Policy Optimization paper](https://huggingface.co/papers/2511.20347). "
+ "Replaces hard clipping with a smooth, temperature-controlled gate that adaptively attenuates "
+ "off-policy updates while preserving useful learning signals."
+ "'luspo': Length-Unbiased Sequence Policy Optimization loss. A sequence-level loss that scales each "
+ "sequence's loss by its length. This is a modification of GSPO and requires "
+ "`importance_sampling_level='sequence'`. Introduced in the [LUSPO "
+ "paper](https://huggingface.co/papers/2602.05261)."
+ "'vespo': Variational Sequence-Level Soft Policy Optimization. Replaces hard clipping with a smooth, "
+ "asymmetric Gamma weighting function applied directly to sequence-level importance weights. Introduced in "
+ "the [VESPO paper](https://huggingface.co/papers/2602.10693)."
+ },
+ )
+ mask_truncated_completions: bool = field(
+ default=False,
+ metadata={
+ "help": "When enabled, truncated completions are excluded from the loss calculation, preventing them from "
+ "being incorrectly penalized and introducing noise during training. According to the DAPO paper, this is "
+ "a good practice for training stability."
+ },
+ )
+ sync_ref_model: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to synchronize the reference model with the active model every `ref_model_sync_steps` "
+ "steps, using the `ref_model_mixup_alpha` parameter."
+ },
+ )
+ ref_model_mixup_alpha: float = field(
+ default=0.6,
+ metadata={
+ "help": "α parameter from the TR-DPO paper, which controls the mix between the current policy and the "
+ "previous reference policy during updates. The reference policy is updated according to the equation: "
+ "`π_ref = α * π_θ + (1 - α) * π_ref_prev`. To use this parameter, you must set `sync_ref_model=True`."
+ },
+ )
+ ref_model_sync_steps: int = field(
+ default=512,
+ metadata={
+ "help": "τ parameter from the TR-DPO paper, which determines how frequently the current policy is "
+ "synchronized with the reference policy. To use this parameter, you must set `sync_ref_model=True`."
+ },
+ )
+ top_entropy_quantile: float = field(
+ default=1.0,
+ metadata={
+ "help": "ρ parameter from Beyond the 80/20 Rule. Keeps in the policy loss term only the top-ρ quantile of "
+ "tokens by entropy of the probability distribution at each sequence position, improving results. Range: "
+ "[0.0-1.0]. A value of `0.0` masks all but the highest entropy token; `1.0` keeps all tokens. The paper "
+ "recommends a value of `0.2`. If used with `mask_truncated_completions=True`, only tokens from "
+ "non-truncated completions are considered."
+ },
+ )
+ max_tool_calling_iterations: int | None = field(
+ default=None,
+ metadata={
+ "help": "Maximum number of tool-calling turns when training an agent. If `None`, there is no limit and "
+ "generation stops when the model generates a response turn with no tool calls or when the total "
+ "response length reaches `max_model_length`."
+ },
+ )
+ vllm_importance_sampling_correction: bool = field(
+ default=True,
+ metadata={
+ "help": "Whether to apply Importance Sampling (IS) to correct for the mismatch between vLLM "
+ "completion logprobs and recomputed training logprobs. If set to `False`, no IS is applied "
+ "regardless of `vllm_importance_sampling_mode`. When `True`, the selected mode determines how "
+ "IS ratios are computed and constrained."
+ },
+ )
+ vllm_importance_sampling_mode: str = field(
+ default="sequence_mask",
+ metadata={
+ "help": "Specifies how Importance Sampling (IS) is performed when "
+ "vllm_importance_sampling_correction=True. Modes are defined along two orthogonal "
+ "dimensions: (1) constraint, which determines how to handle ratios outside the bounds "
+ "[C_min, C_max]—either truncation (clip to range, ρ ← clamp(ρ, C_min, C_max)) or "
+ "masking (set ratios above C_max or below C_min to zero); and (2) granularity, which determines whether "
+ "ratios are computed per token or as a single sequence-level ratio applied to all tokens. "
+ "Supported options are: 'token_truncate', 'token_mask', 'sequence_truncate', and "
+ "'sequence_mask'."
+ },
+ )
+ vllm_importance_sampling_clip_max: float | None = field(
+ default=3.0,
+ metadata={
+ "help": "Importance sampling upper bound C_max used by `vllm_importance_sampling_mode`. For '*_truncate' "
+ "modes, ratios are clipped from above at C_max. For '*_mask' modes, ratios larger than C_max are set to "
+ "zero."
+ },
+ )
+ vllm_importance_sampling_clip_min: float | None = field(
+ default=None,
+ metadata={
+ "help": "Importance sampling lower bound C_min used by `vllm_importance_sampling_mode`. For `*_truncate` "
+ "modes, ratios are clipped from below at C_min. For `*_mask` modes, ratios below C_min are set to "
+ "zero. To strictly mask ratios below C_min without upper bound, set `vllm_importance_sampling_clip_max=None`."
+ },
+ )
+ off_policy_mask_threshold: float | None = field(
+ default=None,
+ metadata={
+ "help": "Threshold for off-policy sequence masking. If `None`, off-policy sequence masking is disabled. "
+ "When set, sequences with negative advantages and high KL divergence are masked out to stabilize "
+ "training. This parameter corresponds to the `delta` threshold in Equation 9 of the [DeepSeek-V3.2 "
+ "paper](https://huggingface.co/papers/2512.02556). It expects a positive value (e.g., 0.5)."
+ },
+ )
+ use_bias_correction_kl: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to use the unbiased KL divergence estimator with importance sampling correction. This "
+ "corrects the KL divergence estimate by multiplying it with the importance sampling ratio. "
+ "This is described in the [DeepSeek-V3.2 paper](https://huggingface.co/papers/2512.02556)."
+ },
+ )
+
+ # Parameters that control the logging
+ log_completions: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to log a sample of (prompt, completion) pairs every `logging_steps` steps. If `rich` is "
+ "installed, it prints the sample. If `wandb` logging is enabled, it logs it to `wandb`."
+ },
+ )
+ num_completions_to_print: int | None = field(
+ default=None,
+ metadata={"help": "Number of completions to print with `rich`. If `None`, all completions are logged."},
+ )
+ log_unique_prompts: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to log unique prompts. If `True`, only unique prompts are logged. If `False`, all "
+ "prompts are logged."
+ },
+ )
+ log_completions_hub_repo: str | None = field(
+ default=None,
+ metadata={
+ "help": "Hugging Face Hub repository to save the completions. Should be a complete repository name like "
+ "`'username/reponame'` or `'orgname/reponame'`, or just `'reponame'` in which case the repository will "
+ "be created in the currently-logged-in Hugging Face user's namespace. Note that this repository will be "
+ "public unless you set `hub_private_repo=True` or your organization's default is to create private "
+ "repositories."
+ },
+ )
+
+ # Parameters that control generation acceleration powered by transformers continuous batching
+ use_transformers_continuous_batching: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to use transformers' continuous batching engine for generating completions. Requires "
+ "transformers>=5.8.0."
+ },
+ )
+ transformers_continuous_batching_config: dict | None = field(
+ default=None,
+ metadata={"help": "Keyword arguments for `transformers.generation.ContinuousBatchingConfig`."},
+ )
+
+ # Deprecated parameters
+ use_transformers_paged: bool = field(
+ default=False,
+ metadata={"help": "Deprecated. Use `use_transformers_continuous_batching` instead."},
+ )
+ vllm_importance_sampling_cap: float | None = field(
+ default=None,
+ metadata={
+ "help": "Deprecated, use `vllm_importance_sampling_clip_max` instead. "
+ "Importance sampling cap C used by `vllm_importance_sampling_mode`. For '*_truncate' modes, "
+ "ratios are clipped from above at C. For '*_mask' modes, ratios larger than C are set to zero."
+ },
+ )
+
+ def __post_init__(self):
+ super().__post_init__()
+
+ if self.use_transformers_paged:
+ warnings.warn(
+ "`use_transformers_paged` is deprecated and will be removed in v2.0.0. Use "
+ "`use_transformers_continuous_batching` instead.",
+ FutureWarning,
+ stacklevel=3,
+ )
+ self.use_transformers_continuous_batching = True
+
+ if self.parallelism_config is not None and (
+ self.parallelism_config.cp_enabled or self.parallelism_config.sp_enabled
+ ):
+ raise ValueError(
+ "GRPOTrainer does not support sequence-dim parallelism (`parallelism_config.cp_size > 1` or "
+ "`parallelism_config.sp_size > 1`) yet. GRPO builds model inputs after generation inside the trainer, "
+ "so Transformers' context-parallel / Ulysses sequence-parallel input sharding cannot be applied to the "
+ "raw generation batch. Set both `cp_size=1` and `sp_size=1`, or disable `parallelism_config`."
+ )
+
+ self.scale_rewards = {True: "group", False: "none"}.get(self.scale_rewards, self.scale_rewards)
+
+ if self.log_completions_hub_repo is not None and not self.log_completions:
+ raise ValueError(
+ "log_completions_hub_repo is set, but log_completions is False. Enable log_completions to upload "
+ "completions to the Hub, or unset log_completions_hub_repo."
+ )
+
+ num_processes = self.world_size
+ # The current default effective batch size
+ if self.generation_batch_size is None and self.steps_per_generation is None:
+ self.steps_per_generation = self.gradient_accumulation_steps
+ self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation
+ elif self.generation_batch_size is not None and self.steps_per_generation is None:
+ # Just ensure the value is divisible by the global batch size
+ if self.generation_batch_size % (self.per_device_train_batch_size * num_processes) != 0:
+ raise ValueError(
+ f"generation_batch_size ({self.generation_batch_size}) must be divisible by the global batch size "
+ f"({self.per_device_train_batch_size * num_processes})."
+ )
+ self.steps_per_generation = self.generation_batch_size // (
+ self.per_device_train_batch_size * num_processes
+ )
+ elif self.generation_batch_size is None and self.steps_per_generation is not None:
+ self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation
+ else:
+ raise ValueError(
+ "'generation_batch_size' and 'steps_per_generation' can not be both configured at the same time"
+ )
+
+ if self.do_eval and self.eval_strategy != "no":
+ # Determine the number of generations to use for evaluation
+ num_generations = self.num_generations_eval or self.num_generations
+
+ # Just ensure the value is divisible by the global batch size
+ if (self.per_device_eval_batch_size * num_processes) % num_generations != 0:
+ raise ValueError(
+ f"The global eval batch size ({self.per_device_eval_batch_size} * {num_processes}) must be "
+ f"divisible by the number of generations used for evaluation ({num_generations})."
+ )
+
+ # The generation batch must contain full prompt groups (no partials), so it must be divisible by
+ # num_generations.
+ if self.generation_batch_size % self.num_generations != 0:
+ raise ValueError(
+ f"generation_batch_size ({self.generation_batch_size}) must be divisible by num_generations "
+ f"({self.num_generations})."
+ )
+
+ if self.num_generations < 2:
+ raise ValueError(
+ "GRPO requires at least 2 generations per prompt to calculate the advantages. You provided "
+ f"{self.num_generations}, which is less than the minimum required."
+ )
+
+ if self.vllm_importance_sampling_cap is not None:
+ warnings.warn(
+ "The `vllm_importance_sampling_cap` argument is deprecated and will be removed in v2.0.0. "
+ "Use `vllm_importance_sampling_clip_max` instead.",
+ FutureWarning,
+ stacklevel=2,
+ )
+ self.vllm_importance_sampling_clip_max = self.vllm_importance_sampling_cap
+
+ if (
+ self.vllm_importance_sampling_clip_min is not None
+ and self.vllm_importance_sampling_clip_max is not None
+ and self.vllm_importance_sampling_clip_min >= self.vllm_importance_sampling_clip_max
+ ):
+ raise ValueError(
+ f"vllm_importance_sampling_clip_min ({self.vllm_importance_sampling_clip_min}) must be less than "
+ f"vllm_importance_sampling_clip_max ({self.vllm_importance_sampling_clip_max})."
+ )
+
+ if (
+ self.vllm_importance_sampling_correction
+ and self.vllm_importance_sampling_mode in ("token_truncate", "sequence_truncate")
+ and self.vllm_importance_sampling_clip_min is None
+ and self.vllm_importance_sampling_clip_max is None
+ ):
+ raise ValueError(
+ "At least one of `vllm_importance_sampling_clip_min` or `vllm_importance_sampling_clip_max` "
+ "must be set when `vllm_importance_sampling_mode` is a `*_truncate` mode."
+ )
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/grpo_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/grpo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..a7a673e878481fbee95567bf1e705913638cfc8c
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/grpo_trainer.py
@@ -0,0 +1,2887 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import atexit
+import copy
+import importlib.resources as pkg_resources
+import inspect
+import math
+import os
+import sys
+import textwrap
+import time
+import warnings
+from collections import defaultdict, deque
+from collections.abc import Callable
+from contextlib import nullcontext
+from pathlib import Path
+from typing import Any, Protocol
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.utils.data
+import transformers
+from accelerate.logging import get_logger
+from accelerate.utils import gather, gather_object, is_peft_model, set_seed
+from datasets import Dataset, IterableDataset
+from huggingface_hub import CommitScheduler, DatasetCard, DatasetCardData, create_repo
+from packaging.version import Version
+from torch import nn
+from torch.utils.data import Sampler
+from transformers import (
+ AutoModelForSequenceClassification,
+ AutoProcessor,
+ AutoTokenizer,
+ GenerationConfig,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+ ProcessorMixin,
+ TrainerCallback,
+ is_trackio_available,
+ is_wandb_available,
+)
+from transformers.utils import is_peft_available, is_rich_available
+
+from ..chat_template_utils import (
+ add_response_schema,
+ get_training_chat_template,
+ is_chat_template_prefix_preserving,
+ parse_response,
+ supports_tool_calling,
+)
+from ..data_utils import apply_chat_template, is_conversational, prepare_multimodal_messages
+from ..distributed import DistributedBackend
+from ..extras.profiling import profiling_context, profiling_decorator
+from ..generation.vllm_generation import VLLMGeneration
+from ..import_utils import is_jmespath_available, is_liger_kernel_available
+from ..models import prepare_deepspeed, prepare_fsdp, unwrap_model_for_generation
+from ..models.utils import _ForwardRedirection, disable_gradient_checkpointing
+from .base_trainer import _BaseTrainer
+from .callbacks import SyncRefModelCallback
+from .grpo_config import GRPOConfig
+from .utils import (
+ RepeatSampler,
+ create_model_from_path,
+ disable_dropout_in_model,
+ entropy_from_logits,
+ get_config_model_id,
+ identity,
+ nanmax,
+ nanmin,
+ nanstd,
+ pad,
+ print_prompt_completions_sample,
+ selective_log_softmax,
+ shuffle_sequence_dict,
+ shutdown_event_loop_in_daemon,
+ split_pixel_values_by_grid,
+ split_tensor_dict,
+ start_event_loop_in_daemon,
+ unsplit_pixel_values_by_grid,
+ use_adapter,
+)
+
+
+if is_peft_available():
+ import peft
+ from peft import LoraConfig, PeftConfig, PeftModel, get_peft_model
+ from peft.tuners.tuners_utils import BaseTunerLayer
+
+if is_liger_kernel_available():
+ from liger_kernel.chunked_loss import LigerFusedLinearGRPOLoss
+
+
+if is_wandb_available():
+ import wandb
+
+if is_trackio_available():
+ import trackio
+
+
+logger = get_logger(__name__)
+
+# A reward function can be a string, interpreted as a model ID and loaded as a pretrained model, a pretrained model, or
+# a callable that returns a list of floats (the rewards). The callable receives prompts, completions, and additional
+# arguments from the trainer (refer to the trainer's source for details). To ensure forward compatibility, it should
+# accept **kwargs.
+RewardFunc = str | PreTrainedModel | Callable[..., list[float | None]]
+
+# What we call a rollout function is a callable that takes prompts (list) and the trainer instance as parameters and
+# returns a dict of generation results. Those results must include "prompt_ids", "completion_ids", and "logprobs"
+# fields. Any extra fields (per-completion) are forwarded to the reward functions.
+RolloutFunc = Callable[[list[str], "GRPOTrainer"], dict[str, Any]]
+
+
+class _SupportsReset(Protocol):
+ def reset(self, **kwargs) -> str | None: ...
+
+
+EnvironmentFactory = Callable[[], _SupportsReset]
+
+
+class GRPOTrainer(_BaseTrainer):
+ """
+ Trainer for the Group Relative Policy Optimization (GRPO) method. This algorithm was initially proposed in the
+ paper [DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language
+ Models](https://huggingface.co/papers/2402.03300).
+
+ Example:
+
+ ```python
+ from trl import GRPOTrainer
+ from trl.rewards import accuracy_reward
+ from datasets import load_dataset
+
+ dataset = load_dataset("trl-lib/DeepMath-103K", split="train")
+
+ trainer = GRPOTrainer(
+ model="Qwen/Qwen2.5-0.5B-Instruct",
+ reward_funcs=accuracy_reward,
+ train_dataset=dataset,
+ )
+ trainer.train()
+ ```
+
+ Args:
+ model (`str` or [`~transformers.PreTrainedModel`] or [`~peft.PeftModel`]):
+ Model to be trained. Can be either:
+
+ - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a
+ path to a *directory* containing model weights saved using
+ [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded
+ using `.from_pretrained` (where `` is derived from the model
+ config) with the keyword arguments in `args.model_init_kwargs`.
+ - A [`~transformers.PreTrainedModel`] object. Only causal language models are supported.
+ - A [`~peft.PeftModel`] object. Only causal language models are supported.
+ reward_funcs (`RewardFunc | list[RewardFunc]`):
+ Reward functions to be used for computing the rewards. To compute the rewards, we call all the reward
+ functions with the prompts and completions and sum the rewards. Can be either:
+
+ - A single reward function, such as:
+ - A string: The *model ID* of a pretrained model hosted inside a model repo on huggingface.co, or a
+ path to a *directory* containing model weights saved using
+ [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded
+ using [`~transformers.AutoModelForSequenceClassification.from_pretrained`] with `num_labels=1` and the
+ keyword arguments in `args.model_init_kwargs`.
+ - A [`~transformers.PreTrainedModel`] object: Only sequence classification models are supported.
+ - A custom reward function: The function is provided with the prompts and the generated completions,
+ plus any additional columns in the dataset. It should return a list of rewards. Custom reward
+ functions can be either synchronous or asynchronous and can also return `None` when the reward is
+ not applicable to those samples. This is useful for multi-task training where different reward
+ functions apply to different types of samples. When a reward function returns `None` for a sample,
+ that reward function is excluded from the reward calculation for that sample. For more details, see
+ [Using a custom reward
+ function](#using-a-custom-reward-function).
+
+ The trainer's state is also passed to the reward function. The trainer's state is an instance of
+ [`~transformers.TrainerState`] and can be accessed by accessing the `trainer_state` argument to the
+ reward function's signature.
+ - A list of reward functions, where each item can independently be any of the above types. Mixing different
+ types within the list (e.g., a string model ID and a custom reward function) is allowed.
+ args ([`GRPOConfig`], *optional*):
+ Configuration for this trainer. If `None`, a default configuration is used.
+ train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]):
+ Dataset to use for training. It must include a column `"prompt"`. Any additional columns in the dataset is
+ ignored. The format of the samples can be either:
+
+ - [Standard](dataset_formats#standard): Each sample contains plain text.
+ - [Conversational](dataset_formats#conversational): Each sample contains structured messages (e.g., role
+ and content).
+ eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`):
+ Dataset to use for evaluation. It must meet the same requirements as `train_dataset`.
+ processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.ProcessorMixin`], *optional*):
+ Processing class used to process the data. The padding side must be set to "left". If `None`, the
+ processing class is loaded from the model's name with [`~transformers.AutoProcessor.from_pretrained`]. A
+ padding token, `tokenizer.pad_token`, must be set. If the processing class has not set a padding token,
+ `tokenizer.eos_token` will be used as the default.
+ reward_processing_classes ([`~transformers.PreTrainedTokenizerBase`] or `list[PreTrainedTokenizerBase]`, *optional*):
+ Processing classes corresponding to the reward functions specified in `reward_funcs`. Can be either:
+
+ - A single processing class: Used when `reward_funcs` contains only one reward function.
+ - A list of processing classes: Must match the order and length of the reward functions in `reward_funcs`.
+ If set to `None`, or if an element of the list corresponding to a [`~transformers.PreTrainedModel`] is
+ `None`, the tokenizer for the model is automatically loaded using
+ [`~transformers.AutoTokenizer.from_pretrained`]. For elements in `reward_funcs` that are custom reward
+ functions (not [`~transformers.PreTrainedModel`]), the corresponding entries in `reward_processing_classes`
+ are ignored.
+ callbacks (list of [`~transformers.TrainerCallback`], *optional*):
+ List of callbacks to customize the training loop. Will add those to the list of default callbacks detailed
+ in [here](https://huggingface.co/docs/transformers/main_classes/callback).
+
+ If you want to remove one of the default callbacks used, use the [`~transformers.Trainer.remove_callback`]
+ method.
+ optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *optional*, defaults to `(None, None)`):
+ A tuple containing the optimizer and the scheduler to use. Will default to an instance of `AdamW` on your
+ model and a scheduler given by [`~transformers.get_linear_schedule_with_warmup`] controlled by `args`.
+ peft_config ([`~peft.PeftConfig`], *optional*):
+ PEFT configuration used to wrap the model. If `None`, the model is not wrapped.
+ tools (list of `Callable`, *optional*):
+ A list of callable tool functions (sync or async) that the model can invoke during generation. Each tool
+ should be a standard Python function with properly type-hinted arguments and return values, and a
+ Google-style docstring describing its purpose, arguments, and return value. For more details, see:
+ https://huggingface.co/docs/transformers/en/chat_extras#passing-tools. The model uses the function's name,
+ type hints, and docstring to determine how to call it. Ensure that the model's chat template supports tool
+ use and that it has been fine-tuned for tool calling.
+ rollout_func (`RolloutFunc`, *optional*):
+ Function to use for generating completions. It receives the list of prompts allocated to the current
+ process and the trainer instance. It must return a dict with `"prompt_ids"`, `"completion_ids"`, and
+ `"logprobs"` fields, and can optionally return `"logprob_token_ids"` (same shape as `"logprobs"`). Any
+ other fields are forwarded to the reward functions. The function receives the raw per-process prompt slice
+ with no duplication; it is responsible for returning the correct number of completions per prompt (see
+ `num_generations` / `num_generations_eval` on the trainer). This feature is experimental and may change or
+ be removed at any time without prior notice.
+ environment_factory (`EnvironmentFactory`, *optional*):
+ A callable that creates and returns an environment instance. The environment class should define methods
+ that can be invoked as tools during generation. Each method should comply with the same requirements as the
+ `tools` described above. If `environment_factory` is provided, an instance of the environment is created
+ for each generation in the batch, allowing for parallel and independent interactions. The environment must
+ also implement a callable `reset` method that can be used to reset state between generations. The `reset`
+ method should return either `None` or a string: when it returns a string, that string is appended to the
+ last user message before generation. This feature is experimental and may change or be removed at any time
+ without prior notice.
+ """
+
+ _tag_names = ["trl", "grpo"]
+ _name = "GRPO"
+ _paper = {
+ "title": "DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models",
+ "id": "2402.03300",
+ # docstyle-ignore
+ "citation": textwrap.dedent("""\
+ @article{shao2024deepseekmath,
+ title = {{DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models}},
+ author = {Zhihong Shao and Peiyi Wang and Qihao Zhu and Runxin Xu and Junxiao Song and Mingchuan Zhang and Y. K. Li and Y. Wu and Daya Guo},
+ year = 2024,
+ eprint = {arXiv:2402.03300},
+ }"""),
+ }
+
+ def __init__(
+ self,
+ model: "str | PreTrainedModel | PeftModel",
+ reward_funcs: RewardFunc | list[RewardFunc],
+ args: GRPOConfig | None = None,
+ train_dataset: Dataset | IterableDataset | None = None,
+ eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None,
+ processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None,
+ reward_processing_classes: PreTrainedTokenizerBase | list[PreTrainedTokenizerBase] | None = None,
+ callbacks: list[TrainerCallback] | None = None,
+ optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None),
+ peft_config: "PeftConfig | None" = None,
+ tools: list[Callable] | None = None,
+ rollout_func: RolloutFunc | None = None,
+ environment_factory: EnvironmentFactory | None = None,
+ ):
+ # Args
+ if args is None:
+ model_name = model if isinstance(model, str) else get_config_model_id(model.config)
+ model_name = model_name.split("/")[-1]
+ args = GRPOConfig(f"{model_name}-GRPO")
+
+ # Model
+ if isinstance(model, str):
+ model_init_kwargs = args.model_init_kwargs or {}
+ # Distributed training requires device_map=None ("auto" fails)
+ if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]:
+ model_init_kwargs["device_map"] = None
+ model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+ model = create_model_from_path(model, **model_init_kwargs)
+ else:
+ if args.model_init_kwargs is not None:
+ logger.warning(
+ "You passed `model_init_kwargs` to the `GRPOConfig`, but your model is already instantiated. "
+ "The `model_init_kwargs` will be ignored."
+ )
+ # Non-quantized models do not have the `is_loaded_in_{8,4}bit` attributes, whereas quantized models do
+ _is_quantized_model = getattr(model, "is_loaded_in_4bit", False) or getattr(model, "is_loaded_in_8bit", False)
+
+ # Some models (SmolVLM/Idefics3) don't support `logits_to_keep` argument and error out if we pass it
+ # Inspect the forward method before we wrap the model with PEFT
+ self.model_kwarg_keys = (
+ inspect.signature(model.forward).parameters.keys()
+ if not hasattr(model, "get_base_model")
+ else inspect.signature(model.get_base_model().forward).parameters.keys()
+ )
+
+ # Processing class
+ if processing_class is None:
+ processing_class = AutoProcessor.from_pretrained(
+ get_config_model_id(model.config),
+ truncation_side="left",
+ padding_side="left",
+ trust_remote_code=args.trust_remote_code,
+ )
+
+ if args.use_transformers_continuous_batching and isinstance(processing_class, ProcessorMixin):
+ raise ValueError(
+ "`use_transformers_continuous_batching` does not support multimodal models. Use `use_vllm` instead."
+ )
+
+ # Handle pad token for processors or tokenizers
+ if isinstance(processing_class, ProcessorMixin):
+ self._tokenizer = processing_class.tokenizer
+ self._is_vlm = True
+ elif isinstance(processing_class, PreTrainedTokenizerBase):
+ self._tokenizer = processing_class
+ self._is_vlm = False
+ else:
+ raise TypeError("The `processing_class` must be either a `PreTrainedTokenizerBase` or a `ProcessorMixin`")
+
+ if self._tokenizer.pad_token is None:
+ self._tokenizer.pad_token = self._tokenizer.eos_token
+
+ # Resolve vision placeholder token IDs once. Used by the forward pass to rebuild mm_token_type_ids
+ # when tool responses inject images into the completion (see _generate forward_kwargs block).
+ self._image_pad_token_id = None
+ self._video_pad_token_id = None
+ if self._is_vlm:
+ for candidate in ("<|image_pad|>", "<|image|>"):
+ tid = self._tokenizer.convert_tokens_to_ids(candidate)
+ if tid != self._tokenizer.unk_token_id:
+ self._image_pad_token_id = tid
+ break
+ tid = self._tokenizer.convert_tokens_to_ids("<|video_pad|>")
+ if tid != self._tokenizer.unk_token_id:
+ self._video_pad_token_id = tid
+
+ # PEFT
+ if peft_config is not None:
+ if not is_peft_available():
+ raise ImportError(
+ "You passed `peft_config` but the `peft` library is not installed. "
+ "Install it with `pip install trl[peft]`."
+ )
+ if not isinstance(peft_config, PeftConfig):
+ raise TypeError(
+ f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), "
+ f"got {type(peft_config).__name__}."
+ )
+ if is_peft_model(model):
+ raise ValueError(
+ "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first merge "
+ "and unload the existing adapter, save the resulting base model, and then pass that base model along "
+ "with the new `peft_config` to the trainer."
+ )
+ # Create PEFT model
+ # ZeRO-3 + PEFT for non-quantized models:
+ # - PEFT's default autocast_adapter_dtype=True upcasts LoRA adapter params to fp32 even when the base model is bf16.
+ # - ZeRO-3's _allgather_params_coalesced allocates output buffers using the dtype of the first persistent parameter,
+ # so mixed-dtype persistent_parameters (bf16 base + fp32 LoRA) cause a TypeError on the first optimizer step.
+ # - Passing autocast_adapter_dtype=False keeps adapter params in the base model dtype (bf16), fixing the mismatch.
+ # - This is safe: the fp32 upcast is a QLoRA-specific concern (low-bit quantized base models), not needed for
+ # non-quantized bf16 training.
+ # - See:
+ # - TRL issue: https://github.com/huggingface/trl/issues/6089
+ # - Upstream issue: https://github.com/deepspeedai/DeepSpeed/issues/8072
+ # - autocast_adapter_dtype was introduced in PEFT 0.12.0; before, no upcast existed: no need to pass the kwarg
+ get_peft_model_kwargs = {}
+ if (
+ args.deepspeed_plugin is not None
+ and args.deepspeed_plugin.zero_stage == 3
+ and not _is_quantized_model
+ and Version(peft.__version__) >= Version("0.12.0")
+ ):
+ get_peft_model_kwargs["autocast_adapter_dtype"] = False
+ model = get_peft_model(model, peft_config, **get_peft_model_kwargs)
+
+ elif is_peft_model(model) and args.beta != 0.0:
+ # If the model is a PEFT model with a pretrained adapter, we need to create a "ref" adapter that is a copy
+ # of the "default" adapter, so that we can use it as the reference model during GRPO training. PEFT only
+ # supports one adapter per model when the LoRA config uses `target_parameters` (see peft#3340), so in that
+ # case we skip the "ref" adapter and compute the reference log probs with adapters disabled, i.e. with the
+ # base model.
+ default_config = model.peft_config["default"]
+ if isinstance(default_config, LoraConfig) and default_config.target_parameters:
+ logger.warning(
+ "PEFT can't add a frozen reference adapter alongside one that uses `target_parameters` "
+ "(peft#3340), so the reference log probs are computed from the base model (adapters disabled). "
+ "If you wrapped the model only to apply LoRA, pass a `peft_config` to the trainer instead; if you "
+ "wrapped it deliberately (pretrained adapter or custom init), note that the base model matches "
+ "your adapter only when it's freshly zero-initialized. If it is, this warning is safe to ignore."
+ )
+ else:
+ model.add_adapter("ref", default_config)
+ for name, param in model.named_parameters():
+ if ".default." in name:
+ ref_name = name.replace(".default.", ".ref.")
+ ref_param = model.get_parameter(ref_name)
+ ref_param.data.copy_(param.data)
+
+ # When using gradient checkpointing with PEFT, we need to enable input gradients. transformers.Trainer normally
+ # handles this, but a bug currently prevents it; see https://github.com/huggingface/transformers/issues/42489
+ if is_peft_model(model) and args.gradient_checkpointing:
+ model.enable_input_require_grads()
+
+ # When using QLoRA, the PEFT adapter weights are converted to bf16 to follow the recommendations from the
+ # original paper (see https://huggingface.co/papers/2305.14314, paragraph 3). Normally, this can be done by
+ # passing `autocast_adapter_dtype=False` to `get_peft_model`, but this option is not yet supported for
+ # quantized models. See: https://github.com/huggingface/peft/issues/2889
+ if _is_quantized_model:
+ for param in model.parameters():
+ if param.requires_grad:
+ param.data = param.data.to(torch.bfloat16)
+
+ # Reward functions
+ if not isinstance(reward_funcs, list):
+ reward_funcs = [reward_funcs]
+ self.reward_func_names = []
+ for i, reward_func in enumerate(reward_funcs):
+ if isinstance(reward_func, str):
+ model_init_kwargs = args.model_init_kwargs or {}
+ # Distributed training requires device_map=None ("auto" fails)
+ if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]:
+ model_init_kwargs["device_map"] = None
+ model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+ reward_funcs[i] = AutoModelForSequenceClassification.from_pretrained(
+ reward_func, num_labels=1, **model_init_kwargs
+ )
+ if isinstance(reward_funcs[i], nn.Module): # Use Module over PretrainedModel for compat w/ compiled models
+ self.reward_func_names.append(get_config_model_id(reward_funcs[i].config).split("/")[-1])
+ else:
+ self.reward_func_names.append(reward_funcs[i].__name__)
+ self.reward_funcs = reward_funcs
+
+ # Reward weights
+ if args.reward_weights is not None:
+ if len(args.reward_weights) != len(reward_funcs):
+ raise ValueError(
+ f"Number of reward weights ({len(args.reward_weights)}) must match number of reward "
+ f"functions ({len(reward_funcs)})"
+ )
+ self.reward_weights = torch.tensor(args.reward_weights, dtype=torch.float32)
+ else:
+ self.reward_weights = torch.ones(len(reward_funcs), dtype=torch.float32)
+
+ # Reward processing class
+ if reward_processing_classes is None:
+ reward_processing_classes = [None] * len(reward_funcs)
+ elif not isinstance(reward_processing_classes, list):
+ reward_processing_classes = [reward_processing_classes]
+ if len(reward_processing_classes) != len(reward_funcs):
+ raise ValueError(
+ f"The number of reward processing classes ({len(reward_processing_classes)}) must match the number of "
+ f"reward functions ({len(reward_funcs)})."
+ )
+
+ for i, (reward_processing_class, reward_func) in enumerate(
+ zip(reward_processing_classes, reward_funcs, strict=True)
+ ):
+ if isinstance(reward_func, PreTrainedModel):
+ if reward_processing_class is None:
+ reward_processing_class = AutoTokenizer.from_pretrained(
+ get_config_model_id(reward_func.config), trust_remote_code=args.trust_remote_code
+ )
+ if reward_processing_class.pad_token_id is None:
+ reward_processing_class.pad_token = reward_processing_class.eos_token
+ # The reward model computes the reward for the latest non-padded token in the input sequence.
+ # So it's important to set the pad token ID to the padding token ID of the processing class.
+ reward_func.config.pad_token_id = reward_processing_class.pad_token_id
+ reward_processing_classes[i] = reward_processing_class
+
+ self.reward_processing_classes = reward_processing_classes
+
+ # Rollout function
+ if rollout_func is not None and os.environ.get("TRL_EXPERIMENTAL_SILENCE", "0") != "1":
+ warnings.warn(
+ "You are using 'rollout_func', which is an experimental feature. This API may change or be removed at "
+ "any time without prior notice. Silence this warning by setting environment variable "
+ "TRL_EXPERIMENTAL_SILENCE=1.",
+ UserWarning,
+ stacklevel=2,
+ )
+ self.rollout_func = rollout_func
+ if environment_factory is not None and os.environ.get("TRL_EXPERIMENTAL_SILENCE", "0") != "1":
+ warnings.warn(
+ "You are using 'environment_factory', which is an experimental feature. This API may change or be "
+ "removed at any time without prior notice. Silence this warning by setting environment variable "
+ "TRL_EXPERIMENTAL_SILENCE=1.",
+ UserWarning,
+ stacklevel=2,
+ )
+
+ # Tools
+ if tools:
+ if not Version(transformers.__version__) >= Version("5.0.0"):
+ raise ImportError(
+ "Using tools with GRPOTrainer requires transformers version 5.0.0 or higher. Please upgrade "
+ "transformers with `pip install --upgrade transformers` to use this feature."
+ )
+ if environment_factory:
+ if not Version(transformers.__version__) >= Version("5.2.0"):
+ raise ImportError(
+ "Using `environment_factory` with GRPOTrainer requires transformers version 5.2.0 or higher. "
+ "Please install transformers from the main branch with `pip install "
+ "git+https://github.com/huggingface/transformers.git@main` to use this feature."
+ )
+ if tools or environment_factory:
+ if not is_jmespath_available():
+ raise ImportError(
+ "Using tools with GRPOTrainer requires the jmespath library for response parsing. Please install "
+ "it with `pip install jmespath` to use this feature."
+ )
+ if not supports_tool_calling(processing_class):
+ raise ValueError(
+ "The provided chat template does not support tool calling. The template must be able to render a "
+ "full tool-calling conversation (user -> assistant with tool_calls -> tool)."
+ )
+
+ # Create the environments and extract their methods to be used as tools. We create one environment per rollout
+ generation_batch_size = args.per_device_train_batch_size * args.steps_per_generation
+ if environment_factory is not None:
+ self.environments = [environment_factory() for _ in range(generation_batch_size)]
+ environment_methods = [[] for _ in range(generation_batch_size)]
+ for i, environment in enumerate(self.environments):
+ has_reset = False
+ for name, member in inspect.getmembers(environment, predicate=inspect.ismethod):
+ if name == "reset":
+ has_reset = True
+ elif not name.startswith("_"):
+ environment_methods[i].append(member)
+ if not has_reset:
+ raise ValueError(
+ "Each environment instance returned by `environment_factory` must define a callable `reset` "
+ )
+ else:
+ self.environments = None
+
+ tools = tools or []
+ self._sync_tool_dicts = [{} for _ in range(generation_batch_size)]
+ self._async_tool_dicts = [{} for _ in range(generation_batch_size)]
+ for i in range(generation_batch_size):
+ for tool in tools + (environment_methods[i] if self.environments is not None else []):
+ if inspect.iscoroutinefunction(tool):
+ self._async_tool_dicts[i][tool.__name__] = tool
+ else:
+ self._sync_tool_dicts[i][tool.__name__] = tool
+
+ self.tools = tools + (environment_methods[0] if self.environments is not None else [])
+
+ # Check for async functions to start an event loop on a daemon thread
+ self._has_async_funcs = any(inspect.iscoroutinefunction(func) for func in self.reward_funcs + self.tools)
+
+ if self._has_async_funcs:
+ self.async_loop_thread, self.async_loop, self.async_loop_ready_event = start_event_loop_in_daemon(
+ name="GRPOTrainer-AsyncLoop"
+ )
+ # wait until the event loop is running in the daemon thread
+ self.async_loop_ready_event.wait()
+ atexit.register(shutdown_event_loop_in_daemon, self.async_loop_thread, self.async_loop)
+
+ # At the time of initial implementation, most tokenizers do not have built-in support for response schemas.
+ # While waiting for broader adoption, we provide this utility function to manually set the response schema for
+ # known chat templates. `response_schema` lives on the (inner) tokenizer, since `parse_response` is a tokenizer
+ # method that reads `self.response_schema`.
+ if self.tools and getattr(self._tokenizer, "response_schema", None) is None:
+ processing_class = add_response_schema(processing_class)
+ # In multi-turn training, the chat template *must* be prefix-preserving. If the tokenizer's original template
+ # isn't, we replace it at initialization with a training-safe, prefix-preserving template.
+ if self.tools and not is_chat_template_prefix_preserving(processing_class):
+ self.chat_template = get_training_chat_template(processing_class)
+ else:
+ self.chat_template = None
+
+ # Training arguments
+ self.max_completion_length = args.max_completion_length # = |o_i| in the GRPO paper
+ self.num_generations = args.num_generations # = G in the GRPO paper
+ self.max_tool_calling_iterations = args.max_tool_calling_iterations or sys.maxsize
+ self.num_generations_eval = args.num_generations_eval or self.num_generations
+ self.chat_template_kwargs = args.chat_template_kwargs or {}
+ self.temperature = args.temperature
+ self.top_p = args.top_p
+ self.top_k = args.top_k
+ self.min_p = args.min_p
+ self.repetition_penalty = args.repetition_penalty
+ self.use_transformers_continuous_batching = args.use_transformers_continuous_batching
+ if self.use_transformers_continuous_batching:
+ if not Version(transformers.__version__) >= Version("5.8.0"):
+ raise ImportError(
+ "Using `use_transformers_continuous_batching` requires transformers>=5.8.0. "
+ "Please upgrade with `pip install --upgrade transformers`."
+ )
+ from transformers.generation import ContinuousBatchingConfig
+
+ cb_kwargs = dict(args.transformers_continuous_batching_config or {})
+ # The transformers default (0.9) leaves almost no VRAM for the training backward pass;
+ # use a training-aware default unless the user has set it explicitly.
+ cb_kwargs.setdefault("max_memory_percent", 0.5)
+ self.continuous_batching_config = ContinuousBatchingConfig(**cb_kwargs)
+ else:
+ self.continuous_batching_config = None
+ self.pad_to_multiple_of = args.pad_to_multiple_of
+ self.use_vllm = args.use_vllm
+ self.vllm_mode = args.vllm_mode
+ self.vllm_gpu_memory_utilization = args.vllm_gpu_memory_utilization # only applies to colocation mode
+ self.vllm_tensor_parallel_size = args.vllm_tensor_parallel_size # only applies to colocation mode
+ self.vllm_importance_sampling_correction = args.vllm_importance_sampling_correction
+ self.vllm_importance_sampling_mode = args.vllm_importance_sampling_mode
+ self.vllm_importance_sampling_clip_max = args.vllm_importance_sampling_clip_max
+ self.vllm_importance_sampling_clip_min = args.vllm_importance_sampling_clip_min
+ self.use_liger_kernel = args.use_liger_kernel
+ self.loss_type = args.loss_type
+ self.multi_objective_aggregation = args.multi_objective_aggregation
+
+ # MoE load-balancing auxiliary loss, applied to Mixture-of-Experts models (no effect otherwise)
+ text_config = model.config.get_text_config()
+ is_moe = getattr(text_config, "output_router_logits", None) is not None
+ self.aux_loss_enabled = is_moe and args.router_aux_loss_coef != 0.0
+ self.router_aux_loss_coef = args.router_aux_loss_coef
+ self.scale_rewards = args.scale_rewards
+ self.importance_sampling_level = args.importance_sampling_level
+ self.off_policy_mask_threshold = args.off_policy_mask_threshold
+ if self.use_liger_kernel and self.off_policy_mask_threshold is not None:
+ raise ValueError("Liger kernel does not support off-policy sequence masking yet.")
+ if self.use_liger_kernel and is_peft_model(model):
+ # The Liger fused GRPO loss multiplies the hidden states by `lm_head.weight` directly. When the LM head is
+ # targeted by a PEFT adapter (`"lm_head"` in `target_modules`), `lm_head.weight` is the frozen base weight
+ # and the trainable adapter parameters live in separate submodules that Liger never sees. The head adapter
+ # would silently receive no gradient, so the model trains as if `lm_head` were frozen. Fail loudly rather
+ # than train a silently-frozen head.
+ output_embeddings = model.get_output_embeddings()
+ if isinstance(output_embeddings, BaseTunerLayer):
+ raise ValueError(
+ "`use_liger_kernel=True` is incompatible with applying a PEFT adapter to `lm_head`. The Liger "
+ "fused GRPO loss reads `lm_head.weight` directly, so the adapter on the head is ignored and never "
+ "trained. Either remove `'lm_head'` from your `target_modules`, or set `use_liger_kernel=False`."
+ )
+ self.mask_truncated_completions = args.mask_truncated_completions
+ self.top_entropy_quantile = args.top_entropy_quantile
+ if self.use_liger_kernel and self.top_entropy_quantile < 1.0:
+ raise NotImplementedError(
+ "Liger Kernels don't currently support masking token positions based on entropy."
+ )
+ if self.use_liger_kernel and self.importance_sampling_level not in ("token", "sequence"):
+ raise ValueError(
+ f"Unknown importance sampling level: {self.importance_sampling_level}. "
+ "Possible values are 'token' and 'sequence'."
+ )
+
+ # Datasets
+ self.shuffle_dataset = args.shuffle_dataset
+
+ if train_dataset is None:
+ raise ValueError("`train_dataset` is required")
+ elif (
+ isinstance(train_dataset, IterableDataset)
+ or isinstance(eval_dataset, IterableDataset)
+ or (
+ isinstance(eval_dataset, dict) and any(isinstance(ds, IterableDataset) for ds in eval_dataset.values())
+ )
+ ):
+ # See https://github.com/huggingface/trl/issues/3213
+ raise NotImplementedError(
+ "Iterable datasets are not yet supported in GRPOTrainer. Please use a standard dataset instead."
+ )
+
+ if args.loss_type == "luspo" and args.importance_sampling_level != "sequence":
+ logger.warning(
+ "When using `'luspo'` loss, `importance_sampling_level` should be set to `'sequence'` to mirror the "
+ "paper's setup."
+ )
+
+ if args.loss_type == "vespo" and args.importance_sampling_level != "token":
+ logger.warning(
+ "VESPO computes sequence-level importance weights internally. `importance_sampling_level` should be "
+ "set to `'token'` (the default)."
+ )
+
+ if self.loss_type == "vespo" and self.use_vllm and self.vllm_importance_sampling_correction:
+ if self.vllm_importance_sampling_mode not in ["token_truncate", "token_mask"]:
+ raise ValueError(
+ f"VESPO loss requires `vllm_importance_sampling_mode` to be either 'token_truncate' or "
+ f"'token_mask'. Got: {self.vllm_importance_sampling_mode}."
+ )
+
+ # Multi-step
+ self.num_iterations = args.num_iterations # = 𝜇 in the GRPO paper
+ self.epsilon_low = args.epsilon
+ self.epsilon_high = args.epsilon_high if args.epsilon_high is not None else args.epsilon
+ # Tracks the number of iterations (forward + backward passes), including those within a grad accum cycle
+ self._step = 0
+ # Buffer the batch to reuse generated outputs across multiple updates. For more details, see
+ # `_get_train_sampler` and `_prepare_inputs`.
+ self._buffered_inputs = None
+
+ # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was
+ # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream
+ # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we
+ # default to the recommended non-reentrant behavior here, while preserving any user-provided value.
+ if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"):
+ args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {}
+ args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False)
+
+ super().__init__(
+ model=model,
+ args=args,
+ data_collator=identity, # No data collation is needed in GRPO
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=processing_class,
+ callbacks=callbacks,
+ optimizers=optimizers,
+ # In Trainer, `training_step` scales the loss by `gradient_accumulation_steps` only if `compute_loss_func`
+ # is None. For DAPO, loss scaling instead depends on the total number of completions tokens across the
+ # global accumulated batch. To control scaling ourselves, we must disable Trainer’s built-in scaling. The
+ # simplest (though a bit hacky) way is to set `compute_loss_func` to any non-None value, which bypasses
+ # that behavior without rewriting `training_step`.
+ compute_loss_func="non-None value to disable scaling",
+ )
+
+ # Reference model
+ self.beta = args.beta
+ if self.beta == 0.0:
+ # If beta is 0.0, the reference model is not needed
+ self.ref_model = None
+ elif is_peft_model(model):
+ # If PEFT is used, the reference model is not needed since the adapter can be disabled
+ # to revert to the initial model.
+ self.ref_model = None
+ else:
+ # For deepspeed, fsdp or non-distributed models, create a reference model from scratch
+ model_init_kwargs = args.model_init_kwargs or {}
+ # Distributed training requires device_map=None ("auto" fails)
+ if self.args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]:
+ model_init_kwargs["device_map"] = None
+ model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+ self.ref_model = create_model_from_path(get_config_model_id(self.model.config), **model_init_kwargs)
+
+ # Disable dropout in the models
+ if args.disable_dropout:
+ disable_dropout_in_model(model)
+ if self.ref_model is not None:
+ disable_dropout_in_model(self.ref_model)
+
+ # Cast LM Head To FP32
+ if args.cast_lm_head_to_fp32:
+
+ def _cast_lm_head_to_fp32(target_model: PreTrainedModel):
+ """Cast lm_head to fp32 while preserving embedding output dtype if tied."""
+
+ def cast_inputs_to_fp32(module, inputs):
+ # Preserve other positional args and kwargs untouched
+ if not inputs:
+ return inputs
+ return (inputs[0].to(torch.float32),) + inputs[1:]
+
+ original_dtype_local = target_model.lm_head.weight.dtype
+ target_model.lm_head = target_model.lm_head.float()
+ target_model.lm_head.register_forward_pre_hook(cast_inputs_to_fp32)
+
+ if target_model.config.tie_word_embeddings:
+
+ def cast_outputs_to_original_dtype(module, args, output):
+ return output.to(original_dtype_local)
+
+ # Only cast activations; weights are now fp32 (intentional for numerical stability of logits)
+ target_model.model.embed_tokens.register_forward_hook(cast_outputs_to_original_dtype)
+
+ _cast_lm_head_to_fp32(model)
+ if self.ref_model is not None:
+ _cast_lm_head_to_fp32(self.ref_model)
+
+ # Liger loss
+ if self.use_liger_kernel:
+ if not is_liger_kernel_available():
+ raise ImportError(
+ "Liger is required to use `use_liger_kernel` as the GRPO loss. Run `pip install liger-kernel`."
+ )
+ # redirect the model.module forward to the model forward to ensure pre-forward hooks are called
+ self._forward_redirection = _ForwardRedirection()
+
+ self.liger_grpo_loss = LigerFusedLinearGRPOLoss(
+ beta=self.beta,
+ epsilon_low=self.epsilon_low,
+ epsilon_high=self.epsilon_high,
+ temperature=self.temperature,
+ use_ref_model=self.beta != 0.0,
+ loss_type=self.loss_type,
+ max_completion_length=self.max_completion_length,
+ importance_sampling_level=self.importance_sampling_level,
+ delta=args.delta,
+ use_bias_correction_kl=args.use_bias_correction_kl,
+ sapo_temperature_pos=args.sapo_temperature_pos,
+ sapo_temperature_neg=args.sapo_temperature_neg,
+ vespo_k_pos=args.vespo_k_pos,
+ vespo_lambda_pos=args.vespo_lambda_pos,
+ vespo_k_neg=args.vespo_k_neg,
+ vespo_lambda_neg=args.vespo_lambda_neg,
+ )
+
+ # Initialize the metrics
+ self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)}
+ self._total_train_tokens = 0
+ self._current_train_step_time = 0.0
+ self.log_completions = args.log_completions
+ self.log_unique_prompts = args.log_unique_prompts
+ self.num_completions_to_print = args.num_completions_to_print
+ # Keep logs sized to the generation batch to record only outputs from the latest model update.
+ self._logs = {
+ "images": deque(maxlen=args.generation_batch_size),
+ "prompt": deque(maxlen=args.generation_batch_size),
+ "completion": deque(maxlen=args.generation_batch_size),
+ "rewards": defaultdict(lambda: deque(maxlen=args.generation_batch_size)),
+ "advantages": deque(maxlen=args.generation_batch_size),
+ "extra": defaultdict(lambda: deque(maxlen=args.generation_batch_size)),
+ }
+ # Buffers for user-logged data from reward functions, flushed after gathering
+ self._pending_extra_logs = defaultdict(list)
+ self._pending_metrics = defaultdict(list)
+
+ # Ensure each process receives a unique seed to prevent duplicate completions when generating with
+ # transformers if num_generations exceeds per_device_train_batch_size. We could skip it if we use vLLM, but
+ # it's safer to set it in all cases.
+ set_seed(args.seed, device_specific=True)
+
+ if self.use_vllm:
+ # Initialize vLLM generation backend
+ self.vllm_generation = VLLMGeneration(
+ model=self.model,
+ accelerator=self.accelerator,
+ processing_class=self.processing_class,
+ # vLLM configuration
+ mode=args.vllm_mode,
+ structured_outputs_regex=args.vllm_structured_outputs_regex,
+ # Server mode configuration
+ server_base_url=args.vllm_server_base_url,
+ server_host=args.vllm_server_host,
+ server_port=args.vllm_server_port,
+ group_port=args.vllm_group_port,
+ server_timeout=args.vllm_server_timeout,
+ # Colocate mode configuration
+ tensor_parallel_size=args.vllm_tensor_parallel_size,
+ gpu_memory_utilization=args.vllm_gpu_memory_utilization,
+ max_model_length=args.vllm_max_model_length,
+ max_num_seqs=args.per_device_train_batch_size
+ * args.vllm_tensor_parallel_size
+ * args.steps_per_generation,
+ enable_sleep_mode=args.vllm_enable_sleep_mode,
+ model_impl=args.vllm_model_impl,
+ # Generation configuration
+ repetition_penalty=self.repetition_penalty,
+ temperature=self.temperature,
+ top_p=self.top_p,
+ top_k=self.top_k,
+ min_p=self.min_p,
+ max_completion_length=self.max_completion_length,
+ logprobs=0, # we only need the generated token logprobs for the importance sampling correction
+ generation_kwargs=args.generation_kwargs,
+ )
+ self._last_loaded_step = -1 # tag to avoid useless loading during grad accumulation
+ else:
+ generation_kwargs = {
+ "max_new_tokens": self.max_completion_length,
+ "do_sample": True,
+ "pad_token_id": self._tokenizer.pad_token_id,
+ "bos_token_id": self._tokenizer.bos_token_id,
+ "eos_token_id": self._tokenizer.eos_token_id,
+ "temperature": self.temperature,
+ "top_p": self.top_p,
+ "top_k": self.top_k,
+ "min_p": self.min_p,
+ "repetition_penalty": self.repetition_penalty,
+ "cache_implementation": args.cache_implementation,
+ }
+ if args.generation_kwargs is not None:
+ generation_kwargs.update(args.generation_kwargs)
+ self.generation_config = GenerationConfig(**generation_kwargs, disable_compile=True)
+ # Keep training-specific generation kwargs to overwrite model's original generation config
+ self.generation_kwargs = generation_kwargs
+
+ # Gradient accumulation requires scaled loss. Normally, loss scaling in the parent class depends on whether the
+ # model accepts loss-related kwargs. Since we compute our own loss, this check is irrelevant. We set
+ # self.model_accepts_loss_kwargs to False to enable scaling.
+ self.model_accepts_loss_kwargs = False
+ self._dist = DistributedBackend(self.accelerator)
+
+ # Add tags to the model
+ self.model.add_model_tags(self._tag_names)
+
+ if self.ref_model is not None:
+ if self.is_deepspeed_enabled:
+ self.ref_model = prepare_deepspeed(self.ref_model, self.accelerator)
+ elif self.is_fsdp_enabled:
+ self.ref_model = prepare_fsdp(self.ref_model, self.accelerator)
+ else:
+ self.ref_model = self.accelerator.prepare_model(self.ref_model, evaluation_mode=True)
+
+ if args.sync_ref_model:
+ if self.beta == 0.0:
+ raise ValueError(
+ "You passed `sync_ref_model=True` while `beta=0.0`, which means the reference model is not used "
+ "during training. Consequently, GRPOTrainer does not create a `ref_model` instance, and there is "
+ "nothing to synchronize. Please set `sync_ref_model=False`, or set `beta` to a non-zero value."
+ )
+ if is_peft_model(model):
+ raise NotImplementedError(
+ "You passed `sync_ref_model=True` while using a PEFT model, which is currently not supported. "
+ "With PEFT, GRPOTrainer does not keep a separate reference model in memory; instead, it recovers "
+ "reference behavior by temporarily disabling the adapter. As a result, there is no standalone "
+ "`ref_model` instance to synchronize. Use `sync_ref_model=False`, or opt for full fine-tuning if "
+ "you need a synced reference model. If you need `sync_ref_model` to work with PEFT, please open a "
+ "feature request at https://github.com/huggingface/trl/issues."
+ )
+ self.add_callback(SyncRefModelCallback(ref_model=self.ref_model, accelerator=self.accelerator))
+
+ for i, reward_func in enumerate(self.reward_funcs):
+ if isinstance(reward_func, PreTrainedModel):
+ if self.is_deepspeed_enabled:
+ self.reward_funcs[i] = prepare_deepspeed(reward_func, self.accelerator)
+ else:
+ # set device placement to True to make `prepare_model` move `reward_func` to device when using fsdp
+ self.reward_funcs[i] = self.accelerator.prepare_model(
+ reward_func, evaluation_mode=True, device_placement=True
+ )
+
+ if self.accelerator.is_main_process and self.log_completions:
+ os.makedirs(os.path.join(self.args.output_dir, "completions"), exist_ok=True)
+ if self.args.log_completions_hub_repo is not None:
+ repo_id = self.args.log_completions_hub_repo
+ create_repo(repo_id, private=self.args.hub_private_repo, repo_type="dataset", exist_ok=True)
+ template_path = pkg_resources.files("trl").joinpath("templates/completions_dataset_card.md")
+ card_data = DatasetCardData(
+ pretty_name="TRL Completion logs",
+ tags=["trl", "trl-logs", "completions"],
+ )
+ card = DatasetCard.from_template(
+ card_data=card_data,
+ template_path=str(template_path),
+ repo_id=repo_id,
+ hub_model_id=self.args.hub_model_id,
+ )
+ card.push_to_hub(repo_id)
+ self.commit_scheduler = CommitScheduler(
+ repo_id=repo_id,
+ repo_type="dataset",
+ folder_path=f"{self.args.output_dir}/completions",
+ every=2, # minutes
+ allow_patterns=["*.parquet"],
+ )
+
+ def _set_signature_columns_if_needed(self):
+ # If `self.args.remove_unused_columns` is True, non-signature columns are removed.
+ # By default, this method sets `self._signature_columns` to the model's expected inputs (usually, "input_ids"
+ # and "attention_mask"). In GRPOTrainer, we preprocess data, so using the model's signature columns doesn't
+ # work. Instead, we set them to the columns expected by the `training_step` method, hence the override.
+ if self._signature_columns is None:
+ self._signature_columns = ["prompt", "image", "images"]
+
+ # This method overrides `Trainer.get_train_dataloader` to support our custom batching strategy.
+ # Instead of returning a standard per-step batch (i.e., `per_device_batch_size), our dataloader loads an
+ # *generation* batch (i.e., `per_device_batch_size × steps_per_generation`). This allows us to generate completions
+ # once every steps_per_generation step—rather than once per accumulation step—which is significantly more
+ # efficient. The only change from the original implementation is multiplying the batch size by
+ # `steps_per_generation`. Thus, `_prepare_inputs` is called with this *generation* batch, and it handles the
+ # splitting internally.
+ # Maintenance note: This method is a copy-paste of the original `Trainer.get_train_dataloader` with only one line
+ # modification.
+ def get_train_dataloader(self):
+ return self._get_dataloader(
+ dataset=self.train_dataset,
+ description="Training",
+ batch_size=self._train_batch_size * self.args.steps_per_generation, # < this is the change
+ sampler_fn=self._get_train_sampler,
+ is_training=True,
+ )
+
+ def _get_train_sampler(self, dataset: Dataset | None = None) -> Sampler:
+ # Returns a sampler that
+ # 1. ensures each prompt is repeated across multiple processes. This guarantees that identical prompts are
+ # distributed to different GPUs, allowing rewards to be computed and normalized correctly within each prompt
+ # group. Using the same seed across processes ensures consistent prompt assignment, preventing discrepancies
+ # in group formation.
+ # 2. repeats the batch multiple times to allow reusing generations across multiple updates. Refer to
+ # _prepare_inputs to see how the generations are stored and reused.
+
+ # In the following figure, the values are the prompt indices. The first row shows the first sampled batch, the
+ # second row shows the second sampled batch, and so on.
+ #
+ # | GPU 0 | GPU 1 |
+ #
+ # global_step step <-───> num_generations=2
+ # <-───────> per_device_train_batch_size=3
+ # grad_accum ▲ ▲ 0 0 0 0 1 1 2 2 <- Generate for the first `steps_per_generation` (prompts 0 to 11); store the completions; use the first slice to compute the loss
+ # =2 ▼ | 0 1 3 3 4 4 5 5 <- Take the stored generations and use the second slice to compute the loss
+ # |
+ # | 1 2 6 6 7 7 8 8 <- Take the stored generations and use the third slice to compute the loss
+ # steps_per_gen=4 ▼ 1 3 9 9 10 10 11 11 <- Take the stored generations and use the fourth slice to compute the loss
+ #
+ # 2 4 12 12 13 13 14 14 <- Generate for the second `steps_per_generation` (prompts 12 to 23); store the completions; use the first slice to compute the loss
+ # 2 5 15 15 16 16 17 17 <- Take the stored generations and use the second slice to compute the loss
+ # ...
+ if dataset is None:
+ dataset = self.train_dataset
+ return RepeatSampler(
+ data_source=dataset,
+ mini_repeat_count=self.num_generations,
+ batch_size=self.args.generation_batch_size // self.num_generations,
+ repeat_count=self.num_iterations * self.args.steps_per_generation,
+ shuffle=self.shuffle_dataset,
+ seed=self.args.seed,
+ )
+
+ def _get_eval_sampler(self, eval_dataset) -> Sampler:
+ # See _get_train_sampler for an explanation of the sampler.
+ return RepeatSampler(
+ data_source=eval_dataset,
+ mini_repeat_count=self.num_generations_eval,
+ seed=self.args.seed,
+ )
+
+ @profiling_decorator
+ def _get_last_hidden_state(
+ self,
+ unwrapped_model,
+ input_ids,
+ attention_mask,
+ logits_to_keep,
+ pixel_values=None,
+ image_grid_thw=None,
+ pixel_attention_mask=None,
+ image_sizes=None,
+ image_position_ids=None,
+ ):
+ if is_peft_model(unwrapped_model):
+ unwrapped_model = unwrapped_model.base_model.model
+
+ # Build model inputs - check if the model supports logits_to_keep (some models and VLMs don't)
+ model_inputs = {"input_ids": input_ids, "attention_mask": attention_mask}
+
+ # For Qwen models:
+ if image_grid_thw is not None and pixel_values is not None:
+ model_inputs["image_grid_thw"] = image_grid_thw
+ # For Gemma, SmolVLM2, LLaVa-Next etc.:
+ if pixel_values is not None:
+ model_inputs["pixel_values"] = pixel_values
+ # For SmolVLM2
+ if pixel_attention_mask is not None:
+ model_inputs["pixel_attention_mask"] = pixel_attention_mask
+ # For LLaVa-Next
+ if image_sizes is not None:
+ model_inputs["image_sizes"] = image_sizes
+ if image_position_ids is not None:
+ model_inputs["image_position_ids"] = image_position_ids
+
+ # Only add logits_to_keep if the model supports it
+ if "logits_to_keep" in self.model_kwarg_keys:
+ # We add 1 to `logits_to_keep` because the last logits of the sequence is later excluded
+ model_inputs["logits_to_keep"] = logits_to_keep + 1
+
+ model_inputs["use_cache"] = False # only used in generation; set False to suppress warnings
+
+ # `base_model` gives the backbone model (skipping `lm_head`) — text decoder for LMs, multimodal wrapper for
+ # VLMs (so vision-token injection runs before the text decoder). `get_decoder()` won't do: on VLMs it
+ # returns just the text stack and feeds image-placeholder IDs through it.
+ # Pre-5.0 transformers VLMs set `base_model_prefix = ""` so `base_model is self` (re-runs `lm_head`).
+ # Fall back to `.model` there.
+ if self._is_vlm and Version(transformers.__version__) < Version("5.0.0"):
+ backbone = unwrapped_model.model
+ else:
+ backbone = unwrapped_model.base_model
+ last_hidden_state = backbone(**model_inputs).last_hidden_state
+ # Exclude the last value: it corresponds to the next token pred
+ last_hidden_state = last_hidden_state[:, :-1, :] # (B, L-1, H)
+ # Only keep the last logits_to_keep. For model that support logits_to_keep, this is a no-op.
+ last_hidden_state = last_hidden_state[:, -logits_to_keep:, :] # (B, logits_to_keep, H)
+ return last_hidden_state
+
+ def get_high_entropy_mask(self, entropies: torch.Tensor, mask: torch.Tensor, threshold: float) -> torch.Tensor:
+ """
+ Returns a binary mask identifying tokens whose entropy exceeds a given quantile threshold.
+
+ Args:
+ entropies (`torch.Tensor`):
+ Tensor of shape (batch_size, seq_len) with per-token entropy values.
+ mask (`torch.Tensor`):
+ Binary mask of the same shape as `entropies`, where `1` indicates valid tokens and `0` padding.
+ threshold (`float`):
+ Quantile threshold between `0.0` and `1.0` to select high-entropy tokens.
+
+ Returns:
+ `torch.Tensor`:
+ Boolean mask of shape (batch_size, seq_len), where `True` indicates tokens with entropy >= threshold
+ and `False` otherwise.
+ """
+ local = entropies[mask.bool()].float()
+
+ # Use a negative pad_value as a sentinel because entropy values are always >= 0.
+ # This guarantees that the sentinel cannot collide with any real entropy value.
+ pad_value = -1e9
+
+ # Pad across processes so that every rank has the same tensor length
+ padded = self.accelerator.pad_across_processes(local, dim=0, pad_index=pad_value)
+ gathered = self.accelerator.gather(padded)
+
+ # Drop sentinel values (safe because no entropy can be negative)
+ gathered = gathered[gathered != pad_value]
+
+ if gathered.numel() == 0:
+ return torch.zeros_like(entropies, dtype=torch.bool)
+
+ entropy_threshold = torch.quantile(gathered, threshold)
+ masked_entropies = entropies * mask.float()
+ entropy_mask = masked_entropies >= entropy_threshold
+ return entropy_mask & mask.bool() # ensure padding tokens are always masked out
+
+ @profiling_decorator
+ def _get_per_token_logps_and_entropies(
+ self,
+ model,
+ input_ids,
+ attention_mask,
+ logits_to_keep,
+ batch_size=None,
+ compute_entropy=False,
+ compute_aux_loss=False,
+ pixel_values=None,
+ image_grid_thw=None,
+ num_images=None,
+ pixel_attention_mask=None,
+ image_sizes=None,
+ token_type_ids=None,
+ mm_token_type_ids=None,
+ image_position_ids=None,
+ ) -> tuple[torch.Tensor, torch.Tensor | None, torch.Tensor | None]:
+ """Compute log-probs, (optionally) entropies, and (optionally) the MoE load-balancing aux loss."""
+ batch_size = batch_size or input_ids.size(0) # Chunk inputs into smaller batches to reduce memory peak
+ all_logps = []
+ all_entropies = []
+ all_aux_losses = []
+ for start in range(0, input_ids.size(0), batch_size):
+ input_ids_batch = input_ids[start : start + batch_size]
+ attention_mask_batch = attention_mask[start : start + batch_size]
+
+ # Build model inputs
+ model_inputs = {"input_ids": input_ids_batch, "attention_mask": attention_mask_batch}
+ if image_grid_thw is not None and pixel_values is not None:
+ rows_per_image = image_grid_thw.prod(dim=-1)
+ rows_per_sample = torch.split(rows_per_image, num_images)
+ rows_per_sample = torch.stack([s.sum() for s in rows_per_sample])
+ cum_rows = torch.cat([torch.tensor([0], device=rows_per_sample.device), rows_per_sample.cumsum(0)])
+ row_start, row_end = cum_rows[start].item(), cum_rows[start + batch_size].item()
+ model_inputs["pixel_values"] = pixel_values[row_start:row_end]
+ cum_imgs = torch.tensor([0] + num_images).cumsum(0)
+ img_start, img_end = cum_imgs[start], cum_imgs[start + batch_size]
+ model_inputs["image_grid_thw"] = image_grid_thw[img_start:img_end]
+ elif image_position_ids is not None and pixel_values is not None:
+ cum_imgs = torch.tensor([0] + num_images).cumsum(0)
+ img_start, img_end = cum_imgs[start], cum_imgs[start + batch_size]
+ model_inputs["pixel_values"] = pixel_values[img_start:img_end]
+ model_inputs["image_position_ids"] = image_position_ids[img_start:img_end]
+ elif pixel_values is not None:
+ model_inputs["pixel_values"] = pixel_values[start : start + batch_size]
+ if pixel_attention_mask is not None:
+ model_inputs["pixel_attention_mask"] = pixel_attention_mask[start : start + batch_size]
+ if image_sizes is not None:
+ model_inputs["image_sizes"] = image_sizes[start : start + batch_size]
+ if token_type_ids is not None:
+ model_inputs["token_type_ids"] = token_type_ids[start : start + batch_size]
+ if mm_token_type_ids is not None:
+ model_inputs["mm_token_type_ids"] = mm_token_type_ids[start : start + batch_size]
+
+ # Only add logits_to_keep if the model supports it
+ if "logits_to_keep" in self.model_kwarg_keys:
+ # We add 1 to `logits_to_keep` because the last logits of the sequence is later excluded
+ model_inputs["logits_to_keep"] = logits_to_keep + 1
+
+ model_inputs["use_cache"] = False # only used in generation; set False to suppress warnings
+
+ # MoE models: request router logits so the model returns `outputs.aux_loss`. VLM wrappers honor this only
+ # as a forward kwarg (not from the model config), so it must be passed here.
+ if compute_aux_loss:
+ model_inputs["output_router_logits"] = True
+
+ outputs = model(**model_inputs)
+ logits = outputs.logits
+ # Exclude the last value: it corresponds to the next token pred
+ logits = logits[:, :-1, :] # (B, L-1, H)
+ # Only keep the last logits_to_keep. For model that support logits_to_keep, this is a no-op.
+ logits = logits[:, -logits_to_keep:, :] # (B, logits_to_keep, H)
+ # Divide logits by sampling temperature.
+ # See https://huggingface.co/blog/the_n_implementation_details_of_rlhf_with_ppo#policy-training-implementation-details
+ logits.div_(self.temperature)
+ completion_ids = input_ids_batch[:, -logits_to_keep:]
+ logps = selective_log_softmax(logits, completion_ids) # compute logprobs
+ all_logps.append(logps)
+
+ if compute_entropy:
+ with torch.no_grad():
+ entropies = entropy_from_logits(logits)
+ all_entropies.append(entropies)
+
+ if compute_aux_loss:
+ all_aux_losses.append(outputs.aux_loss)
+
+ logps = torch.cat(all_logps, dim=0)
+ entropies = torch.cat(all_entropies, dim=0) if compute_entropy else None
+ aux_loss = torch.stack(all_aux_losses).mean() if compute_aux_loss else None
+ return logps, entropies, aux_loss
+
+ def training_step(self, model, inputs, num_items_in_batch):
+ time_before = time.perf_counter()
+ output = super().training_step(model, inputs, num_items_in_batch)
+ self._step += 1
+ time_after = time.perf_counter()
+ self._current_train_step_time += time_after - time_before
+ if self._step % self.current_gradient_accumulation_steps == 0:
+ self._metrics["train"]["step_time"].append(self._current_train_step_time)
+ self._current_train_step_time = 0.0
+ return output
+
+ @profiling_decorator
+ def _prepare_inputs(self, generation_batch: dict[str, torch.Tensor | Any]) -> dict[str, torch.Tensor | Any]:
+ # Prepares inputs for model training/evaluation by managing completion generation and batch handling.
+ # During training:
+ # - Receives the local generation batch (Per-GPU batch size × steps per generation)
+ # from the modified training dataloader instead of the standard local batch
+ # - Generates completions once for the entire generation batch and splits it into batches of size
+ # `per_device_train_batch_size`
+ # - Buffers these completions and returns the appropriate slice for the current accumulation step
+ # - Optimizes by regenerating completions only periodically (every steps_per_generation * num_iterations)
+ # During evaluation:
+ # - The input is treated as a standard local batch (no accumulation, no multiple iterations)
+ # - Completions are generated for each batch without buffering or reuse
+ # Returns a single local batch in both cases.
+
+ mode = "train" if self.model.training else "eval"
+ if mode == "train":
+ generate_every = self.args.steps_per_generation * self.num_iterations
+ if self._step % generate_every == 0 or self._buffered_inputs is None:
+ # self._buffered_inputs=None can occur when resuming from a checkpoint
+ generation_batch = self._generate_and_score_completions(generation_batch)
+ generation_batch = split_pixel_values_by_grid(generation_batch)
+ generation_batch = shuffle_sequence_dict(generation_batch)
+ generation_batches = split_tensor_dict(generation_batch, self.args.steps_per_generation)
+ self._buffered_inputs = [unsplit_pixel_values_by_grid(batch) for batch in generation_batches]
+ inputs = self._buffered_inputs[self._step % self.args.steps_per_generation]
+ else:
+ # In evaluation, there is neither batch grouping for generation, nor multiple iterations, hence
+ # local generation batch == local eval batch
+ inputs = self._generate_and_score_completions(generation_batch)
+ return inputs
+
+ def _log_completion_extra(self, column: str, values: list):
+ """
+ Log extra columns to the completions table. Called from reward functions via the `log_extra` kwarg.
+
+ Args:
+ column (`str`):
+ Name of the column to add.
+ values (`list`):
+ Values for the column, one per sample in the batch.
+ """
+ self._pending_extra_logs[column].extend(values)
+
+ def _log_metric(self, name: str, value: float):
+ """
+ Log a scalar metric from a reward function. Called via the `log_metric` kwarg. Values are averaged over each
+ logging step and reported alongside built-in metrics like `kl` and `entropy`.
+
+ Args:
+ name (`str`):
+ Name of the metric.
+ value (`float`):
+ Scalar value for this batch.
+ """
+ self._pending_metrics[name].append(value)
+
+ @profiling_decorator
+ def _calculate_rewards(self, inputs, prompts, completions, completion_ids_list):
+ device = self.accelerator.device
+ rewards_per_func = torch.zeros(len(prompts), len(self.reward_funcs), device=device)
+
+ # Repeat all input columns (but "prompt", "completion", and "completion_ids") to match the num of generations
+ keys = [key for key in inputs[0] if key not in ["prompt", "completion", "completion_ids"]]
+ reward_kwargs = {key: [example[key] for example in inputs] for key in keys}
+
+ # This allows for dynamic reward shaping based on training progress.
+ reward_kwargs["trainer_state"] = self.state
+
+ # Allow reward functions to log extra columns to the completions table.
+ reward_kwargs["log_extra"] = self._log_completion_extra
+
+ # Allow reward functions to log additional scalar metrics.
+ reward_kwargs["log_metric"] = self._log_metric
+
+ async_funcs_info = [] # async custom functions for asyncio.gather
+
+ for i, (reward_func, reward_processing_class, reward_func_name) in enumerate(
+ zip(self.reward_funcs, self.reward_processing_classes, self.reward_func_names, strict=True)
+ ):
+ if isinstance(reward_func, nn.Module): # Module (no PretrainedModel) for compat with compiled models
+ with profiling_context(self, reward_func_name):
+ if is_conversational(inputs[0]):
+ messages = [{"messages": p + c} for p, c in zip(prompts, completions, strict=True)]
+ texts = [
+ apply_chat_template(x, reward_processing_class, **self.chat_template_kwargs)["text"]
+ for x in messages
+ ]
+ else:
+ texts = [p + c for p, c in zip(prompts, completions, strict=True)]
+ reward_inputs = reward_processing_class(
+ text=texts, return_tensors="pt", padding=True, padding_side="right", add_special_tokens=False
+ )
+ reward_inputs = super()._prepare_inputs(reward_inputs)
+ with torch.inference_mode():
+ rewards_per_func[:, i] = reward_func(**reward_inputs).logits[:, 0] # Shape (B*G,)
+ elif inspect.iscoroutinefunction(reward_func): # Separate async reward funcs to run them in parallel later
+ async_funcs_info.append((i, reward_func, reward_func_name))
+ else:
+ # Run synchronous reward function
+ with profiling_context(self, reward_func_name):
+ if self.environments is not None:
+ reward_kwargs["environments"] = self.environments
+ output_reward_func = reward_func(
+ prompts=prompts, completions=completions, completion_ids=completion_ids_list, **reward_kwargs
+ )
+ # Convert None values to NaN
+ output_reward_func = [reward if reward is not None else torch.nan for reward in output_reward_func]
+ rewards_per_func[:, i] = torch.tensor(output_reward_func, dtype=torch.float32, device=device)
+
+ # Execute async custom functions in parallel using asyncio.gather
+ if async_funcs_info:
+
+ async def _invoke_async(index, func, func_name):
+ with profiling_context(self, func_name):
+ output = await func(
+ prompts=prompts, completions=completions, completion_ids=completion_ids_list, **reward_kwargs
+ )
+ output = [r if r is not None else torch.nan for r in output]
+ return index, output
+
+ async def _run_async_funcs():
+ coros = [_invoke_async(i, func, func_name) for (i, func, func_name) in async_funcs_info]
+ return await asyncio.gather(*coros)
+
+ async_results = asyncio.run_coroutine_threadsafe(_run_async_funcs(), self.async_loop).result()
+ for idx, output_reward_func in async_results:
+ rewards_per_func[:, idx] = torch.tensor(output_reward_func, dtype=torch.float32, device=device)
+
+ # If all reward functions return None for a given row, issue a detailed warning
+ if torch.isnan(rewards_per_func).all(dim=1).any():
+ nan_row_idx = torch.isnan(rewards_per_func).all(dim=1).nonzero(as_tuple=True)[0][0]
+ row_reward_kwargs = {
+ key: value[nan_row_idx]
+ for key, value in reward_kwargs.items()
+ if key not in ("trainer_state", "log_extra", "log_metric")
+ }
+ row_reward_kwargs["prompt"] = prompts[nan_row_idx]
+ row_reward_kwargs["completion"] = completions[nan_row_idx]
+ logger.warning(
+ f"All reward functions returned None for the following kwargs:\n{row_reward_kwargs}\n"
+ "Please ensure that at least one reward function returns a valid reward."
+ )
+
+ # Gather the reward per function: this part is crucial, because the rewards are normalized per group and the
+ # completions may be distributed across processes
+ rewards_per_func = gather(rewards_per_func)
+ return rewards_per_func
+
+ def _tokenize_prompts(self, prompts: list):
+ """Tokenize prompts and extract images/multimodal fields for generation."""
+ if is_conversational({"prompt": prompts[0]}):
+ # Normalize string content to content blocks for VLM processors that don't handle plain strings.
+ if self._is_vlm:
+ prompts = [prepare_multimodal_messages(prompt) for prompt in prompts]
+
+ # Extract images from messages for VLM support
+ images = []
+ has_images = False
+ for prompt in prompts:
+ prompt_images = []
+ for message in prompt:
+ if isinstance(message["content"], list):
+ for part in message["content"]:
+ if part["type"] == "image":
+ prompt_images.append(part["image"])
+ has_images = True
+ images.append(prompt_images if prompt_images else None)
+ images = images if has_images else None
+
+ # Workaround for a bug in transformers 5.3.0 where some processors (e.g. Qwen2.5-VL) crash on
+ # batched unpadded input (transformers#44514).
+ # Fixed in transformers 5.4.0 (transformers#44563).
+ needs_padding_workaround = Version("5.3.0") <= Version(transformers.__version__) < Version("5.4.0")
+ tokenized = self.processing_class.apply_chat_template(
+ conversation=prompts,
+ tools=self.tools or None, # `or None`: Llama bug: it renders tool boilerplate for tools=[]
+ chat_template=self.chat_template,
+ add_generation_prompt=True,
+ tokenize=True,
+ return_dict=True,
+ **({"padding": True} if needs_padding_workaround else {}),
+ **self.chat_template_kwargs,
+ )
+ if needs_padding_workaround:
+ # Unpad input_ids: remove padding tokens using attention_mask to get per-sequence lists
+ prompt_ids = [
+ [tok for tok, m in zip(ids, mask, strict=True) if m]
+ for ids, mask in zip(tokenized["input_ids"], tokenized["attention_mask"], strict=True)
+ ]
+ else:
+ prompt_ids = tokenized["input_ids"]
+ # For VLMs, the processor returns extra multimodal fields (pixel_values, image_grid_thw, etc.)
+ multimodal_fields = {k: v for k, v in tokenized.items() if k not in ("input_ids", "attention_mask")}
+ else:
+ prompt_ids = self.processing_class(text=prompts)["input_ids"]
+ images = None
+ multimodal_fields = {}
+ return prompt_ids, images, multimodal_fields
+
+ def _generate_single_turn(self, prompt_ids, images, multimodal_fields):
+ device = self.accelerator.device
+ mode = "train" if self.model.training else "eval"
+
+ # Generate completions using either vLLM or regular generation
+ if self.use_vllm:
+ # Sync weights if training step changed
+ if self.state.global_step != self._last_loaded_step:
+ with profiling_context(self, "sync_weights"):
+ self.vllm_generation.sync_weights()
+ self._last_loaded_step = self.state.global_step
+
+ # Generate using vLLM with raw token IDs
+ num_generations = self.num_generations if mode == "train" else self.num_generations_eval
+ _, completion_ids, logprobs, _ = self.vllm_generation.generate(
+ prompts=prompt_ids,
+ images=images,
+ num_generations=num_generations,
+ profiler=profiling_context(self, "vLLM.generate"),
+ )
+ # vLLM returns per-token top-k logprobs; keep only the top-1 (sampled token) logprob
+ logprobs = [[lp[0] for lp in seq] for seq in logprobs]
+
+ elif self.use_transformers_continuous_batching:
+ with (
+ profiling_context(self, "transformers.generate_batch"),
+ unwrap_model_for_generation(
+ self.model_wrapped, self.accelerator, gather_deepspeed3_params=self.args.ds3_gather_for_generation
+ ) as unwrapped_model,
+ torch.no_grad(),
+ self._dist.summon_full_params(self.model_wrapped, recurse=False),
+ ):
+ # Cast to the appropriate dtype based on training configuration
+ if self.args.bf16:
+ unwrapped_model.to(torch.bfloat16)
+ elif self.args.fp16:
+ unwrapped_model.to(torch.float16)
+ if self.args.cast_lm_head_to_fp32:
+ unwrapped_model.lm_head.to(torch.float32)
+ all_outputs = unwrapped_model.generate_batch(
+ prompt_ids,
+ generation_config=self.generation_config,
+ continuous_batching_config=self.continuous_batching_config,
+ progress_bar=False,
+ )
+ unwrapped_model.train()
+ completion_ids = [output.generated_tokens for output in all_outputs.values()]
+ logprobs = None
+
+ else:
+ # Regular generation path: left-pad token IDs into tensors
+ prompt_tensors = [torch.tensor(ids) for ids in prompt_ids]
+ padded_ids = pad(prompt_tensors, padding_value=self._tokenizer.pad_token_id, padding_side="left")
+ attention_mask = pad([torch.ones_like(t) for t in prompt_tensors], padding_value=0, padding_side="left")
+ generate_inputs = {"input_ids": padded_ids, "attention_mask": attention_mask}
+ # For VLMs, include multimodal fields as tensors (pixel_values, image_grid_thw, etc.)
+ for k, v in multimodal_fields.items():
+ if isinstance(v, torch.Tensor):
+ generate_inputs[k] = v
+ elif isinstance(v, list) and v and isinstance(v[0], list):
+ # Per-token field (e.g., token_type_ids): left-pad like input_ids
+ generate_inputs[k] = pad([torch.tensor(x) for x in v], padding_value=0, padding_side="left")
+ else:
+ generate_inputs[k] = torch.tensor(np.array(v))
+ generate_inputs = super()._prepare_inputs(generate_inputs)
+
+ with (
+ profiling_context(self, "transformers.generate"),
+ unwrap_model_for_generation(
+ self.model_wrapped,
+ self.accelerator,
+ gather_deepspeed3_params=self.args.ds3_gather_for_generation,
+ generation_kwargs=self.generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762
+ ) as unwrapped_model,
+ torch.no_grad(),
+ self._dist.summon_full_params(self.model_wrapped, recurse=False),
+ ):
+ prompt_completion_ids = unwrapped_model.generate(
+ **generate_inputs, generation_config=self.generation_config
+ )
+ # Compute prompt length and extract completion ids
+ prompt_length = generate_inputs["input_ids"].size(1)
+ completion_ids = prompt_completion_ids[:, prompt_length:]
+
+ # Mask everything after the first EOS token
+ is_eos = completion_ids == self._tokenizer.eos_token_id
+ eos_idx = torch.full((is_eos.size(0),), is_eos.size(1), dtype=torch.long, device=device)
+ eos_idx[is_eos.any(dim=1)] = is_eos.int().argmax(dim=1)[is_eos.any(dim=1)]
+ sequence_indices = torch.arange(is_eos.size(1), device=device).expand(is_eos.size(0), -1)
+ completion_mask = (sequence_indices <= eos_idx.unsqueeze(1)).int()
+ completion_ids = [
+ c[m].tolist() for c, m in zip(completion_ids.cpu(), completion_mask.bool().cpu(), strict=True)
+ ]
+ logprobs = None # not used in this case
+
+ return completion_ids, logprobs
+
+ def _get_tool_suffix_ids(self, tool_messages):
+ """Get token IDs for tool result formatting by using a minimal dummy conversation."""
+ # Use the real tool name instead of a dummy: some templates (e.g. GPT-OSS) derive the tool response
+ # header from the assistant's tool call name.
+ dummy_tool_calls = [{"type": "function", "function": {"name": tool_messages[0]["name"], "arguments": {}}}]
+ dummy_messages = [
+ {"role": "user", "content": "dummy"},
+ {
+ "role": "assistant",
+ # "content" is required here because VLM processors crash on tokenize=True without it
+ # (KeyError in processing_utils.py). See huggingface/transformers#45290.
+ "content": "",
+ "tool_calls": dummy_tool_calls,
+ },
+ ]
+ if self._is_vlm:
+ dummy_messages = prepare_multimodal_messages(dummy_messages)
+ tool_messages = prepare_multimodal_messages(tool_messages)
+
+ prefix_ids = self.processing_class.apply_chat_template(
+ dummy_messages,
+ add_generation_prompt=False,
+ tokenize=True,
+ chat_template=self.chat_template,
+ return_dict=False,
+ **self.chat_template_kwargs,
+ )
+ full_ids = self.processing_class.apply_chat_template(
+ dummy_messages + tool_messages,
+ add_generation_prompt=True,
+ tokenize=True,
+ chat_template=self.chat_template,
+ return_dict=False,
+ **self.chat_template_kwargs,
+ )
+ # VLM processors return batched output (list of lists), unbatch for single conversation
+ if self._is_vlm:
+ prefix_ids = prefix_ids[0]
+ full_ids = full_ids[0]
+
+ # Some chat templates (notably Qwen3/Qwen3.5) render "...<|im_end|>\n" after an assistant/tool block.
+ # When we compute `suffix_ids` by slicing `full_ids`, we must align the slicing boundary to
+ # EOS (not EOS + newline). Templates that don't use EOS as end-of-turn (e.g. Gemma uses
+ # ) skip this trimming.
+ eos_positions = [i for i, tok_id in enumerate(prefix_ids) if tok_id == self._tokenizer.eos_token_id]
+ if eos_positions:
+ prefix_ids = prefix_ids[: eos_positions[-1] + 1]
+
+ if full_ids[: len(prefix_ids)] != prefix_ids:
+ raise ValueError("Unexpected tokenization: the EOS-trimmed prefix IDs are not a prefix of the full IDs.")
+ return full_ids[len(prefix_ids) :]
+
+ def _tool_call_loop(self, prompts, prompt_ids, completion_ids, completions, logprobs, images, multimodal_fields):
+ # Tool execution loop: execute tools, then regenerate completions with tool results appended to the prompt
+ tool_calls = [completion[0].get("tool_calls") for completion in completions]
+ idxs_with_tool = [idx for idx, tool_call in enumerate(tool_calls) if tool_call]
+ tool_calls = [tool_calls[idx] for idx in idxs_with_tool]
+ tool_mask = [[1] * len(ids) for ids in completion_ids] # 0 for tool result tokens, 1 elsewhere
+ # Collect images from multimodal tool responses for the forward pass
+ tool_images = [[] for _ in completion_ids]
+ tool_call_count = 0
+ tool_failure_count = 0
+ iteration_num = 0
+
+ while idxs_with_tool and iteration_num < self.max_tool_calling_iterations:
+ prompt_completion_tools = [prompts[i] for i in idxs_with_tool] # select only prompts that need tool calls
+ # Snapshot state so we can rollback tool results that would exceed max_completion_length
+ completions_len_before = [len(completions[i]) for i in idxs_with_tool]
+ tool_images_len_before = [len(tool_images[i]) for i in idxs_with_tool]
+ prompts_len_before = [len(prompts[i]) for i in idxs_with_tool]
+
+ # Call the tools, and build the new prompt for generation
+ for idx in range(len(idxs_with_tool)):
+ idx_with_tool = idxs_with_tool[idx]
+ tool_call_list = tool_calls[idx]
+ prompt_completion_tool = prompt_completion_tools[idx]
+ sync_tool_dict = self._sync_tool_dicts[idx_with_tool]
+ async_tool_dict = self._async_tool_dicts[idx_with_tool]
+ # Append the last assistant message (which triggered tool_calls) to the prompt
+ prompt_completion_tool.append(completions[idx_with_tool][-1])
+ async_coros = []
+ tool_call_results = []
+ for tool_call in tool_call_list:
+ tool_call_count += 1
+ if tool_call["type"] == "function":
+ function = tool_call["function"]
+ name = function["name"]
+ try:
+ if name in sync_tool_dict:
+ tool_call_results.append((name, sync_tool_dict[name](**function["arguments"])))
+ elif name in async_tool_dict:
+ async_coros.append((name, async_tool_dict[name](**function["arguments"])))
+ else:
+ raise ValueError(f"Tool {name} not found.")
+ except Exception as e:
+ tool_failure_count += 1
+ result = {"error": str(e)}
+ tool_call_results.append((name, result))
+ else:
+ tool_failure_count += 1
+ name = tool_call.get("name", "unknown")
+ tool_call_results.append((name, {"error": f"Unsupported tool call type: {tool_call['type']}"}))
+
+ if async_coros:
+
+ async def _run_async_tools(async_coros):
+ coros = [coro for _, coro in async_coros]
+ results = await asyncio.gather(*coros, return_exceptions=True)
+ return [(name, result) for (name, _), result in zip(async_coros, results, strict=False)]
+
+ async_results = asyncio.run_coroutine_threadsafe(
+ _run_async_tools(async_coros), self.async_loop
+ ).result()
+
+ for name, result in async_results:
+ if isinstance(result, Exception):
+ tool_failure_count += 1
+ tool_call_results.append((name, {"error": str(result)}))
+ else:
+ tool_call_results.append((name, result))
+
+ for name, result in tool_call_results:
+ # Support multimodal tool responses: if the tool returns a list of content blocks
+ # (e.g., [{"type": "image", "image": ...}, {"type": "text", "text": "..."}]),
+ # pass them through directly so _tokenize_prompts can extract images for VLMs.
+ content = result if isinstance(result, list) else str(result)
+ tool_message = {"role": "tool", "name": name, "content": content}
+ # Collect images from multimodal tool responses
+ if isinstance(content, list):
+ for part in content:
+ if isinstance(part, dict) and part.get("type") == "image":
+ tool_images[idx_with_tool].append(part["image"])
+ prompt_completion_tool.append(tool_message)
+ completions[idx_with_tool].append(tool_message)
+
+ # Build token IDs by concatenation: prompt + completion + tool_suffix.
+ prompt_completion_tool_ids = []
+ for idx in range(len(idxs_with_tool)):
+ idx_with_tool = idxs_with_tool[idx]
+ # Extract trailing tool messages from completions
+ tool_messages = []
+ for message in reversed(completions[idx_with_tool]):
+ if message["role"] == "tool":
+ tool_messages.insert(0, message)
+ else:
+ break
+ suffix_ids = self._get_tool_suffix_ids(tool_messages)
+ prompt_completion_tool_ids.append(
+ prompt_ids[idx_with_tool] + completion_ids[idx_with_tool] + suffix_ids
+ )
+
+ # Drop tool results whose addition would push the sequence past max_completion_length (the completion
+ # budget) or past the backend context ceiling (vLLM and transformers will error out on inputs longer than
+ # the model's max length). The sample exits the loop with its completion as-is, and the tool
+ # messages/images appended this iteration are rolled back so completions and tool_images stay consistent
+ # with completion_ids.
+ if self.use_vllm and self.vllm_mode == "colocate":
+ max_model_len = self.vllm_generation.llm.llm_engine.model_config.max_model_len
+ else:
+ config = self.model.config.text_config if self._is_vlm else self.model.config
+ max_model_len = config.max_position_embeddings
+ overlong = [
+ len(pct) - len(prompt_ids[i]) > self.max_completion_length or len(pct) >= max_model_len
+ for i, pct in zip(idxs_with_tool, prompt_completion_tool_ids, strict=True)
+ ]
+ for idx in range(len(idxs_with_tool)):
+ if overlong[idx]:
+ idx_with_tool = idxs_with_tool[idx]
+ del completions[idx_with_tool][completions_len_before[idx] :]
+ del tool_images[idx_with_tool][tool_images_len_before[idx] :]
+ del prompts[idx_with_tool][prompts_len_before[idx] :]
+ # Keep only non-overlong items for further processing
+ idxs_with_tool = [idx for idx, o in zip(idxs_with_tool, overlong, strict=True) if not o]
+ prompt_completion_tool_ids = [
+ pct for pct, o in zip(prompt_completion_tool_ids, overlong, strict=True) if not o
+ ]
+ if not idxs_with_tool:
+ break # all overlong, exit tool loop
+
+ # Filter images and multimodal fields to match the current subset (index into full batch).
+ # Merge tool response images so the model can see visual feedback during generation.
+ merged_images = images
+ if any(imgs for imgs in tool_images):
+ if merged_images is None:
+ merged_images = [imgs if imgs else None for imgs in tool_images]
+ else:
+ merged_images = [
+ (existing or []) + new for existing, new in zip(merged_images, tool_images, strict=True)
+ ]
+ loop_images = [merged_images[i] for i in idxs_with_tool] if merged_images else None
+ if multimodal_fields:
+ loop_multimodal_fields = {}
+ for k, v in multimodal_fields.items():
+ selected = [v[i] for i in idxs_with_tool]
+ # Per-token fields (e.g. token_type_ids) need zero-padding to match extended prompt length
+ if isinstance(selected[0], list):
+ selected = [
+ s + [0] * (len(pct) - len(s))
+ for s, pct in zip(selected, prompt_completion_tool_ids, strict=True)
+ ]
+ loop_multimodal_fields[k] = selected
+ else:
+ loop_multimodal_fields = {}
+
+ # Generate new completions after tool execution (using concatenated IDs, no re-tokenization)
+ post_tool_ids, post_tool_logprobs = self._generate_single_turn(
+ prompt_completion_tool_ids, loop_images, loop_multimodal_fields
+ )
+
+ # Truncate so that pct[len(prompt_ids[idx]) :] + post_tool does not exceed max_completion_length.
+ # The pre-regen check guarantees len(completion_tool_ids) <= max_completion_length, so any
+ # excess can only come from post_tool_ids. post_tool_ids is model-generated text and never
+ # contains image tokens, so a plain slice is safe.
+ for idx in range(len(idxs_with_tool)):
+ idx_with_tool = idxs_with_tool[idx]
+ completion_tool_length = len(prompt_completion_tool_ids[idx]) - len(prompt_ids[idx_with_tool])
+ excess_length = completion_tool_length + len(post_tool_ids[idx]) - self.max_completion_length
+ if excess_length > 0:
+ new_len = len(post_tool_ids[idx]) - excess_length
+ post_tool_ids[idx] = post_tool_ids[idx][:new_len]
+ if logprobs is not None:
+ post_tool_logprobs[idx] = post_tool_logprobs[idx][:new_len]
+
+ # Update tool_mask: the tool result should be 0 and the post-tool 1
+ for idx in range(len(idxs_with_tool)):
+ idx_with_tool = idxs_with_tool[idx]
+ prompt_completion_tool_length = len(prompt_completion_tool_ids[idx])
+ prompt_length = len(prompt_ids[idx_with_tool])
+ completion_length = len(completion_ids[idx_with_tool])
+ post_tool_length = len(post_tool_ids[idx])
+ tool_length = prompt_completion_tool_length - prompt_length - completion_length
+ tool_mask[idx_with_tool] += [0] * tool_length + [1] * post_tool_length
+ if logprobs is not None:
+ logprobs[idx_with_tool] += [0.0] * tool_length + post_tool_logprobs[idx]
+
+ # Update completion_ids with the new completions (after tool execution)
+ for idx in range(len(idxs_with_tool)):
+ idx_with_tool = idxs_with_tool[idx]
+ prompt_length = len(prompt_ids[idx_with_tool])
+ pct = prompt_completion_tool_ids[idx] # = prompt-completion-tool
+ completion_ids[idx_with_tool] = pct[prompt_length:] + post_tool_ids[idx]
+
+ # Decode post-tool completions.
+ post_tool_completions = [parse_response(self._tokenizer, ids) if ids else {} for ids in post_tool_ids]
+
+ # Add post-tool completions to the existing completions
+ for idx in range(len(idxs_with_tool)):
+ idx_with_tool = idxs_with_tool[idx]
+ if post_tool_completions[idx]: # {} if post-tool completions completely truncated
+ completions[idx_with_tool].append(post_tool_completions[idx])
+
+ # Check for further tool calls
+ tool_calls = [completion.get("tool_calls") for completion in post_tool_completions]
+ idxs_with_tool = [idx for idx, tool_call in zip(idxs_with_tool, tool_calls, strict=True) if tool_call]
+ tool_calls = [tool_call for tool_call in tool_calls if tool_call]
+ iteration_num += 1
+
+ return tool_mask, completions, completion_ids, logprobs, tool_call_count, tool_failure_count, tool_images
+
+ def _generate(self, prompts: list):
+ device = self.accelerator.device
+ mode = "train" if self.model.training else "eval"
+
+ # Copy the prompts to avoid modifying the original list
+ prompts = copy.deepcopy(prompts)
+
+ if self.rollout_func is not None:
+ # Keep vLLM weights in sync for custom rollouts that rely on vLLM utilities.
+ if self.use_vllm and self.state.global_step != self._last_loaded_step:
+ with profiling_context(self, "sync_weights"):
+ self.vllm_generation.sync_weights()
+ self._last_loaded_step = self.state.global_step
+
+ # Pass prompts to rollout_func preserving structured messages.
+ # Chat templating must happen inside rollout_func, at the backend boundary, so that
+ # multimodal content (images, typed content blocks) is not lost before rollout logic runs.
+ output = self.rollout_func(prompts, self)
+ required_keys = {"prompt_ids", "completion_ids", "logprobs"}
+ missing_keys = required_keys - output.keys()
+ if missing_keys:
+ missing_keys_list = sorted(missing_keys)
+ raise ValueError(f"rollout_func must return keys {missing_keys_list} in its output dict.")
+ extra_fields = {k: v for k, v in output.items() if k not in required_keys}
+ prompt_ids, completion_ids, logprobs = output["prompt_ids"], output["completion_ids"], output["logprobs"]
+ images = None
+ multimodal_fields = {}
+ else:
+ prompt_ids, images, multimodal_fields = self._tokenize_prompts(prompts)
+ completion_ids, logprobs = self._generate_single_turn(prompt_ids, images, multimodal_fields)
+ extra_fields = {}
+
+ # Decode completions. It's important to use `parse_response` when possible, because it handles tool calls.
+ if is_conversational({"prompt": prompts[0]}):
+ if (
+ Version(transformers.__version__) >= Version("5.0.0") # parse_response added in v5
+ and hasattr(self._tokenizer, "response_schema") # attribute not set by default for now
+ and self._tokenizer.response_schema is not None # only works if the tokenizer has a schema
+ ):
+ completions = [[parse_response(self._tokenizer, ids)] for ids in completion_ids]
+ else:
+ contents = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True)
+ completions = [[{"role": "assistant", "content": content}] for content in contents]
+ else:
+ completions = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True)
+
+ # Extract tool calls from the completions and (possibly) execute them
+ tool_images = []
+ if self.tools:
+ (
+ tool_mask,
+ completions,
+ completion_ids,
+ logprobs,
+ tool_call_count,
+ tool_failure_count,
+ tool_images,
+ ) = self._tool_call_loop(
+ prompts, prompt_ids, completion_ids, completions, logprobs, images, multimodal_fields
+ )
+ # Merge tool response images into the images list for the forward pass
+ if any(imgs for imgs in tool_images):
+ if images is None:
+ images = [imgs if imgs else None for imgs in tool_images]
+ else:
+ images = [(existing or []) + new for existing, new in zip(images, tool_images, strict=True)]
+ else:
+ # Support custom env_mask from rollout_func (e.g., for environment feedback masking)
+ # Internally treated as tool_mask - marks model tokens (1) vs external tokens (0)
+ tool_mask = extra_fields.pop("env_mask", None)
+
+ # Get completion length per sequence, used for logging
+ prompt_lengths = torch.tensor([len(ids) for ids in prompt_ids], device=device)
+ if tool_mask is not None: # count only model-generated tokens (tool_mask=1)
+ completion_lengths = torch.tensor([sum(mask) for mask in tool_mask], device=device)
+ else:
+ completion_lengths = torch.tensor([len(ids) for ids in completion_ids], device=device)
+ agg_prompt_lengths = self.accelerator.gather(prompt_lengths)
+ agg_completion_lengths = self.accelerator.gather(completion_lengths)
+ total_prompt_tokens = agg_prompt_lengths.sum()
+ total_completion_tokens = agg_completion_lengths.sum() # = num_items_in_batch, required for the DAPO loss
+
+ # Log the metrics
+ if mode == "train":
+ self.state.num_input_tokens_seen += (total_prompt_tokens + total_completion_tokens).item()
+ self._metrics[mode]["num_tokens"] = [self.state.num_input_tokens_seen]
+
+ # Log completion lengths, mean, min, max
+ self._metrics[mode]["completions/mean_length"].append(agg_completion_lengths.float().mean().item())
+ self._metrics[mode]["completions/min_length"].append(agg_completion_lengths.float().min().item())
+ self._metrics[mode]["completions/max_length"].append(agg_completion_lengths.float().max().item())
+
+ # Identify sequences that terminated with EOS and log their lengths
+ eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id]
+ is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids], device=device)
+ agg_is_truncated = self.accelerator.gather(is_truncated)
+ self._metrics[mode]["completions/clipped_ratio"].append(agg_is_truncated.float().mean().item())
+ term_completion_lengths = agg_completion_lengths[~agg_is_truncated]
+ if len(term_completion_lengths) == 0: # edge case where no terminated sequences are found
+ term_completion_lengths = torch.zeros(1, device=device)
+ self._metrics[mode]["completions/mean_terminated_length"].append(term_completion_lengths.float().mean().item())
+ self._metrics[mode]["completions/min_terminated_length"].append(term_completion_lengths.float().min().item())
+ self._metrics[mode]["completions/max_terminated_length"].append(term_completion_lengths.float().max().item())
+
+ if self.tools:
+ agg_tool_call_count = self.accelerator.gather(torch.tensor(tool_call_count, device=device)).sum()
+ tool_call_frequency = (agg_tool_call_count / len(agg_prompt_lengths)).item()
+ self._metrics[mode]["tools/call_frequency"].append(tool_call_frequency)
+ agg_tool_failure_count = self.accelerator.gather(torch.tensor(tool_failure_count, device=device)).sum()
+ failure_frequency = (
+ (agg_tool_failure_count / agg_tool_call_count).item() if agg_tool_call_count > 0 else 0.0
+ )
+ self._metrics[mode]["tools/failure_frequency"].append(failure_frequency)
+
+ return (
+ prompt_ids,
+ completion_ids,
+ tool_mask,
+ completions,
+ total_completion_tokens,
+ logprobs,
+ extra_fields,
+ images,
+ tool_images,
+ )
+
+ def _generate_and_score_completions(
+ self, inputs: list[dict[str, torch.Tensor | Any]]
+ ) -> dict[str, torch.Tensor | Any]:
+ device = self.accelerator.device
+ mode = "train" if self.model.training else "eval"
+
+ prompts = [x["prompt"] for x in inputs]
+
+ if self.environments:
+ for prompt, environment, reset_kwargs in zip(prompts, self.environments, inputs, strict=True):
+ observation = environment.reset(**reset_kwargs)
+ if observation is None:
+ continue
+ if isinstance(observation, list) and isinstance(prompt[-1]["content"], str):
+ prompt[-1]["content"] = [{"type": "text", "text": prompt[-1]["content"]}]
+ if isinstance(observation, str) and isinstance(prompt[-1]["content"], list):
+ observation = [{"type": "text", "text": observation}]
+ prompt[-1]["content"] += observation
+
+ if "images" in inputs[0]:
+ images = [example.get("images") for example in inputs]
+ elif "image" in inputs[0]:
+ images = [[example.get("image")] if example.get("image") is not None else None for example in inputs]
+ else:
+ images = None
+ # Transformers requires at least one image in the batch, otherwise it throws an error
+ if images is not None and all(img_list == [] for img_list in images):
+ images = None
+
+ # If the prompts are conversational and the inputs contain images, we need to convert the prompts from
+ # [{"role": "user", "content": "What color is the sky?"}] to
+ # [{"role": "user", "content": [{"type": "image", "image": }, {"type": "text", "text": "What color is the sky?"}]}]
+ if images is not None:
+ if not is_conversational(inputs[0]):
+ raise ValueError(
+ "Multimodal training requires conversational prompts. It looks like the dataset contains "
+ "non-conversational inputs, likely because a chat template was applied before passing the dataset "
+ "to the trainer. Please provide the raw conversational prompts and let the trainer apply the chat "
+ "template internally."
+ )
+ prompts = [
+ prepare_multimodal_messages(prompt, images=image_list)
+ for prompt, image_list in zip(prompts, images, strict=True)
+ ]
+
+ dataset_images = images # preserve dataset images before _generate may overwrite
+ (
+ prompt_ids_list,
+ completion_ids_list,
+ tool_mask_list,
+ completions,
+ num_items_in_batch,
+ sampling_per_token_logps_list,
+ extra_fields,
+ images,
+ tool_images,
+ ) = self._generate(prompts)
+ if images is None:
+ images = dataset_images # restore dataset images (rollout_func path returns None)
+
+ # Convert lists of token IDs to padded tensors
+ prompt_ids = [torch.tensor(ids) for ids in prompt_ids_list]
+ prompt_mask = [torch.ones_like(ids, dtype=torch.long) for ids in prompt_ids]
+ prompt_ids = pad(
+ prompt_ids,
+ padding_value=self._tokenizer.pad_token_id,
+ padding_side="left",
+ pad_to_multiple_of=self.pad_to_multiple_of,
+ ).to(device=device)
+ prompt_mask = pad(
+ prompt_mask, padding_value=0, padding_side="left", pad_to_multiple_of=self.pad_to_multiple_of
+ ).to(device=device)
+ completion_ids = [torch.tensor(ids) for ids in completion_ids_list]
+ completion_mask = [torch.ones_like(ids, dtype=torch.long) for ids in completion_ids]
+ completion_ids = pad(
+ completion_ids,
+ padding_value=self._tokenizer.pad_token_id,
+ padding_side="right",
+ pad_to_multiple_of=self.pad_to_multiple_of,
+ ).to(device=device)
+ completion_mask = pad(
+ completion_mask, padding_value=0, padding_side="right", pad_to_multiple_of=self.pad_to_multiple_of
+ ).to(device=device)
+ if sampling_per_token_logps_list is not None:
+ sampling_per_token_logps = [torch.tensor(logps) for logps in sampling_per_token_logps_list]
+ sampling_per_token_logps = pad(
+ sampling_per_token_logps,
+ padding_value=0.0,
+ padding_side="right",
+ pad_to_multiple_of=self.pad_to_multiple_of,
+ ).to(device=device)
+ else:
+ sampling_per_token_logps = None
+ if tool_mask_list is not None:
+ tool_mask = [torch.tensor(mask) for mask in tool_mask_list]
+ tool_mask = pad(
+ tool_mask, padding_value=1, padding_side="right", pad_to_multiple_of=self.pad_to_multiple_of
+ ).to(device=device)
+ else:
+ tool_mask = None
+
+ # If mask_truncated_completions is enabled, zero out truncated completions for attention and loss masking
+ if self.mask_truncated_completions:
+ eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id]
+ is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids_list], device=device)
+ # Mask completion_mask for attention masking
+ completion_mask = completion_mask * (~is_truncated).unsqueeze(1).int()
+ # Also mask tool_mask for consistency in multi-turn training
+ if tool_mask is not None:
+ tool_mask = tool_mask * (~is_truncated).unsqueeze(1).int()
+
+ # Concatenate prompt_mask with completion_mask for logit computation
+ prompt_completion_ids = torch.cat([prompt_ids, completion_ids], dim=1) # (B, P+C)
+ attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) # (B, P+C)
+
+ logits_to_keep = completion_ids.size(1) # we only need to compute the logits for the completion tokens
+ batch_size = self.args.per_device_train_batch_size if mode == "train" else self.args.per_device_eval_batch_size
+
+ num_images = [len(img_list) if img_list else 0 for img_list in images] if images is not None else None
+
+ # Get forward_kwargs for models with multimodal inputs.
+ # When tool images are present (from _tool_call_loop), use image_processor directly and build
+ # mm_token_type_ids from prompt_completion_ids. Otherwise, use the full processor pipeline
+ # which returns model-specific keys (image_sizes, pixel_attention_mask, etc.).
+ if self.tools and any(imgs for imgs in tool_images) and self._is_vlm:
+ flat_images = [img for img_list in images if img_list for img in img_list]
+ image_inputs = self.processing_class.image_processor(images=flat_images, return_tensors="pt")
+ image_inputs = super()._prepare_inputs(image_inputs)
+ forward_kwargs = dict(image_inputs)
+ elif images is not None:
+ prompts_text = [
+ apply_chat_template(
+ {"prompt": prompt}, self.processing_class, tools=self.tools, **self.chat_template_kwargs
+ )["prompt"]
+ for prompt in prompts
+ ]
+ prompt_inputs = self.processing_class(images=images, text=prompts_text, padding=True, return_tensors="pt")
+ prompt_inputs = super()._prepare_inputs(prompt_inputs)
+ forward_kwargs = {k: v for k, v in prompt_inputs.items() if k not in ["input_ids", "attention_mask"]}
+ else:
+ forward_kwargs = {}
+
+ # If token_type_ids are used, extend them with zeros for the completion part
+ if "token_type_ids" in forward_kwargs:
+ token_type_ids = forward_kwargs["token_type_ids"]
+ if self.pad_to_multiple_of is not None:
+ # Needed only with pad_to_multiple_of: otherwise prompt_ids and token_type_ids must have equal len
+ padding_size = prompt_ids.size(1) - token_type_ids.size(1)
+ if padding_size > 0:
+ token_type_ids = torch.cat(
+ [token_type_ids.new_zeros((token_type_ids.size(0), padding_size)), token_type_ids], dim=1
+ )
+ forward_kwargs["token_type_ids"] = torch.cat(
+ [token_type_ids, token_type_ids.new_zeros(completion_ids.shape)], dim=1
+ )
+ # If mm_token_type_ids are used, extend them with zeros for the completion part
+ if "mm_token_type_ids" in forward_kwargs:
+ mm_token_type_ids = forward_kwargs["mm_token_type_ids"]
+ if self.pad_to_multiple_of is not None:
+ # Needed only with pad_to_multiple_of: otherwise prompt_ids and mm_token_type_ids must have equal len
+ padding_size = prompt_ids.size(1) - mm_token_type_ids.size(1)
+ if padding_size > 0:
+ mm_token_type_ids = torch.cat(
+ [mm_token_type_ids.new_zeros((mm_token_type_ids.size(0), padding_size)), mm_token_type_ids],
+ dim=1,
+ )
+ forward_kwargs["mm_token_type_ids"] = torch.cat(
+ [mm_token_type_ids, mm_token_type_ids.new_zeros(completion_ids.shape)], dim=1
+ )
+
+ # For VLM tool images: build token type IDs from the full prompt_completion_ids.
+ # This must happen AFTER the token_type_ids/mm_token_type_ids extension blocks above,
+ # because our version already covers the full sequence (images are in the completion,
+ # not just the prompt).
+ if self.tools and any(imgs for imgs in tool_images) and self._is_vlm:
+ mm_ids = torch.zeros_like(prompt_completion_ids)
+ if self._image_pad_token_id is not None:
+ mm_ids[prompt_completion_ids == self._image_pad_token_id] = 1
+ if self._video_pad_token_id is not None:
+ mm_ids[prompt_completion_ids == self._video_pad_token_id] = 2
+
+ # Use the same key the model expects: token_type_ids for models like Gemma,
+ # mm_token_type_ids for models like Qwen.
+ image_grid_thw = forward_kwargs.get("image_grid_thw")
+ if image_grid_thw is not None:
+ forward_kwargs["mm_token_type_ids"] = mm_ids
+ else:
+ forward_kwargs["token_type_ids"] = mm_ids
+
+ # Truncation safety (Qwen-style models with image_grid_thw only): if
+ # max_completion_length truncated some image tokens, the number of image pad tokens
+ # in input_ids won't match pixel_values features. Check per-sample and drop ALL
+ # images for any sample with a mismatch (safe fallback).
+ if image_grid_thw is not None and num_images is not None:
+ merge_length = getattr(self.processing_class.image_processor, "merge_size", 2) ** 2
+ img_offset = 0
+ has_mismatch = False
+ for b in range(mm_ids.shape[0]):
+ sample_tokens = (mm_ids[b] == 1).sum().item()
+ sample_features = 0
+ for i in range(num_images[b]):
+ grid_idx = img_offset + i
+ if grid_idx < image_grid_thw.shape[0]:
+ sample_features += image_grid_thw[grid_idx].prod().item() // merge_length
+ if sample_tokens != sample_features:
+ has_mismatch = True
+ break
+ img_offset += num_images[b]
+
+ if has_mismatch:
+ # Drop all images: safer than partial trim which is error-prone
+ forward_kwargs.pop("pixel_values", None)
+ forward_kwargs.pop("image_grid_thw", None)
+ mm_ids.zero_()
+ forward_kwargs["mm_token_type_ids"] = mm_ids
+ num_images = None
+
+ # When gradient checkpointing is enabled with use_reentrant=True (non default), calling the model inside a
+ # torch.no_grad() block triggers a harmless PyTorch warning ("None of the inputs have requires_grad=True").
+ # Temporarily disable checkpointing to avoid this warning during inference.
+ with torch.no_grad(), disable_gradient_checkpointing(self.model, self.args.gradient_checkpointing_kwargs):
+ # If the generation and optimization steps are misaligned—i.e., if generation does not occur at the end of
+ # a full optimizer step (when gradient_accumulation_steps is not a multiple of generate_every)—then the
+ # samples may come from an earlier version of the model. In that case, we need to track old_per_token_logps
+ # for importance sampling. If the steps are aligned, importance sampling isn't necessary and we set
+ # old_per_token_logps to None.
+ # When using vLLM, we always compute old_per_token_logps for importance sampling, it was shown that the
+ # distribution mismatch between vLLM and the training model can be large and harm the training.
+ generate_every = self.args.steps_per_generation * self.num_iterations # generation frequency
+ if self.args.gradient_accumulation_steps % generate_every != 0 or (
+ self.use_vllm and self.vllm_importance_sampling_correction
+ ):
+ old_per_token_logps, _, _ = self._get_per_token_logps_and_entropies(
+ self.model,
+ prompt_completion_ids,
+ attention_mask,
+ logits_to_keep,
+ batch_size,
+ num_images=num_images,
+ **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask, image_sizes, image_position_ids
+ )
+ else:
+ old_per_token_logps = None
+
+ # Compute the importance sampling ratio when using vLLM, to correct for potential distribution mismatch
+ if self.use_vllm and self.vllm_importance_sampling_correction:
+ mask = completion_mask if tool_mask is None else completion_mask * tool_mask
+ per_token_logps_diff = (old_per_token_logps - sampling_per_token_logps) * mask
+
+ sequence_level_is = self.vllm_importance_sampling_mode in ["sequence_mask", "sequence_truncate"]
+ if sequence_level_is:
+ per_sequence_logps_diff = per_token_logps_diff.sum(dim=-1, keepdim=True)
+ logps_diff = per_sequence_logps_diff
+ else:
+ logps_diff = per_token_logps_diff
+
+ vllm_importance_sampling_ratio = torch.exp(logps_diff)
+
+ # vllm_importance_sampling_ratio.shape:
+ # token_* modes: (B, T) (per-token ratio)
+ # sequence_* modes: (B, 1) (per-sequence ratio)
+
+ if self.vllm_importance_sampling_mode in ["sequence_truncate", "token_truncate"]:
+ vllm_importance_sampling_ratio = torch.clamp(
+ vllm_importance_sampling_ratio,
+ min=self.vllm_importance_sampling_clip_min,
+ max=self.vllm_importance_sampling_clip_max,
+ )
+ elif self.vllm_importance_sampling_mode in ["sequence_mask", "token_mask"]:
+ min_val = (
+ self.vllm_importance_sampling_clip_min
+ if self.vllm_importance_sampling_clip_min is not None
+ else -math.inf
+ )
+ max_val = (
+ self.vllm_importance_sampling_clip_max
+ if self.vllm_importance_sampling_clip_max is not None
+ else math.inf
+ )
+
+ invalid_mis_mask = (vllm_importance_sampling_ratio < min_val) | (
+ vllm_importance_sampling_ratio > max_val
+ )
+ vllm_importance_sampling_ratio = vllm_importance_sampling_ratio.masked_fill(
+ invalid_mis_mask, value=0.0
+ )
+ else:
+ raise ValueError(
+ f"Unknown vLLM importance sampling level: {self.vllm_importance_sampling_mode}. Possible values are 'token_truncate', 'token_mask', 'sequence_truncate', and 'sequence_mask'."
+ )
+
+ # Compute the per-token log probabilities for the reference model
+ if self.beta != 0.0:
+ if self.ref_model is not None:
+ ref_per_token_logps, _, _ = self._get_per_token_logps_and_entropies(
+ self.ref_model,
+ prompt_completion_ids,
+ attention_mask,
+ logits_to_keep,
+ batch_size=batch_size,
+ num_images=num_images,
+ **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask, image_sizes, image_position_ids
+ )
+ else:
+ # When training a PEFT adapter, how we obtain the reference depends on the setup:
+ # - New adapter: disabling adapters yields the base model.
+ # - Re-training an existing adapter: an initial copy is loaded under the name "ref".
+ model = self.accelerator.unwrap_model(self.model)
+ with use_adapter(model, adapter_name="ref" if "ref" in model.peft_config else None):
+ ref_per_token_logps, _, _ = self._get_per_token_logps_and_entropies(
+ self.model,
+ prompt_completion_ids,
+ attention_mask,
+ logits_to_keep,
+ batch_size=batch_size,
+ num_images=num_images,
+ **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask, image_sizes, image_position_ids
+ )
+ else:
+ ref_per_token_logps = None
+
+ # Decode
+ prompts_text = self.processing_class.batch_decode(prompt_ids, skip_special_tokens=True)
+ completions_text = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True)
+
+ # Merge extra_fields from rollout_func into inputs for reward functions
+ if extra_fields:
+ for i, inp in enumerate(inputs):
+ for key, values in extra_fields.items():
+ if isinstance(values, list) and i < len(values):
+ inp[key] = values[i]
+ elif not isinstance(values, list):
+ inp[key] = values
+
+ # Calculate rewards for each reward function. rewards_per_func aggregates rewards across all processes. This is
+ # important because rewards will be normalized per group, and completions are distributed. We will later slice
+ # rewards_per_func to extract each process's subset.
+ rewards_per_func = self._calculate_rewards(inputs, prompts, completions, completion_ids_list)
+ num_generations = self.num_generations if mode == "train" else self.num_generations_eval
+
+ # A completion for which every reward function returned None is unscorable. nansum would collapse it to 0,
+ # which both biases the per-group baseline and hands the completion a spurious advantage. Mark these rows NaN
+ # so they're excluded from the (nan-aware) baseline below; their advantage is forced to 0 afterwards.
+ unscorable_mask = torch.isnan(rewards_per_func).all(dim=1)
+
+ if self.multi_objective_aggregation == "sum_then_normalize":
+ # Apply weights to each reward function's output and sum
+ rewards = (rewards_per_func * self.reward_weights.to(device).unsqueeze(0)).nansum(dim=1)
+ rewards[unscorable_mask] = torch.nan
+ mean_grouped_rewards = torch.nanmean(rewards.view(-1, num_generations), dim=1)
+ mean_grouped_rewards = mean_grouped_rewards.repeat_interleave(num_generations, dim=0)
+ if self.scale_rewards in ["group", "none"]:
+ # If self.scale_rewards = "none", we'll only use std_rewards to check for zero std for logging
+ if num_generations > 1:
+ std_rewards = nanstd(rewards.view(-1, num_generations), dim=1)
+ std_rewards = std_rewards.repeat_interleave(num_generations, dim=0)
+ else: # doesn't occur during training, but could occur in eval when num_generations_eval=1
+ std_rewards = torch.zeros_like(rewards)
+ elif self.scale_rewards == "batch":
+ # Compute global std
+ if rewards.numel() > 1:
+ std_rewards = nanstd(rewards).expand_as(rewards)
+ else: # doesn't occur during training, but could occur in eval when num_generations_eval=batch_size=1
+ std_rewards = torch.zeros_like(rewards)
+ else:
+ raise ValueError(
+ f"Invalid value for scale_rewards: {self.scale_rewards}. Must be one of 'batch', 'group', or 'none'."
+ )
+
+ advantages = rewards - mean_grouped_rewards
+ if self.scale_rewards != "none":
+ advantages = advantages / (std_rewards + 1e-4)
+ is_std_zero = torch.isclose(std_rewards, torch.zeros_like(std_rewards)) # for logging
+
+ elif self.multi_objective_aggregation == "normalize_then_sum":
+ grouped = rewards_per_func.view(-1, num_generations, len(self.reward_funcs))
+ mean_k = torch.nanmean(grouped, dim=1, keepdim=True)
+ std_k = nanstd(grouped, dim=1, keepdim=True) if num_generations > 1 else torch.zeros_like(mean_k)
+ reward_k = (grouped - mean_k) / (std_k + 1e-4)
+ reward_k = reward_k.view(-1, len(self.reward_funcs))
+ rewards = (reward_k * self.reward_weights.to(device).unsqueeze(0)).nansum(dim=1)
+ rewards[unscorable_mask] = torch.nan
+ std_rewards = nanstd(rewards).expand_as(rewards) if rewards.numel() > 1 else torch.zeros_like(rewards)
+ advantages = (rewards - torch.nanmean(rewards)) / (std_rewards + 1e-4)
+ is_std_zero = torch.isclose(std_rewards, torch.zeros_like(std_rewards)) # for logging
+
+ else:
+ raise ValueError(
+ f"Invalid multi_objective_aggregation: {self.multi_objective_aggregation}. Must be "
+ "'sum_then_normalize' or 'normalize_then_sum'."
+ )
+
+ # Unscorable completions (every reward func returned None) carry no learning signal: their reward is NaN here,
+ # so zero their advantage to keep them from moving the policy.
+ advantages = torch.nan_to_num(advantages, nan=0.0)
+
+ # Slice to keep only the local part of the data
+ process_slice = slice(
+ self.accelerator.process_index * len(prompts),
+ (self.accelerator.process_index + 1) * len(prompts),
+ )
+ all_process_advantages = advantages.clone() # keep the aggregated advantages for logging
+ advantages = advantages[process_slice]
+
+ # Calculate mean reward per function, but only for samples where the function was applied (non-NaN values)
+ for i, reward_func_name in enumerate(self.reward_func_names):
+ mean_rewards = torch.nanmean(rewards_per_func[:, i]).item()
+ self._metrics[mode][f"rewards/{reward_func_name}/mean"].append(mean_rewards)
+ std_func_rewards = nanstd(rewards_per_func[:, i]).item()
+ self._metrics[mode][f"rewards/{reward_func_name}/std"].append(std_func_rewards)
+ rewards = (rewards_per_func * self.reward_weights.to(rewards_per_func.device).unsqueeze(0)).nansum(dim=1)
+ rewards[unscorable_mask] = torch.nan # exclude unscorable rows from the logged reward stats
+ self._metrics[mode]["reward"].append(torch.nanmean(rewards).item())
+ self._metrics[mode]["reward_std"].append(nanstd(rewards).item())
+ self._metrics[mode]["frac_reward_zero_std"].append(is_std_zero.float().mean().item())
+
+ # Log prompt and completion texts
+ self._logs["prompt"].extend(gather_object(prompts_text))
+ self._logs["completion"].extend(gather_object(completions_text))
+ for i, name in enumerate(self.reward_func_names):
+ self._logs["rewards"][name].extend(rewards_per_func[:, i].tolist())
+ self._logs["advantages"].extend(all_process_advantages.tolist())
+
+ # Flush user-logged extra columns (from log_extra), gathering across processes.
+ # Keys must be sorted so that all ranks call gather_object in the same order, otherwise values
+ # get mis-attributed across columns (dict insertion order may differ between processes).
+ for column in sorted(self._pending_extra_logs):
+ self._logs["extra"][column].extend(gather_object(self._pending_extra_logs[column]))
+ self._pending_extra_logs.clear()
+
+ # Flush user-logged metrics (from log_metric), averaging across processes.
+ # Keys must be sorted so that all ranks call accelerator.gather in the same order, otherwise values
+ # get mis-attributed across metrics (dict insertion order may differ between processes).
+ for name in sorted(self._pending_metrics):
+ values = self._pending_metrics[name]
+ local_mean = sum(values) / len(values)
+ global_mean = self.accelerator.gather(torch.tensor(local_mean, device=device)).mean().item()
+ self._metrics[mode][name].append(global_mean)
+ self._pending_metrics.clear()
+
+ if images is not None:
+ self._logs["images"].extend(gather_object(images))
+
+ if self.use_vllm and self.vllm_importance_sampling_correction:
+ delta = torch.abs(old_per_token_logps - sampling_per_token_logps)
+ mask = completion_mask.bool() if tool_mask is None else (completion_mask * tool_mask).bool()
+ delta = delta[mask]
+ mean_delta = torch.mean(delta) if delta.numel() > 0 else torch.tensor(0.0, device=device)
+ max_delta = torch.max(delta) if delta.numel() > 0 else torch.tensor(0.0, device=device)
+ self._metrics[mode]["sampling/sampling_logp_difference/mean"].append(
+ self.accelerator.gather(mean_delta).mean().item()
+ )
+ self._metrics[mode]["sampling/sampling_logp_difference/max"].append(
+ self.accelerator.gather(max_delta).max().item()
+ )
+ if sequence_level_is:
+ flat_is_ratio = vllm_importance_sampling_ratio.flatten()
+ else:
+ flat_is_ratio = vllm_importance_sampling_ratio[mask]
+
+ min_importance_sampling_ratio = (
+ torch.min(flat_is_ratio) if flat_is_ratio.numel() > 0 else torch.tensor(0.0, device=device)
+ )
+ mean_importance_sampling_ratio = (
+ torch.mean(flat_is_ratio) if flat_is_ratio.numel() > 0 else torch.tensor(0.0, device=device)
+ )
+ max_importance_sampling_ratio = (
+ torch.max(flat_is_ratio) if flat_is_ratio.numel() > 0 else torch.tensor(0.0, device=device)
+ )
+ self._metrics[mode]["sampling/importance_sampling_ratio/min"].append(
+ nanmin(self.accelerator.gather(min_importance_sampling_ratio)).item()
+ )
+ self._metrics[mode]["sampling/importance_sampling_ratio/mean"].append(
+ self.accelerator.gather(mean_importance_sampling_ratio).nanmean().item()
+ )
+ self._metrics[mode]["sampling/importance_sampling_ratio/max"].append(
+ nanmax(self.accelerator.gather(max_importance_sampling_ratio)).item()
+ )
+
+ output = {
+ "prompt_ids": prompt_ids,
+ "prompt_mask": prompt_mask,
+ "completion_ids": completion_ids,
+ "completion_mask": completion_mask,
+ "advantages": advantages,
+ "num_items_in_batch": num_items_in_batch,
+ }
+ if old_per_token_logps is not None:
+ output["old_per_token_logps"] = old_per_token_logps
+ if self.use_vllm and self.vllm_importance_sampling_correction:
+ output["importance_sampling_ratio"] = vllm_importance_sampling_ratio
+ if sampling_per_token_logps is not None:
+ output["sampling_per_token_logps"] = sampling_per_token_logps
+ if ref_per_token_logps is not None:
+ output["ref_per_token_logps"] = ref_per_token_logps
+ if "pixel_values" in forward_kwargs:
+ output["pixel_values"] = forward_kwargs["pixel_values"]
+ if "image_grid_thw" in forward_kwargs:
+ output["image_grid_thw"] = forward_kwargs["image_grid_thw"]
+ if "pixel_attention_mask" in forward_kwargs:
+ output["pixel_attention_mask"] = forward_kwargs["pixel_attention_mask"]
+ if "image_sizes" in forward_kwargs:
+ output["image_sizes"] = forward_kwargs["image_sizes"]
+ if "token_type_ids" in forward_kwargs:
+ output["token_type_ids"] = forward_kwargs["token_type_ids"]
+ if "mm_token_type_ids" in forward_kwargs:
+ output["mm_token_type_ids"] = forward_kwargs["mm_token_type_ids"]
+ if "image_position_ids" in forward_kwargs:
+ output["image_position_ids"] = forward_kwargs["image_position_ids"]
+ if images is not None:
+ output["num_images"] = num_images
+ if tool_mask is not None:
+ output["tool_mask"] = tool_mask
+ return output
+
+ def compute_liger_loss(self, unwrapped_model, inputs):
+ # Compute the per-token log probabilities for the model
+ prompt_ids, prompt_mask = inputs["prompt_ids"], inputs["prompt_mask"]
+ completion_ids, completion_mask = inputs["completion_ids"], inputs["completion_mask"]
+ input_ids = torch.cat([prompt_ids, completion_ids], dim=1)
+ attention_mask = torch.cat([prompt_mask, completion_mask], dim=1)
+ logits_to_keep = completion_ids.size(1) # we only need to compute the logits for the completion tokens
+
+ # Get the last hidden state of the model
+ last_hidden_state = self._get_last_hidden_state(
+ unwrapped_model,
+ input_ids,
+ attention_mask,
+ logits_to_keep,
+ inputs.get("pixel_values"),
+ inputs.get("image_grid_thw"),
+ inputs.get("pixel_attention_mask"),
+ inputs.get("image_sizes"),
+ inputs.get("image_position_ids"),
+ )
+
+ # Apply tool_mask (from env_mask) for loss computation in multi-turn training scenarios
+ loss_mask = completion_mask if "tool_mask" not in inputs else completion_mask * inputs["tool_mask"]
+ lm_head_weight = unwrapped_model.lm_head.weight
+ lm_head_bias = unwrapped_model.lm_head.bias
+ # Liger reads `lm_head` directly instead of through `model.forward()`, so its ZeRO-3 gather hook never fires
+ # and the fused matmul gets an empty shard. Gather the weight/bias ourselves for the call (the weight grad is
+ # computed during this forward, so it isn't needed in the backward). Skip it when already gathered: with tied
+ # embeddings `embed_tokens` keeps the weight `AVAILABLE`, and re-partitioning on exit breaks its tracking.
+ deepspeed_plugin = self.accelerator.state.deepspeed_plugin
+ gather_ctx = nullcontext()
+ if deepspeed_plugin is not None and deepspeed_plugin.zero_stage == 3:
+ from deepspeed.runtime.zero.partition_parameters import ZeroParamStatus
+
+ params = [lm_head_weight] if lm_head_bias is None else [lm_head_weight, lm_head_bias]
+ if any(p.ds_status != ZeroParamStatus.AVAILABLE for p in params):
+ import deepspeed
+
+ gather_ctx = deepspeed.zero.GatheredParameters(params, modifier_rank=None)
+ with gather_ctx:
+ loss, metrics = self.liger_grpo_loss(
+ _input=last_hidden_state,
+ lin_weight=lm_head_weight,
+ selected_token_ids=completion_ids,
+ # The attention_mask parameter in liger loss is actually used as a loss mask (not model attention)
+ attention_mask=loss_mask,
+ advantages=inputs["advantages"],
+ bias=lm_head_bias,
+ old_per_token_logps=inputs.get("old_per_token_logps"),
+ ref_per_token_logps=inputs.get("ref_per_token_logps"),
+ vllm_is_ratio=inputs.get("importance_sampling_ratio"),
+ )
+ # Extract metrics from the liger_grpo_loss output
+ # KL divergence is the first metric when beta is non-zero
+ mean_kl = metrics[0] if self.beta != 0.0 else None
+ clip_ratio = metrics[-1]
+
+ mode = "train" if self.model.training else "eval"
+ if self.beta != 0.0:
+ self._metrics[mode]["kl"].append(self.accelerator.gather(mean_kl).mean().item())
+ self._metrics[mode]["clip_ratio"].append(self.accelerator.gather(clip_ratio).mean().item())
+ normalizer = self.current_gradient_accumulation_steps if mode == "train" else 1.0 # no accum in eval
+ return loss / normalizer
+
+ @profiling_decorator
+ def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
+ if return_outputs:
+ raise ValueError("The GRPOTrainer does not support returning outputs")
+ if self.use_liger_kernel:
+ # Compute the loss using the liger grpo loss
+ unwrapped_model = self.accelerator.unwrap_model(model)
+ return self._forward_redirection(model, unwrapped_model, self.compute_liger_loss, unwrapped_model, inputs)
+ return self._compute_loss(model, inputs)
+
+ @staticmethod
+ def get_off_policy_mask(
+ advantages: torch.Tensor,
+ per_token_logps: torch.Tensor,
+ sampling_per_token_logps: torch.Tensor,
+ mask: torch.Tensor,
+ off_policy_threshold: float,
+ ) -> torch.Tensor:
+ """
+ Computes the Off-Policy Sequence Mask from DeepSeek-V3.2 paper. Returns a (B, 1) tensor where 1.0 indicates
+ "Keep" and 0.0 indicates "Drop".
+ """
+ # forward KL div: log(pi_old) - log(pi_theta)
+ kl_div = sampling_per_token_logps - per_token_logps.detach()
+ # Sequence-level Mean KL (ignoring prompt+padding)
+ seq_kl_sum = (kl_div * mask).sum(dim=1, keepdim=True)
+ avg_seq_kl = seq_kl_sum / mask.sum(dim=1, keepdim=True).clamp(min=1.0)
+ # Keep if (Advantage >= 0) OR (KL <= delta)
+ is_pos_adv = advantages >= 0
+ is_low_kl = avg_seq_kl <= off_policy_threshold
+ return (is_pos_adv | is_low_kl).to(dtype=mask.dtype) # (B, 1)
+
+ @staticmethod
+ @torch.no_grad()
+ def get_gamma_weights(
+ advantages: torch.Tensor,
+ log_ratio_per_token: torch.Tensor,
+ mask: torch.Tensor,
+ importance_sampling_ratio: torch.Tensor | None, # (B, T)
+ k_pos: float = 2.0,
+ lambda_pos: float = 3.0,
+ k_neg: float = 3.0,
+ lambda_neg: float = 2.0,
+ ) -> torch.Tensor:
+ """
+ Computes the Gamma weights for the VESPO loss. For reference:
+ φ(w) = e^λ × w^k × e^{-λw} is the gamma weighting (normalized so φ(1)=1)
+ with w = sequence-level importance sampling ratio
+ note: we will compute φ(w) in log space
+
+ φ(w) is detached via @torch.no_grad(), only acts as gradient scaling coefficient
+
+ VESPO loss = -φ(w) × A × log_prob, gradient naturally gives φ(w) × A × ∇log π
+ """
+ # reducing clamp range directly to log(1e-8) ~ -18.42, to avoid recomputing log_w=log(w.clamp(min=1e-8)) later
+ # This is solely for matching truthfully the original implementation, otherwise keeping -20 could be fine.
+ lower_clamp = math.log(1e-8)
+
+ # Sequence-level log ratio Σ log(π_θ/π_old) (not a mean like for `log_importance_weights`)
+ log_ratio_clamped = torch.clamp(log_ratio_per_token, -20.0, 20.0)
+ seq_log_ratio = torch.sum(log_ratio_clamped * mask, dim=-1, keepdim=True) # (B, 1)
+
+ # Apply token-level TIS or MIS correction (in log space)
+ if importance_sampling_ratio is not None:
+ log_is_ratio = torch.clamp(torch.log(importance_sampling_ratio), lower_clamp, 20.0)
+ # log(w) = log(π_θ/π_old) + log(π_old/π_sampler)
+ seq_log_ratio += torch.sum(log_is_ratio, dim=-1, keepdim=True)
+
+ log_w_seq = torch.clamp(seq_log_ratio, lower_clamp, 20.0)
+ w_seq = torch.exp(log_w_seq)
+
+ # compute k and lambda based on advantage sign
+ is_nonneg_adv = advantages >= 0
+ k_seq = torch.where(is_nonneg_adv, k_pos, k_neg)
+ lambda_seq = torch.where(is_nonneg_adv, lambda_pos, lambda_neg).clamp(min=1e-4)
+
+ # log(φ(w)) = λ + k × log(w) - λ × w
+ log_phi = lambda_seq + k_seq * log_w_seq - lambda_seq * w_seq
+ phi_seq = torch.exp(log_phi).nan_to_num(nan=0.0, posinf=0.0, neginf=0.0)
+
+ return phi_seq # (B, 1)
+
+ def _compute_loss(self, model, inputs):
+ # Compute the per-token log probabilities for the model
+ prompt_ids, prompt_mask = inputs["prompt_ids"], inputs["prompt_mask"]
+ completion_ids, completion_mask = inputs["completion_ids"], inputs["completion_mask"]
+ input_ids = torch.cat([prompt_ids, completion_ids], dim=1)
+ attention_mask = torch.cat([prompt_mask, completion_mask], dim=1)
+ logits_to_keep = completion_ids.size(1) # we only need to compute the logits for the completion tokens
+ mask = completion_mask if "tool_mask" not in inputs else completion_mask * inputs["tool_mask"]
+
+ # Compute the per_token_logps and the entropy at each position in the completion
+ per_token_logps, entropies, aux_loss = self._get_per_token_logps_and_entropies(
+ model,
+ input_ids,
+ attention_mask,
+ logits_to_keep,
+ compute_entropy=True,
+ compute_aux_loss=self.aux_loss_enabled,
+ pixel_values=inputs.get("pixel_values"),
+ image_grid_thw=inputs.get("image_grid_thw"),
+ num_images=inputs.get("num_images"),
+ pixel_attention_mask=inputs.get("pixel_attention_mask"),
+ image_sizes=inputs.get("image_sizes"),
+ token_type_ids=inputs.get("token_type_ids"),
+ mm_token_type_ids=inputs.get("mm_token_type_ids"),
+ image_position_ids=inputs.get("image_position_ids"),
+ )
+
+ if self.top_entropy_quantile < 1.0:
+ entropy_mask = self.get_high_entropy_mask(entropies, mask, 1 - self.top_entropy_quantile)
+ else:
+ entropy_mask = None
+
+ # Compute the loss
+ advantages = inputs["advantages"]
+ # In the base GRPO implementation, advantages are expected to have shape (B,). To support subclasses that
+ # provide advantages with shape (B, T) (e.g., MiniLLM), we *conditionally* unsqueeze the tensor.
+ if advantages.dim() == 1:
+ advantages = advantages.unsqueeze(1)
+ # When num_iterations == 1 and steps_per_generation <= gradient_accumulation_steps,
+ # old_per_token_logps == per_token_logps. In this case we can skip its computation
+ # (see _generate_and_score_completions) and instead use per_token_logps.detach().
+ # The exception is when using vLLM, where we always compute old_per_token_logps
+ # for importance sampling
+ old_per_token_logps = inputs.get("old_per_token_logps")
+ old_per_token_logps = per_token_logps.detach() if old_per_token_logps is None else old_per_token_logps
+
+ if self.off_policy_mask_threshold is not None:
+ # OPSM should use inference-time logprobs to detect both sources of off-policyness:
+ # 1. Drift from gradient updates (always present)
+ # 2. Drift from training-inference mismatch (when using vLLM)
+ # When using vLLM, prioritize sampling_per_token_logps, otherwise use old_per_token_logps
+ sampling_per_token_logps = inputs.get("sampling_per_token_logps", old_per_token_logps)
+
+ off_policy_mask = self.get_off_policy_mask(
+ advantages=advantages,
+ per_token_logps=per_token_logps,
+ sampling_per_token_logps=sampling_per_token_logps,
+ mask=mask,
+ off_policy_threshold=self.off_policy_mask_threshold,
+ )
+
+ log_ratio = per_token_logps - old_per_token_logps
+ if self.importance_sampling_level == "token":
+ log_importance_weights = log_ratio
+ elif self.importance_sampling_level == "sequence":
+ log_importance_weights = (log_ratio * mask).sum(-1) / mask.sum(-1).clamp(min=1.0)
+ log_importance_weights = log_importance_weights.unsqueeze(-1)
+ else:
+ raise ValueError(
+ f"Unknown importance sampling level: {self.importance_sampling_level}. Possible values are 'token' "
+ "and 'sequence'."
+ )
+
+ coef_1 = torch.exp(log_importance_weights)
+
+ # Compute the KL divergence between the model and the reference model
+ if self.beta != 0.0:
+ ref_per_token_logps = inputs["ref_per_token_logps"]
+ per_token_kl = (
+ torch.exp(ref_per_token_logps - per_token_logps) - (ref_per_token_logps - per_token_logps) - 1
+ )
+ # Importance sampling correction for the KL divergence
+ if self.args.use_bias_correction_kl:
+ per_token_kl = per_token_kl * coef_1
+
+ # From here, log_importance_weights (and all subsequent tensors, coef_1, coef_2, etc.) shape depends on
+ # importance_sampling_level: "token" level: (B, T); "sequence" level: (B, 1)
+ if self.loss_type == "cispo":
+ clamped_ratios = torch.clamp(coef_1, max=self.epsilon_high).detach()
+ per_token_loss = -clamped_ratios * advantages * per_token_logps
+ elif self.loss_type in ["grpo", "bnpo", "dr_grpo", "dapo", "luspo"]:
+ coef_2 = torch.clamp(coef_1, 1 - self.epsilon_low, 1 + self.epsilon_high)
+ # Two-sided clipping
+ if self.args.delta is not None:
+ coef_1 = torch.clamp(coef_1, max=self.args.delta)
+
+ per_token_loss1 = coef_1 * advantages
+ per_token_loss2 = coef_2 * advantages
+ per_token_loss = -torch.min(per_token_loss1, per_token_loss2)
+ elif self.loss_type == "sapo":
+ temperatures = torch.where(advantages > 0, self.args.sapo_temperature_pos, self.args.sapo_temperature_neg)
+ soft_coef_1 = torch.sigmoid(temperatures * (coef_1 - 1)) * 4 / temperatures
+ per_token_loss = -soft_coef_1 * advantages
+ elif self.loss_type == "vespo":
+ phi_seq = self.get_gamma_weights(
+ advantages=advantages,
+ log_ratio_per_token=log_ratio,
+ mask=mask,
+ importance_sampling_ratio=inputs.get("importance_sampling_ratio"),
+ k_pos=self.args.vespo_k_pos,
+ lambda_pos=self.args.vespo_lambda_pos,
+ k_neg=self.args.vespo_k_neg,
+ lambda_neg=self.args.vespo_lambda_neg,
+ )
+ per_token_loss = -phi_seq * advantages * per_token_logps
+ else:
+ raise ValueError(f"Unknown loss type: {self.loss_type}")
+
+ if self.off_policy_mask_threshold is not None:
+ per_token_loss = per_token_loss * off_policy_mask
+
+ if entropy_mask is not None:
+ per_token_loss = per_token_loss * entropy_mask
+
+ if self.use_vllm and self.vllm_importance_sampling_correction and self.loss_type != "vespo":
+ per_token_loss = per_token_loss * inputs["importance_sampling_ratio"]
+
+ if self.beta != 0.0:
+ per_token_loss = per_token_loss + self.beta * per_token_kl
+
+ mode = "train" if self.model.training else "eval"
+ if self.loss_type in ["grpo", "sapo"]:
+ loss = ((per_token_loss * mask).sum(-1) / mask.sum(-1).clamp(min=1.0)).mean()
+ normalizer = self.current_gradient_accumulation_steps if mode == "train" else 1.0 # no accum in eval
+ loss = loss / normalizer
+ elif self.loss_type == "bnpo":
+ loss = (per_token_loss * mask).sum() / mask.sum().clamp(min=1.0)
+ normalizer = self.current_gradient_accumulation_steps if mode == "train" else 1.0 # no accum in eval
+ loss = loss / normalizer
+ elif self.loss_type == "dr_grpo":
+ loss = (per_token_loss * mask).sum() / (per_token_loss.size(0) * self.max_completion_length)
+ normalizer = self.current_gradient_accumulation_steps if mode == "train" else 1.0 # no accum in eval
+ loss = loss / normalizer
+ elif self.loss_type in ["cispo", "dapo", "vespo"]:
+ normalizer = inputs["num_items_in_batch"] / self.accelerator.num_processes
+ loss = (per_token_loss * mask).sum() / normalizer
+ elif self.loss_type == "luspo":
+ # Unless importance_sampling_level="token" (not recommended here), per_token_loss is expected to be (B, 1)
+ loss = (per_token_loss * mask.sum(1, keepdim=True)).mean()
+ normalizer = self.current_gradient_accumulation_steps if mode == "train" else 1.0
+ loss = loss / normalizer
+ else:
+ raise ValueError(f"Unknown loss type: {self.loss_type}")
+
+ # The policy loss above is scaled for gradient accumulation (HF auto-scaling is off here), so scale aux too
+ if self.aux_loss_enabled:
+ normalizer = self.current_gradient_accumulation_steps if mode == "train" else 1.0
+ loss = loss + self.router_aux_loss_coef * aux_loss / normalizer
+ self._metrics[mode]["aux_loss"].append(self.accelerator.gather_for_metrics(aux_loss).mean().item())
+
+ # Log the metrics
+ completion_token_count = mask.sum().clamp(min=1.0)
+
+ def masked_batch_mean(x):
+ if x.shape[1] == 1: # when importance_sampling_level == "sequence"
+ return x.mean()
+ else:
+ return (x * mask).sum() / completion_token_count
+
+ if self.beta != 0.0:
+ mean_kl = masked_batch_mean(per_token_kl)
+ self._metrics[mode]["kl"].append(self.accelerator.gather(mean_kl).nanmean().item())
+
+ mean_entropy = masked_batch_mean(entropies)
+ self._metrics[mode]["entropy"].append(self.accelerator.gather(mean_entropy).nanmean().item())
+
+ if self.loss_type in ["grpo", "bnpo", "dr_grpo", "dapo", "luspo"]:
+ # Compute the clipped probability ratios
+ is_low_clipped = (coef_1 < 1 - self.epsilon_low) & (advantages < 0)
+ is_high_clipped = (coef_1 > 1 + self.epsilon_high) & (advantages > 0)
+ is_region_clipped = is_low_clipped | is_high_clipped
+
+ low_clip = masked_batch_mean(is_low_clipped.float())
+ high_clip = masked_batch_mean(is_high_clipped.float())
+ clip_ratio = masked_batch_mean(is_region_clipped.float())
+
+ gathered_low_clip = self.accelerator.gather(low_clip)
+ self._metrics[mode]["clip_ratio/low_mean"].append(gathered_low_clip.nanmean().item())
+ self._metrics[mode]["clip_ratio/low_min"].append(nanmin(gathered_low_clip).item())
+ gathered_high_clip = self.accelerator.gather(high_clip)
+ self._metrics[mode]["clip_ratio/high_mean"].append(gathered_high_clip.nanmean().item())
+ self._metrics[mode]["clip_ratio/high_max"].append(nanmax(gathered_high_clip).item())
+ gathered_clip_ratio = self.accelerator.gather(clip_ratio)
+ self._metrics[mode]["clip_ratio/region_mean"].append(gathered_clip_ratio.nanmean().item())
+ elif self.loss_type == "cispo":
+ is_cispo_clipped = (coef_1 > self.epsilon_high) & (advantages > 0)
+ cispo_clip_ratio = masked_batch_mean(is_cispo_clipped.float())
+ gathered_cispo_clip_ratio = self.accelerator.gather(cispo_clip_ratio)
+ self._metrics[mode]["cispo_clip_ratio"].append(gathered_cispo_clip_ratio.nanmean().item())
+ elif self.loss_type == "vespo":
+ gathered_phi_seq = self.accelerator.gather(phi_seq)
+ self._metrics[mode]["vespo/phi_seq_mean"].append(gathered_phi_seq.nanmean().item())
+
+ return loss
+
+ # During eval, Trainer calls prediction_step. If no labels are present in the inputs, it only runs forward and
+ # returns logits. We override prediction_step to force compute_loss, because this trainer doesn't involve labels.
+ def prediction_step(self, model, inputs, prediction_loss_only, ignore_keys: list[str] | None = None):
+ inputs = self._prepare_inputs(inputs)
+ with torch.no_grad():
+ with self.compute_loss_context_manager():
+ loss = self.compute_loss(model, inputs)
+ loss = loss.mean().detach()
+ return loss, None, None
+
+ def log(self, logs: dict[str, float], start_time: float | None = None) -> None:
+ mode = "train" if self.model.training else "eval"
+ # Average the metrics
+ metrics = {}
+ for key, val in self._metrics[mode].items():
+ # Filter out NaN values before averaging. A reward function that returns None for all samples
+ # in a batch produces NaN for that batch's metric. With logging_steps > 1, a naive sum()/len()
+ # would let a single NaN contaminate valid data from other batches. Only return None when no
+ # valid values remain (e.g. JSON loggers crash on float NaN).
+ valid = [v for v in val if not math.isnan(v)]
+ metrics[key] = sum(valid) / len(valid) if valid else None
+
+ # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs`
+ # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format.
+ if mode == "eval":
+ metrics = {f"eval_{key}": val for key, val in metrics.items()}
+
+ logs.update(metrics)
+ super().log(logs, start_time)
+ self._metrics[mode].clear()
+
+ if self.accelerator.is_main_process and self.log_completions:
+ if is_rich_available():
+ print_prompt_completions_sample(
+ self._logs["prompt"],
+ self._logs["completion"],
+ self._logs["rewards"],
+ self._logs["advantages"],
+ self.state.global_step,
+ self.num_completions_to_print,
+ extra=dict(self._logs["extra"]),
+ )
+
+ logging_backends = []
+ if self.args.report_to and "wandb" in self.args.report_to and wandb.run is not None:
+ logging_backends.append(wandb)
+ if self.args.report_to and "trackio" in self.args.report_to:
+ logging_backends.append(trackio)
+
+ table = {
+ "step": [self.state.global_step] * len(self._logs["prompt"]),
+ "prompt": self._logs["prompt"],
+ "completion": self._logs["completion"],
+ **self._logs["rewards"],
+ **self._logs["extra"],
+ "advantage": self._logs["advantages"],
+ }
+
+ df_base = pd.DataFrame(table)
+ df_base.to_parquet(
+ os.path.join(
+ self.args.output_dir,
+ "completions",
+ f"completions_{self.state.global_step:05d}.parquet",
+ )
+ )
+
+ images_raw = self._logs["images"] or []
+
+ for logging_backend in logging_backends:
+ if images_raw:
+ images = []
+ for image_list in self._logs["images"]:
+ if image_list:
+ images.append([logging_backend.Image(image) for image in image_list])
+ else:
+ images.append([])
+ df = pd.concat(
+ [df_base, pd.Series(images, name="image")],
+ axis=1,
+ copy=False,
+ )
+ else:
+ df = df_base
+
+ if self.log_unique_prompts:
+ df = df.drop_duplicates(subset=["prompt"])
+
+ logging_backend.log({"completions": logging_backend.Table(dataframe=df)})
+
+ # Ensure the model card is saved along with the checkpoint
+ def _save_checkpoint(self, model, trial):
+ if self.args.hub_model_id is None:
+ model_name = Path(self.args.output_dir).name
+ else:
+ model_name = self.args.hub_model_id.split("/")[-1]
+ self.create_model_card(model_name=model_name)
+ super()._save_checkpoint(model, trial)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/kto_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/kto_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..849648a8f74f245df98cab016a7b87fa1b628f93
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/kto_config.py
@@ -0,0 +1,36 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import warnings
+from dataclasses import dataclass
+
+from ..import_utils import suppress_experimental_warning
+
+
+with suppress_experimental_warning():
+ from ..experimental.kto import KTOConfig as _KTOConfig
+
+
+@dataclass
+class KTOConfig(_KTOConfig):
+ def __post_init__(self):
+ warnings.warn(
+ "The `KTOConfig` is now located in `trl.experimental`. Please update your imports to "
+ "`from trl.experimental.kto import KTOConfig`. For more information, see "
+ "https://github.com/huggingface/trl/issues/4223. Promoting KTO to the stable API is a high-priority task. "
+ "Until then, this current path (`from trl import KTOConfig`) will remain, but API changes may occur.",
+ FutureWarning,
+ stacklevel=3,
+ )
+ super().__post_init__()
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/kto_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/kto_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..110e29f0a8062efe09a87cddf2a7574d4f8d999e
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/kto_trainer.py
@@ -0,0 +1,36 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import warnings
+from dataclasses import dataclass
+
+from ..import_utils import suppress_experimental_warning
+
+
+with suppress_experimental_warning():
+ from ..experimental.kto import KTOTrainer as _KTOTrainer
+
+
+@dataclass
+class KTOTrainer(_KTOTrainer):
+ def __init__(self, *args, **kwargs):
+ warnings.warn(
+ "The `KTOTrainer` is now located in `trl.experimental`. Please update your imports to "
+ "`from trl.experimental.kto import KTOTrainer`. For more information, see "
+ "https://github.com/huggingface/trl/issues/4223. Promoting KTO to the stable API is a high-priority task. "
+ "Until then, this current path (`from trl import KTOTrainer`) will remain, but API changes may occur.",
+ FutureWarning,
+ stacklevel=2,
+ )
+ super().__init__(*args, **kwargs)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/model_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/model_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..c64d7a9ccade1cc7adb27dbd73742ee888714fb1
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/model_config.py
@@ -0,0 +1,178 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ModelConfig:
+ """
+ Configuration class for the models.
+
+ Using [`~transformers.HfArgumentParser`] we can turn this class into
+ [argparse](https://docs.python.org/3/library/argparse#module-argparse) arguments that can be specified on the
+ command line.
+
+ Parameters:
+ model_name_or_path (`str`, *optional*):
+ Model checkpoint for weights initialization.
+ model_revision (`str`, *optional*, defaults to `"main"`):
+ Specific model version to use. It can be a branch name, a tag name, or a commit id.
+ dtype (`Literal["auto", "bfloat16", "float16", "float32"]`, *optional*, defaults to `"float32"`):
+ Override the default `torch.dtype` and load the model under this dtype. Possible values are
+
+ - `"bfloat16"`: `torch.bfloat16`
+ - `"float16"`: `torch.float16`
+ - `"float32"`: `torch.float32`
+ - `"auto"`: Automatically derive the dtype from the model's weights.
+
+ attn_implementation (`str`, *optional*):
+ Which attention implementation to use. More information in the [Kernels Hub Integrations
+ Guide](kernels_hub).
+ use_peft (`bool`, *optional*, defaults to `False`):
+ Whether to use PEFT for training.
+ lora_r (`int`, *optional*, defaults to `16`):
+ LoRA R value.
+ lora_alpha (`int`, *optional*, defaults to `32`):
+ LoRA alpha.
+ lora_dropout (`float`, *optional*, defaults to `0.05`):
+ LoRA dropout.
+ lora_target_modules (`str | list[str]`, *optional*):
+ LoRA target modules.
+ lora_target_parameters (`str | list[str]`, *optional*):
+ List of target parameters for LoRA.
+ lora_modules_to_save (`list[str]`, *optional*):
+ Model layers to unfreeze & train.
+ lora_task_type (`str`, *optional*, defaults to `"CAUSAL_LM"`):
+ Task type to pass for LoRA (use `"SEQ_CLS"` for reward modeling).
+ use_rslora (`bool`, *optional*, defaults to `False`):
+ Whether to use Rank-Stabilized LoRA, which sets the adapter scaling factor to `lora_alpha/√r`, instead of
+ the original default value of `lora_alpha/r`.
+ use_dora (`bool`, *optional*, defaults to `False`):
+ Enable [Weight-Decomposed Low-Rank Adaptation (DoRA)](https://huggingface.co/papers/2402.09353). This
+ technique decomposes the updates of the weights into two parts, magnitude and direction. Direction is
+ handled by normal LoRA, whereas the magnitude is handled by a separate learnable parameter. This can
+ improve the performance of LoRA, especially at low ranks. Right now, DoRA only supports linear and Conv2D
+ layers. DoRA introduces a bigger overhead than pure LoRA, so it is recommended to merge weights for
+ inference.
+ load_in_8bit (`bool`, *optional*, defaults to `False`):
+ Whether to use 8 bit precision for the base model. Works only with LoRA.
+ load_in_4bit (`bool`, *optional*, defaults to `False`):
+ Whether to use 4 bit precision for the base model. Works only with LoRA.
+ bnb_4bit_quant_type (`str`, *optional*, defaults to `"nf4"`):
+ Quantization type (`"fp4"` or `"nf4"`).
+ use_bnb_nested_quant (`bool`, *optional*, defaults to `False`):
+ Whether to use nested quantization.
+ bnb_4bit_quant_storage (`str`, *optional*):
+ Quantization storage dtype.
+ """
+
+ model_name_or_path: str | None = field(
+ default=None,
+ metadata={"help": "Model checkpoint for weights initialization."},
+ )
+ model_revision: str = field(
+ default="main",
+ metadata={"help": "Specific model version to use. It can be a branch name, a tag name, or a commit id."},
+ )
+ dtype: str | None = field(
+ default="float32",
+ metadata={
+ "help": "Override the default `torch.dtype` and load the model under this dtype. It defaults to `'float32'`.",
+ "choices": ["auto", "bfloat16", "float16", "float32"],
+ },
+ )
+ attn_implementation: str | None = field(
+ default=None,
+ metadata={
+ "help": "Which attention implementation to use. You can run `--attn_implementation=flash_attention_2`, in "
+ "which case you must install this manually by running `pip install flash-attn --no-build-isolation`."
+ },
+ )
+ use_peft: bool = field(
+ default=False,
+ metadata={"help": "Whether to use PEFT for training."},
+ )
+ lora_r: int = field(
+ default=16,
+ metadata={"help": "LoRA R value."},
+ )
+ lora_alpha: int = field(
+ default=32,
+ metadata={"help": "LoRA alpha."},
+ )
+ lora_dropout: float = field(
+ default=0.05,
+ metadata={"help": "LoRA dropout."},
+ )
+ lora_target_modules: list[str] | None = field(
+ default=None,
+ metadata={"help": "LoRA target modules."},
+ )
+ lora_target_parameters: list[str] | None = field(
+ default=None,
+ metadata={"help": "List of target parameters for LoRA."},
+ )
+ lora_modules_to_save: list[str] | None = field(
+ default=None,
+ metadata={"help": "Model layers to unfreeze & train."},
+ )
+ lora_task_type: str = field(
+ default="CAUSAL_LM",
+ metadata={"help": "Task type to pass for LoRA (use 'SEQ_CLS' for reward modeling)."},
+ )
+ use_rslora: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to use Rank-Stabilized LoRA, which sets the adapter scaling factor to `lora_alpha/√r`, "
+ "instead of the original default value of `lora_alpha/r`."
+ },
+ )
+ use_dora: bool = field(
+ default=False,
+ metadata={
+ "help": "Enable Weight-Decomposed Low-Rank Adaptation (DoRA). This technique decomposes the updates of "
+ "the weights into two parts, magnitude and direction. Direction is handled by normal LoRA, whereas the "
+ "magnitude is handled by a separate learnable parameter. This can improve the performance of LoRA, "
+ "especially at low ranks. Right now, DoRA only supports linear and Conv2D layers. DoRA introduces a "
+ "bigger overhead than pure LoRA, so it is recommended to merge weights for inference."
+ },
+ )
+ load_in_8bit: bool = field(
+ default=False,
+ metadata={"help": "Whether to use 8 bit precision for the base model. Works only with LoRA."},
+ )
+ load_in_4bit: bool = field(
+ default=False,
+ metadata={"help": "Whether to use 4 bit precision for the base model. Works only with LoRA."},
+ )
+ bnb_4bit_quant_type: str = field(
+ default="nf4",
+ metadata={"help": "Quantization type.", "choices": ["fp4", "nf4"]},
+ )
+ use_bnb_nested_quant: bool = field(
+ default=False,
+ metadata={"help": "Whether to use nested quantization."},
+ )
+ bnb_4bit_quant_storage: str | None = field(
+ default=None,
+ metadata={"help": "Quantization storage dtype"},
+ )
+
+ def __post_init__(self):
+ if self.load_in_8bit and self.load_in_4bit:
+ raise ValueError("You can't use 8 bit and 4 bit precision at the same time")
+
+ if hasattr(self.lora_target_modules, "__len__") and len(self.lora_target_modules) == 1:
+ self.lora_target_modules = self.lora_target_modules[0]
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/reward_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/reward_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..af36bca3df5e9f79f86248890139b4251f580124
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/reward_config.py
@@ -0,0 +1,183 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import warnings
+from dataclasses import dataclass, field
+from typing import Any
+
+from .base_config import _BaseConfig
+
+
+@dataclass
+class RewardConfig(_BaseConfig):
+ # docstyle-ignore
+ r"""
+ Configuration class for the [`RewardTrainer`].
+
+ This class includes only the parameters that are specific to Reward training. For a full list of training
+ arguments, please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this
+ class may differ from those in [`~transformers.TrainingArguments`].
+
+ Using [`~transformers.HfArgumentParser`] we can turn this class into
+ [argparse](https://docs.python.org/3/library/argparse#module-argparse) arguments that can be specified on the
+ command line.
+
+ Parameters:
+ > Parameters that control the model
+
+ model_init_kwargs (`dict[str, Any]`, *optional*):
+ Keyword arguments for [`~transformers.AutoModelForCausalLM.from_pretrained`], used when the `model`
+ argument of the [`RewardTrainer`] is provided as a string.
+ trust_remote_code (`bool`, *optional*, defaults to `False`):
+ Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to
+ [`~transformers.AutoModelForSequenceClassification.from_pretrained`] and
+ [`~transformers.AutoTokenizer.from_pretrained`].
+ chat_template_path (`str`, *optional*):
+ If specified, sets the model's chat template. This can either be the path to a tokenizer (local directory
+ or Hugging Face Hub model) or a direct path to a Jinja template file. When using a Jinja file, you must
+ ensure that any special tokens referenced in the template are added to the tokenizer and that the model's
+ embedding layer is resized accordingly.
+ disable_dropout (`bool`, *optional*, defaults to `True`):
+ Whether to disable dropout in the model.
+
+ > Parameters that control the data preprocessing
+
+ dataset_num_proc (`int`, *optional*):
+ Number of processes to use for processing the dataset.
+ eos_token (`str`, *optional*):
+ Token used to indicate the end of a turn or sequence. If `None`, it defaults to
+ `processing_class.eos_token`.
+ max_length (`int` or `None`, *optional*, defaults to `1024`):
+ Maximum length of the tokenized sequence. Samples are filtered out if either chosen or rejected sequence
+ exceeds this value. If `None`, no filtering is applied.
+ pad_to_multiple_of (`int`, *optional*):
+ If set, the sequences will be padded to a multiple of this value.
+
+ > Parameters that control the training
+
+ center_rewards_coefficient (`float`, *optional*):
+ Coefficient to incentivize the reward model to output mean-zero rewards (proposed by
+ https://huggingface.co/papers/2312.09244, Eq. 2). Recommended value: `0.01`.
+ activation_offloading (`bool`, *optional*, defaults to `False`):
+ Whether to offload the activations to the CPU.
+
+ > Deprecated parameters
+
+ pad_token:
+
+
+
+ Parameter `pad_token` is deprecated and will be removed in version v2.0.0. Set `tokenizer.pad_token`
+ directly and pass it as `processing_class` to the trainer instead.
+
+
+
+ > [!NOTE]
+ > These parameters have default values different from [`~transformers.TrainingArguments`]:
+ > - `logging_steps`: Defaults to `10` instead of `500`.
+ > - `gradient_checkpointing`: Defaults to `True` instead of `False`.
+ > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`.
+ > - `learning_rate`: Defaults to `1e-4` instead of `5e-5`.
+ """
+
+ _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs"]
+
+ # Parameters whose default values are overridden from TrainingArguments
+ learning_rate: float = field(
+ default=1e-4,
+ metadata={"help": "The initial learning rate for AdamW."},
+ )
+
+ # Parameters that control the model
+ model_init_kwargs: dict[str, Any] | str | None = field(
+ default=None,
+ metadata={
+ "help": "Keyword arguments for `AutoModelForCausalLM.from_pretrained`, used when the `model` argument of "
+ "the `RewardTrainer` is provided as a string."
+ },
+ )
+ trust_remote_code: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. "
+ "Forwarded to `AutoModelForSequenceClassification.from_pretrained` and `AutoTokenizer.from_pretrained`."
+ },
+ )
+ chat_template_path: str | None = field(
+ default=None,
+ metadata={
+ "help": "If specified, sets the model's chat template. This can either be the path to a tokenizer (local "
+ "directory or Hugging Face Hub model) or a direct path to a Jinja template file. When using a Jinja file, "
+ "you must ensure that any special tokens referenced in the template are added to the tokenizer and "
+ "that the model's embedding layer is resized accordingly."
+ },
+ )
+ disable_dropout: bool = field(
+ default=True,
+ metadata={"help": "Whether to disable dropout in the model."},
+ )
+
+ # Parameters that control the data preprocessing
+ dataset_num_proc: int | None = field(
+ default=None,
+ metadata={"help": "Number of processes to use for processing the dataset."},
+ )
+ eos_token: str | None = field(
+ default=None,
+ metadata={
+ "help": "Token used to indicate the end of a turn or sequence. If `None`, it defaults to `processing_class.eos_token`."
+ },
+ )
+ max_length: int | None = field(
+ default=1024,
+ metadata={
+ "help": "Maximum length of the tokenized sequence. Sequences longer than `max_length` are truncated from "
+ "the right. If `None`, no truncation is applied."
+ },
+ )
+ pad_to_multiple_of: int | None = field(
+ default=None,
+ metadata={"help": "If set, the sequences will be padded to a multiple of this value."},
+ )
+
+ # Parameters that control the training
+ center_rewards_coefficient: float | None = field(
+ default=None,
+ metadata={
+ "help": "Coefficient to incentivize the reward model to output mean-zero rewards (proposed by "
+ "https://huggingface.co/papers/2312.09244, Eq. 2). Recommended value: `0.01`."
+ },
+ )
+ activation_offloading: bool = field(
+ default=False,
+ metadata={"help": "Whether to offload the activations to the CPU."},
+ )
+
+ # Deprecated parameters
+ pad_token: str | None = field(
+ default=None,
+ metadata={
+ "help": "Deprecated. Set `tokenizer.pad_token` directly and pass it as `processing_class` to the trainer instead."
+ },
+ )
+
+ def __post_init__(self):
+ super().__post_init__()
+ if self.pad_token is not None:
+ warnings.warn(
+ "`pad_token` is deprecated and will be removed in v2.0.0. "
+ "Set `tokenizer.pad_token` directly and pass it as `processing_class` to the trainer instead.",
+ FutureWarning,
+ stacklevel=3,
+ )
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/reward_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/reward_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfa6254f97c06a47ac8253db40b70448a4941f21
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/reward_trainer.py
@@ -0,0 +1,757 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import contextlib
+import json
+import logging
+import os
+import re
+import warnings
+from collections import defaultdict
+from collections.abc import Callable
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import torch
+import torch.nn as nn
+import transformers
+from accelerate import PartialState
+from accelerate.logging import get_logger
+from accelerate.utils import is_peft_model
+from datasets import Dataset, IterableDataset
+from packaging.version import Version
+from transformers import (
+ AutoModelForSequenceClassification,
+ AutoTokenizer,
+ DataCollator,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+ TrainerCallback,
+ set_seed,
+)
+from transformers.data.data_collator import DataCollatorMixin
+from transformers.modeling_layers import GenericForSequenceClassification
+from transformers.trainer_utils import EvalPrediction
+from transformers.utils import is_peft_available
+
+from ..chat_template_utils import clone_chat_template
+from ..data_utils import is_conversational
+from ..models import get_act_offloading_ctx_manager
+from .base_trainer import _BaseTrainer
+from .reward_config import RewardConfig
+from .utils import create_model_from_path, disable_dropout_in_model, get_config_model_id, pad
+
+
+if is_peft_available():
+ import peft
+ from peft import PeftConfig, PeftModel, get_peft_model
+
+
+logger = get_logger(__name__)
+
+
+# Loading a CausalLM checkpoint into AutoModelForSequenceClassification triggers harmless warnings:
+# - MISSING score.weight : the new seq-clf head was not in the checkpoint and is randomly initialized.
+# - UNEXPECTED lm_head.weight: the causal LM head is in the checkpoint but absent from seq-clf (>= 4.57.0 only).
+# Both are expected consequences of intentional cross-architecture loading. We suppress them to avoid
+# confusing users.
+
+
+# Old approach using logging filter (for transformers < 4.57.0)
+# Note: in transformers < 4.57.0, only the MISSING score.weight warning is emitted; lm_head.weight is not reported.
+@contextmanager
+def _suppress_seqcls_cross_arch_keys(logger: logging.Logger):
+ pattern = re.compile(
+ r"^Some weights of \S+ were not initialized from the model checkpoint at \S+ and are newly initialized: "
+ r"\[.*\]\nYou should probably TRAIN this model on a down-stream task to be able to use it for predictions and "
+ r"inference\.$"
+ )
+
+ class _Filter(logging.Filter):
+ def filter(self, record: logging.LogRecord) -> bool:
+ return not pattern.search(record.getMessage())
+
+ f = _Filter()
+ logger.addFilter(f)
+ try:
+ yield
+ finally:
+ logger.removeFilter(f)
+
+
+# New approach using scoped override (for transformers >= 4.57.0)
+@contextmanager
+def _ignore_seqcls_cross_arch_keys():
+ # Scoped override: ignore the expected seq-clf head key (newly added) and the causal LM head
+ # key (present in the checkpoint but absent from seq-clf).
+ old_missing = getattr(GenericForSequenceClassification, "_keys_to_ignore_on_load_missing", None)
+ old_unexpected = getattr(GenericForSequenceClassification, "_keys_to_ignore_on_load_unexpected", None)
+
+ merged_missing = list(old_missing) if old_missing is not None else []
+ if r"^score\.weight$" not in merged_missing:
+ merged_missing.append(r"^score\.weight$")
+
+ merged_unexpected = list(old_unexpected) if old_unexpected is not None else []
+ if r"^lm_head\." not in merged_unexpected:
+ merged_unexpected.append(r"^lm_head\.")
+
+ GenericForSequenceClassification._keys_to_ignore_on_load_missing = merged_missing
+ GenericForSequenceClassification._keys_to_ignore_on_load_unexpected = merged_unexpected
+ try:
+ yield
+ finally:
+ GenericForSequenceClassification._keys_to_ignore_on_load_missing = old_missing
+ GenericForSequenceClassification._keys_to_ignore_on_load_unexpected = old_unexpected
+
+
+# Version-aware wrapper that chooses the appropriate approach
+@contextmanager
+def suppress_seqcls_warning():
+ # Use the new approach for transformers >= 4.57.0, old approach for earlier versions
+ # The old approach is needed for 4.56.2 to avoid meta tensor issues with device_map=None
+ if Version(transformers.__version__) >= Version("4.57.0"):
+ with _ignore_seqcls_cross_arch_keys():
+ yield
+ else:
+ # Get the transformers logger
+ transformers_logger = logging.getLogger("transformers.modeling_utils")
+ with _suppress_seqcls_cross_arch_keys(transformers_logger):
+ yield
+
+
+def get_dataset_column_names(dataset: Dataset | IterableDataset) -> list[str]:
+ return list(next(iter(dataset)).keys()) if dataset.column_names is None else dataset.column_names
+
+
+@dataclass
+class DataCollatorForPreference(DataCollatorMixin):
+ """
+ Data collator used for preference data. Inputs are dynamically padded to the maximum length of a batch.
+
+ This collator expects each example in the input list to be a dictionary containing the `"chosen_ids"` and
+ `"rejected_ids"` keys. The collator returns a dictionary containing the following keys:
+ - `"input_ids"`: Tensor of input IDs, padded to the maximum length of the batch. The first half of the batch
+ corresponds to the `"chosen_ids"` and the second half to the `"rejected_ids"`.
+ - `"attention_mask"`: Tensor of attention mask, padded to the maximum length of the batch.
+
+ Optionally, the examples can contain a `"margin"` key, in which case the returned dictionary will also contain a
+ `"margin"` key with a tensor of margins.
+
+ Args:
+ pad_token_id (`int`):
+ Token ID to use for padding.
+ pad_to_multiple_of (`int`, *optional*):
+ If set, the sequences will be padded to a multiple of this value.
+ return_tensors (`str`, *optional*, defaults to `"pt"`):
+ Type of Tensor to return. Only `"pt"` is currently supported.
+
+ Examples:
+ ```python
+ >>> from trl.trainer.reward_trainer import DataCollatorForPreference
+
+ >>> collator = DataCollatorForPreference(pad_token_id=0)
+ >>> examples = [
+ ... {"chosen_ids": [1, 2, 3], "rejected_ids": [4, 5]},
+ ... {"chosen_ids": [6, 7], "rejected_ids": [8]},
+ ... ]
+ >>> collator(examples)
+ {'input_ids': tensor([[1, 2, 3],
+ [6, 7, 0],
+ [4, 5, 0],
+ [8, 0, 0]]),
+ 'attention_mask': tensor([[1, 1, 1],
+ [1, 1, 0],
+ [1, 1, 0],
+ [1, 0, 0]])}
+
+ >>> examples = [
+ ... {"chosen_ids": [1, 2, 3], "rejected_ids": [4, 5], "margin": 0.5},
+ ... {"chosen_ids": [6, 7], "rejected_ids": [8], "margin": 0.0},
+ ... ]
+ >>> collator(examples)
+ {'input_ids': tensor([[1, 2, 3],
+ [6, 7, 0],
+ [4, 5, 0],
+ [8, 0, 0]]),
+ 'attention_mask': tensor([[1, 1, 1],
+ [1, 1, 0],
+ [1, 1, 0],
+ [1, 0, 0]]),
+ 'margin': tensor([0.5, 0.0])}
+ ```
+ """
+
+ pad_token_id: int
+ pad_to_multiple_of: int | None = None
+ return_tensors: str = "pt"
+
+ def torch_call(self, examples: list[dict[str, Any]]) -> dict[str, Any]:
+ # Convert to tensor
+ chosen_ids = [torch.tensor(example["chosen_ids"]) for example in examples]
+ rejected_ids = [torch.tensor(example["rejected_ids"]) for example in examples]
+ if "margin" in examples[0]:
+ margins = torch.tensor([example["margin"] for example in examples], dtype=torch.float)
+ input_ids = chosen_ids + rejected_ids
+ attention_mask = [torch.ones_like(ids) for ids in input_ids]
+
+ output = {}
+
+ # Pad
+ output["input_ids"] = pad(
+ input_ids,
+ padding_value=self.pad_token_id,
+ padding_side="right",
+ pad_to_multiple_of=self.pad_to_multiple_of,
+ )
+ output["attention_mask"] = pad(
+ attention_mask,
+ padding_value=0,
+ padding_side="right",
+ pad_to_multiple_of=self.pad_to_multiple_of,
+ )
+ if "margin" in examples[0]:
+ output["margin"] = margins
+ return output
+
+
+class RewardTrainer(_BaseTrainer):
+ """
+ Trainer for Outcome-supervised Reward Models (ORM).
+
+ This class is a wrapper around the [`~transformers.Trainer`] class and inherits all of its attributes and methods.
+
+ Example:
+
+ ```python
+ from trl import RewardTrainer
+ from datasets import load_dataset
+
+ dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
+
+ trainer = RewardTrainer(
+ model="Qwen/Qwen2.5-0.5B-Instruct",
+ train_dataset=dataset,
+ )
+ trainer.train()
+ ```
+
+ Args:
+ model (`str` or [`~transformers.PreTrainedModel`] or [`~peft.PeftModel`]):
+ Model to be trained. Can be either:
+
+ - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a
+ path to a *directory* containing model weights saved using
+ [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded
+ using `AutoModelForSequenceClassification.from_pretrained` with the keyword arguments in
+ `args.model_init_kwargs`.
+ - A sequence classification [`~transformers.PreTrainedModel`] object.
+ - A sequence classification [`~peft.PeftModel`] object.
+ args ([`RewardConfig`], *optional*):
+ Configuration for this trainer. If `None`, a default configuration is used.
+ data_collator ([`~transformers.DataCollator`], *optional*):
+ Function to use to form a batch from a list of elements of the processed `train_dataset` or `eval_dataset`.
+ Will default to [`~trainer.reward_trainer.DataCollatorForPreference`].
+ train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]):
+ Dataset to use for training. This trainer supports [preference](#preference) type (both implicit and
+ explicit prompt). The format of the samples can be either:
+
+ - [Standard](dataset_formats#standard): Each sample contains plain text.
+ - [Conversational](dataset_formats#conversational): Each sample contains structured messages (e.g., role
+ and content).
+
+ The trainer also supports processed datasets (tokenized) as long as they contain `chosen_ids` and
+ `rejected_ids` fields.
+ eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`):
+ Dataset to use for evaluation. It must meet the same requirements as `train_dataset`.
+ processing_class ([`~transformers.PreTrainedTokenizerBase`], *optional*):
+ Tokenizer used to process the data. If `None`, the tokenizer is loaded from the model's name with
+ [`~transformers.AutoTokenizer.from_pretrained`]. A padding token, `processing_class.pad_token`, must be
+ set. If the processing class has not set a padding token, `processing_class.eos_token` will be used as the
+ default.
+ compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*):
+ The function that will be used to compute metrics at evaluation. Must take a
+ [`~transformers.EvalPrediction`] and return a dictionary string to metric values. When passing
+ [`RewardConfig`] with `batch_eval_metrics` set to `True`, your `compute_metrics` function must take a
+ boolean `compute_result` argument. This will be triggered after the last eval batch to signal that the
+ function needs to calculate and return the global summary statistics rather than accumulating the
+ batch-level statistics.
+ callbacks (list of [`~transformers.TrainerCallback`], *optional*):
+ List of callbacks to customize the training loop. Will add those to the list of default callbacks detailed
+ in [here](https://huggingface.co/docs/transformers/main_classes/callback).
+
+ If you want to remove one of the default callbacks used, use the [`~transformers.Trainer.remove_callback`]
+ method.
+ optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *optional*, defaults to `(None, None)`):
+ A tuple containing the optimizer and the scheduler to use. Will default to an instance of `AdamW` on your
+ model and a scheduler given by [`~transformers.get_linear_schedule_with_warmup`] controlled by `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.
+
+ Unlike `optimizers`, this argument avoids the need to place model parameters on the correct devices before
+ initializing the Trainer.
+ preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`, *optional*):
+ A function that preprocess the logits right before caching them at each evaluation step. Must take two
+ tensors, the logits and the labels, and return the logits once processed as desired. The modifications made
+ by this function will be reflected in the predictions received by `compute_metrics`.
+
+ Note that the labels (second parameter) will be `None` if the dataset does not have them.
+ peft_config ([`~peft.PeftConfig`], *optional*):
+ PEFT configuration used to wrap the model. If `None`, the model is not wrapped. Note that if the loaded
+ model is a causal LM, it's highly recommended to set `modules_to_save=["score"]` in the PEFT configuration
+ to ensure that the reward head is properly trained.
+ """
+
+ _tag_names = ["trl", "reward-trainer"]
+ _name = "Reward"
+ _template_file = "rm_model_card.md"
+
+ def __init__(
+ self,
+ model: "str | PreTrainedModel | PeftModel",
+ args: RewardConfig | None = None,
+ data_collator: DataCollator | None = None,
+ train_dataset: Dataset | IterableDataset | None = None,
+ eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None,
+ processing_class: PreTrainedTokenizerBase | None = None,
+ compute_metrics: Callable[[EvalPrediction], dict] | None = None,
+ callbacks: list[TrainerCallback] | None = None,
+ optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None),
+ optimizer_cls_and_kwargs: tuple[type[torch.optim.Optimizer], dict[str, Any]] | None = None,
+ preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None,
+ peft_config: "PeftConfig | None" = None,
+ ):
+ # Args
+ if args is None:
+ model_name = model if isinstance(model, str) else get_config_model_id(model.config)
+ model_name = model_name.split("/")[-1]
+ args = RewardConfig(f"{model_name}-Reward")
+
+ if train_dataset is None:
+ raise ValueError("`train_dataset` is required")
+ elif isinstance(train_dataset, IterableDataset):
+ # IterableDataset requires dispatch_batches=False because Accelerate's dispatch mode may try to concatenate
+ # batches from multiple processes, leading to mismatch errors.
+ if args.accelerator_config.dispatch_batches is True:
+ logger.warning(
+ "You are using an `IterableDataset` for training with `dispatch_batches=True`. `dispatch_batches` "
+ "is forced to `False` when using an `IterableDataset`. To remove this warning, unset "
+ "`dispatch_batches` in `RewardConfig` or set it to `False`."
+ )
+ args.accelerator_config.dispatch_batches = False
+
+ # Model
+ # As AutoModelForSequenceClassification.from_pretrained() will add a random head for the model, set_seed must
+ # be done before loading the model to ensure reproducibility.
+ set_seed(args.seed)
+ if isinstance(model, str):
+ model_init_kwargs = args.model_init_kwargs or {}
+ # Distributed training requires device_map=None ("auto" fails)
+ if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]:
+ model_init_kwargs["device_map"] = None
+ model_init_kwargs["num_labels"] = 1 # the only output of the model is the reward score
+ model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+ with suppress_seqcls_warning():
+ model = create_model_from_path(model, AutoModelForSequenceClassification, **model_init_kwargs)
+ else:
+ if args.model_init_kwargs is not None:
+ logger.warning(
+ "You passed `model_init_kwargs` to the `RewardConfig`, but your model is already instantiated. "
+ "The `model_init_kwargs` will be ignored."
+ )
+ # Validate that the model has num_labels = 1 (required for reward models)
+ if getattr(model.config, "num_labels", None) != 1:
+ raise ValueError(
+ f"The model has `num_labels={model.config.num_labels}`, but reward models require `num_labels=1` "
+ "to output a single scalar reward per sequence. Please instantiate your model with `num_labels=1` "
+ "or pass a model name as a string to have it configured automatically."
+ )
+ # Non-quantized models do not have the `is_loaded_in_{8,4}bit` attributes, whereas quantized models do
+ _is_quantized_model = getattr(model, "is_loaded_in_4bit", False) or getattr(model, "is_loaded_in_8bit", False)
+
+ # Processing class
+ if processing_class is None:
+ processing_class = AutoTokenizer.from_pretrained(
+ get_config_model_id(model.config), trust_remote_code=args.trust_remote_code
+ )
+
+ # Handle pad token for processors or tokenizers
+ if args.eos_token is not None:
+ if args.eos_token not in processing_class.get_vocab():
+ raise ValueError(
+ f"The specified `eos_token` ('{args.eos_token}') is not found in the vocabulary of the given "
+ f"`processing_class` ({processing_class.__class__.__name__}). Ensure that the `eos_token` exists "
+ "in the vocabulary before using it as an EOS token."
+ )
+ processing_class.eos_token = args.eos_token
+
+ if args.chat_template_path is not None:
+ if os.path.isfile(args.chat_template_path) and args.chat_template_path.endswith((".jinja", ".j2")):
+ with open(args.chat_template_path, encoding="utf-8") as chat_template_file:
+ processing_class.chat_template = chat_template_file.read()
+ added_tokens = []
+ else:
+ model, processing_class, added_tokens = clone_chat_template(
+ model, processing_class, args.chat_template_path
+ )
+ else:
+ added_tokens = []
+
+ # PEFT
+ if peft_config is not None:
+ if not is_peft_available():
+ raise ImportError(
+ "You passed `peft_config` but the `peft` library is not installed. "
+ "Install it with `pip install trl[peft]`."
+ )
+ if not isinstance(peft_config, PeftConfig):
+ raise TypeError(
+ f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), "
+ f"got {type(peft_config).__name__}."
+ )
+ if is_peft_model(model):
+ raise ValueError(
+ "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first merge "
+ "and unload the existing adapter, save the resulting base model, and then pass that base model along "
+ "with the new `peft_config` to the trainer."
+ )
+ if added_tokens:
+ # Ensure that the added tokens are trainable
+ if peft_config.trainable_token_indices is None:
+ peft_config.trainable_token_indices = {"embed_tokens": added_tokens}
+ elif "embed_tokens" not in peft_config.trainable_token_indices:
+ peft_config.trainable_token_indices["embed_tokens"] = added_tokens
+ else:
+ peft_config.trainable_token_indices["embed_tokens"].extend(added_tokens)
+ # Ensure that the lm_head is trainable
+ if peft_config.modules_to_save is None or "lm_head" not in peft_config.modules_to_save:
+ logger.warning(
+ "Cloning chat template added new tokens to the tokenizer, but 'lm_head' is not in PEFT's "
+ "`modules_to_save`. As a result, the model may not learn to generate outputs with these new "
+ "tokens, leading to degraded generation quality. To fix this, add "
+ "`modules_to_save=['lm_head']` to your PEFT configuration."
+ )
+
+ if peft_config.modules_to_save is None:
+ peft_config.modules_to_save = ["lm_head"]
+ else:
+ peft_config.modules_to_save.append("lm_head")
+ # Create PEFT model
+ # ZeRO-3 + PEFT for non-quantized models:
+ # - PEFT's default autocast_adapter_dtype=True upcasts LoRA adapter params to fp32 even when the base model is bf16.
+ # - ZeRO-3's _allgather_params_coalesced allocates output buffers using the dtype of the first persistent parameter,
+ # so mixed-dtype persistent_parameters (bf16 base + fp32 LoRA) cause a TypeError on the first optimizer step.
+ # - Passing autocast_adapter_dtype=False keeps adapter params in the base model dtype (bf16), fixing the mismatch.
+ # - This is safe: the fp32 upcast is a QLoRA-specific concern (low-bit quantized base models), not needed for
+ # non-quantized bf16 training.
+ # - See:
+ # - TRL issue: https://github.com/huggingface/trl/issues/6089
+ # - Upstream issue: https://github.com/deepspeedai/DeepSpeed/issues/8072
+ # - autocast_adapter_dtype was introduced in PEFT 0.12.0; before, no upcast existed: no need to pass the kwarg
+ get_peft_model_kwargs = {}
+ if (
+ args.deepspeed_plugin is not None
+ and args.deepspeed_plugin.zero_stage == 3
+ and not _is_quantized_model
+ and Version(peft.__version__) >= Version("0.12.0")
+ ):
+ get_peft_model_kwargs["autocast_adapter_dtype"] = False
+ model = get_peft_model(model, peft_config, **get_peft_model_kwargs)
+
+ # When using gradient checkpointing with PEFT, we need to enable input gradients. transformers.Trainer normally
+ # handles this, but a bug currently prevents it; see https://github.com/huggingface/transformers/issues/42489
+ if is_peft_model(model) and args.gradient_checkpointing:
+ model.enable_input_require_grads()
+
+ # When using QLoRA, the PEFT adapter weights are converted to bf16 to follow the recommendations from the
+ # original paper (see https://huggingface.co/papers/2305.14314, paragraph 3). Normally, this can be done by
+ # passing `autocast_adapter_dtype=False` to `get_peft_model`, but this option is not yet supported for
+ # quantized models. See: https://github.com/huggingface/peft/issues/2889
+ if _is_quantized_model:
+ for param in model.parameters():
+ if param.requires_grad:
+ param.data = param.data.to(torch.bfloat16)
+
+ # Disable dropout in the model
+ if args.disable_dropout:
+ disable_dropout_in_model(model)
+
+ # Pad token (needed for SequenceClassification models)
+ # If not provided, use the one from the processing class or the eos token if the processing class does not have
+ # a pad token.
+ pad_token = args.pad_token or processing_class.pad_token or processing_class.eos_token
+ if pad_token not in processing_class.get_vocab():
+ raise ValueError(
+ f"The specified `pad_token` ('{pad_token}') is not found in the vocabulary of the given "
+ f"`processing_class` ({processing_class.__class__.__name__}). Ensure that the `pad_token` exists "
+ "in the vocabulary before using it as a padding token."
+ )
+ processing_class.pad_token = pad_token
+ # SequenceClassification models need `config.pad_token_id` to locate the last non-pad token.
+ model.config.pad_token_id = processing_class.pad_token_id
+
+ # Data collator
+ if data_collator is None:
+ data_collator = DataCollatorForPreference(
+ pad_token_id=processing_class.pad_token_id,
+ pad_to_multiple_of=args.pad_to_multiple_of,
+ )
+
+ # Dataset
+ train_dataset = self._prepare_dataset(train_dataset, processing_class, args, "train")
+ if eval_dataset is not None:
+ if isinstance(eval_dataset, dict):
+ eval_dataset = {
+ key: self._prepare_dataset(dataset, processing_class, args, key)
+ for key, dataset in eval_dataset.items()
+ }
+ else:
+ eval_dataset = self._prepare_dataset(eval_dataset, processing_class, args, "eval")
+
+ # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was
+ # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream
+ # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we
+ # default to the recommended non-reentrant behavior here, while preserving any user-provided value.
+ if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"):
+ args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {}
+ args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False)
+
+ super().__init__(
+ model=model,
+ args=args,
+ data_collator=data_collator,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=processing_class,
+ compute_metrics=compute_metrics,
+ callbacks=callbacks,
+ optimizers=optimizers,
+ optimizer_cls_and_kwargs=optimizer_cls_and_kwargs,
+ preprocess_logits_for_metrics=preprocess_logits_for_metrics,
+ )
+
+ # During evaluation, Trainer calls compute_loss() only if can_return_loss is True and label_names is empty.
+ self.can_return_loss = True
+ self.label_names = []
+
+ # Initialize activation offloading context
+ if self.args.activation_offloading:
+ self.maybe_activation_offload_context = get_act_offloading_ctx_manager(model=self.model)
+ else:
+ self.maybe_activation_offload_context = contextlib.nullcontext()
+
+ # Initialize the metrics
+ self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)}
+ self._total_train_tokens = 0
+
+ # Gradient accumulation requires scaled loss. Normally, loss scaling in the parent class depends on whether the
+ # model accepts loss-related kwargs. Since we compute our own loss, this check is irrelevant. We set
+ # self.model_accepts_loss_kwargs to False to enable scaling.
+ self.model_accepts_loss_kwargs = False
+
+ # Add tags to the model
+ self.model.add_model_tags(self._tag_names)
+
+ def _prepare_dataset(
+ self,
+ dataset: Dataset | IterableDataset,
+ processing_class: PreTrainedTokenizerBase,
+ args: RewardConfig,
+ dataset_name: str,
+ ) -> Dataset | IterableDataset:
+ # If the dataset is already preprocessed (tokenized), skip the processing steps.
+ column_names = get_dataset_column_names(dataset)
+ is_processed = "chosen_ids" in column_names and "rejected_ids" in column_names
+ has_legacy_processed_columns = "chosen_input_ids" in column_names and "rejected_input_ids" in column_names
+ if has_legacy_processed_columns and not is_processed:
+ warnings.warn(
+ "Detected legacy dataset columns `chosen_input_ids`/`rejected_input_ids`; they are deprecated and "
+ "will not be supported in v1. Please migrate to `chosen_ids`/`rejected_ids`.",
+ FutureWarning,
+ stacklevel=2,
+ )
+ dataset = dataset.rename_column("chosen_input_ids", "chosen_ids")
+ dataset = dataset.rename_column("rejected_input_ids", "rejected_ids")
+ is_processed = True
+
+ # Build the kwargs for the `map` function
+ map_kwargs = {}
+ if isinstance(dataset, Dataset): # IterableDataset does not support num_proc
+ map_kwargs["num_proc"] = args.dataset_num_proc
+
+ with PartialState().main_process_first():
+ if not is_processed:
+ # Add EOS token if needed: non-conversational only
+ first_example = next(iter(dataset))
+ if not is_conversational(first_example):
+ if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc`
+ map_kwargs["desc"] = f"Adding EOS to {dataset_name} dataset"
+
+ def add_eos(example, eos_token):
+ if not example["chosen"].endswith(eos_token):
+ example["chosen"] = example["chosen"] + eos_token
+ if "rejected" in example and not example["rejected"].endswith(eos_token):
+ example["rejected"] = example["rejected"] + eos_token
+ return example
+
+ dataset = dataset.map(
+ add_eos,
+ fn_kwargs={"eos_token": processing_class.eos_token},
+ **map_kwargs,
+ )
+
+ # Tokenize the dataset
+ if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc`
+ map_kwargs["desc"] = f"Tokenizing {dataset_name} dataset"
+
+ def tokenize_fn(example, processing_class):
+ tools = example.get("tools")
+ tools = json.loads(tools) if isinstance(tools, str) else tools
+ if "prompt" in example: # explicit prompt case
+ example["chosen"] = example["prompt"] + example["chosen"]
+ example["rejected"] = example["prompt"] + example["rejected"]
+
+ if is_conversational(example):
+ chosen_ids = processing_class.apply_chat_template(
+ example["chosen"],
+ tools=tools,
+ return_dict=True,
+ **example.get("chat_template_kwargs", {}),
+ )["input_ids"]
+ rejected_ids = processing_class.apply_chat_template(
+ example["rejected"],
+ tools=tools,
+ return_dict=True,
+ **example.get("chat_template_kwargs", {}),
+ )["input_ids"]
+ output = {"chosen_ids": chosen_ids, "rejected_ids": rejected_ids}
+ else:
+ output = {
+ "chosen_ids": processing_class(text=example["chosen"])["input_ids"],
+ "rejected_ids": processing_class(text=example["rejected"])["input_ids"],
+ }
+ return output
+
+ dataset = dataset.map(tokenize_fn, fn_kwargs={"processing_class": processing_class}, **map_kwargs)
+
+ # Filter samples that are longer than `max_length`
+ if args.max_length is not None:
+ if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc`
+ map_kwargs["desc"] = f"Filtering {dataset_name} >{args.max_length} tokens"
+ dataset = dataset.filter(
+ lambda example: len(example["chosen_ids"]) <= args.max_length
+ and len(example["rejected_ids"]) <= args.max_length,
+ **map_kwargs,
+ )
+
+ return dataset
+
+ def _set_signature_columns_if_needed(self):
+ # If `self.args.remove_unused_columns` is True, non-signature columns are removed.
+ # By default, this method sets `self._signature_columns` to the model's expected inputs (usually, "input_ids"
+ # and "attention_mask").
+ if self._signature_columns is None:
+ self._signature_columns = ["chosen_ids", "rejected_ids", "margin"]
+
+ def evaluate(
+ self,
+ eval_dataset: Dataset | dict[str, Dataset] | None = None,
+ ignore_keys: list[str] | None = None,
+ metric_key_prefix: str = "eval",
+ ) -> dict[str, float]:
+ # When a dataset is passed directly to `evaluate` (e.g. a held-out test set), preprocess it the same way
+ # `__init__` does, so that `evaluate` accepts the same dataset types as the trainer. `_prepare_dataset` is
+ # idempotent: it skips datasets that are already tokenized. A `str` selects a dataset that was already prepared
+ # at init time, so it's left untouched.
+ if eval_dataset is not None and not isinstance(eval_dataset, str):
+ if isinstance(eval_dataset, dict):
+ eval_dataset = {
+ key: self._prepare_dataset(dataset, self.processing_class, self.args, key)
+ for key, dataset in eval_dataset.items()
+ }
+ else:
+ eval_dataset = self._prepare_dataset(eval_dataset, self.processing_class, self.args, "eval")
+ return super().evaluate(
+ eval_dataset=eval_dataset, ignore_keys=ignore_keys, metric_key_prefix=metric_key_prefix
+ )
+
+ def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
+ mode = "train" if self.model.training else "eval"
+
+ # If not set, defaults from model config and may warn since cache isn't compatible with gradient checkpointing
+ inputs["use_cache"] = False
+ outputs = model(**inputs)
+
+ # Split the rewards into chosen and rejected
+ rewards_chosen, rewards_rejected = torch.chunk(outputs.logits.squeeze(-1), chunks=2)
+
+ # Calculate loss, optionally modulate with margin
+ if "margin" in inputs:
+ loss = -nn.functional.logsigmoid(rewards_chosen - rewards_rejected - inputs["margin"]).mean()
+ else:
+ loss = -nn.functional.logsigmoid(rewards_chosen - rewards_rejected).mean()
+
+ if self.args.center_rewards_coefficient is not None:
+ loss += self.args.center_rewards_coefficient * torch.mean((rewards_chosen + rewards_rejected) ** 2)
+
+ if mode == "train":
+ num_tokens_in_batch = self.accelerator.gather_for_metrics(inputs["attention_mask"].sum()).sum().item()
+ self._total_train_tokens += num_tokens_in_batch
+ self._metrics[mode]["num_tokens"] = [self._total_train_tokens]
+
+ # Compute min, mean, max, accuracy and margin
+ with torch.no_grad():
+ all_rewards = self.accelerator.gather(outputs.logits)
+ self._metrics[mode]["min_reward"].append(all_rewards.min().item())
+ self._metrics[mode]["mean_reward"].append(all_rewards.mean().item())
+ self._metrics[mode]["max_reward"].append(all_rewards.max().item())
+
+ mean_accuracy = (rewards_chosen > rewards_rejected).float().mean()
+ mean_accuracy = self.accelerator.gather_for_metrics(mean_accuracy).mean().item()
+ self._metrics[mode]["accuracy"].append(mean_accuracy)
+
+ mean_margin = (rewards_chosen - rewards_rejected).mean()
+ mean_margin = self.accelerator.gather_for_metrics(mean_margin).mean()
+ self._metrics[mode]["margin"].append(mean_margin.item())
+
+ return (loss, outputs) if return_outputs else loss
+
+ # Override training step to add activation offloading context.
+ def training_step(self, *args, **kwargs):
+ with self.maybe_activation_offload_context:
+ return super().training_step(*args, **kwargs)
+
+ def log(self, logs: dict[str, float], start_time: float | None = None) -> None:
+ mode = "train" if self.model.training else "eval"
+ metrics = {key: sum(val) / len(val) for key, val in self._metrics[mode].items()} # average the metrics
+
+ # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs`
+ # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format.
+ if mode == "eval":
+ metrics = {f"eval_{key}": val for key, val in metrics.items()}
+
+ logs.update(metrics)
+ super().log(logs, start_time)
+ self._metrics[mode].clear()
+
+ # Ensure the model card is saved along with the checkpoint
+ def _save_checkpoint(self, model, trial):
+ if self.args.hub_model_id is None:
+ model_name = Path(self.args.output_dir).name
+ else:
+ model_name = self.args.hub_model_id.split("/")[-1]
+ self.create_model_card(model_name=model_name)
+ super()._save_checkpoint(model, trial)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/rloo_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/rloo_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..5cd2bb565ac2d8f600d5113cfa00bcddaaf9b952
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/rloo_config.py
@@ -0,0 +1,668 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import warnings
+from dataclasses import dataclass, field
+from typing import Any
+
+from .base_config import _BaseConfig
+
+
+@dataclass
+class RLOOConfig(_BaseConfig):
+ # docstyle-ignore
+ r"""
+ Configuration class for the [`RLOOTrainer`].
+
+ This class includes only the parameters that are specific to RLOO training. For a full list of training arguments,
+ please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may
+ differ from those in [`~transformers.TrainingArguments`].
+
+ Using [`~transformers.HfArgumentParser`] we can turn this class into
+ [argparse](https://docs.python.org/3/library/argparse#module-argparse) arguments that can be specified on the
+ command line.
+
+ Parameters:
+ > Parameters that control the model and reference model
+
+ model_init_kwargs (`str`, `dict[str, Any]`, *optional*):
+ Keyword arguments for [`~transformers.AutoModelForCausalLM.from_pretrained`], used when the `model`
+ argument of the [`RLOOTrainer`] is provided as a string.
+ trust_remote_code (`bool`, *optional*, defaults to `False`):
+ Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to
+ [`~transformers.AutoModelForCausalLM.from_pretrained`] and
+ [`~transformers.AutoProcessor.from_pretrained`]. Also applied to reward-model and reward-tokenizer loads.
+ router_aux_loss_coef (`float`, *optional*, defaults to `0.001`):
+ Coefficient of the load-balancing auxiliary loss. Only has an effect when training a Mixture-of-Experts
+ (MoE) model; for other models it does nothing. The auxiliary loss is added to the training loss with this
+ weight. Set to `0.0` to disable it.
+ disable_dropout (`bool`, *optional*, defaults to `False`):
+ Whether to disable dropout in the model. This is useful for training with a reference model, as it prevents
+ the model from generating different logprobs for the same input.
+
+ > Parameters that control the data preprocessing
+
+ remove_unused_columns (`bool`, *optional*, defaults to `False`):
+ Whether to only keep the column `"prompt"` in the dataset. If you use a custom reward function that
+ requires any column other than `"prompts"` and `"completions"`, you should keep this to `False`.
+ num_generations (`int`, *optional*, defaults to `2`):
+ Number of generations per prompt to sample. The effective batch size (num_processes * per_device_batch_size
+ * gradient_accumulation_steps) must be evenly divisible by this value.
+ num_generations_eval (`int` or `None`, *optional*):
+ Number of generations to sample during evaluation. This allows using fewer generations during evaluation to
+ save computation. If `None`, uses the value of `num_generations`.
+ max_completion_length (`int` or `None`, *optional*, defaults to `256`):
+ Maximum length of the generated completion.
+ ds3_gather_for_generation (`bool`, *optional*, defaults to `True`):
+ This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for generation,
+ improving generation speed. However, disabling this option allows training models that exceed the VRAM
+ capacity of a single GPU, albeit at the cost of slower generation. Disabling this option is not compatible
+ with vLLM generation.
+ shuffle_dataset (`bool`, *optional*, defaults to `True`):
+ Whether to shuffle the training dataset.
+ pad_to_multiple_of (`int`, *optional*):
+ If set, the prompts ids and completions ids will be padded to a multiple of this value.
+
+ > Parameters that control generation
+
+ generation_batch_size (`int`, *optional*):
+ Batch size to use for generation. If `None`, it defaults to the effective training batch size:
+ `per_device_train_batch_size * num_processes * steps_per_generation`. In other words, there is one
+ generation batch processed per optimization step. Mutually exclusive with `steps_per_generation`.
+ steps_per_generation (`int`, *optional*):
+ Number of steps per generation. If `None`, it defaults to `gradient_accumulation_steps`. Mutually exclusive
+ with `generation_batch_size`.
+ temperature (`float`, defaults to `1.0`):
+ Temperature for sampling. The higher the temperature, the more random the completions.
+ top_p (`float`, *optional*, defaults to `1.0`):
+ Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. Set to
+ `1.0` to consider all tokens.
+ top_k (`int`, *optional*, defaults to `0`):
+ Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, top-k-filtering is
+ disabled and all tokens are considered.
+ min_p (`float`, *optional*):
+ Minimum token probability, which will be scaled by the probability of the most likely token. It must be a
+ value between `0.0` and `1.0`. Typical values are in the `0.01-0.2` range.
+ generation_kwargs (`dict[str, Any]`, *optional*):
+ Additional keyword arguments to pass to [`~transformers.GenerationConfig`] (if using transformers) or
+ `SamplingParams` (if using vLLM) when sampling completions. This can be used to further customize the
+ generation behavior, such as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that conflict
+ with the other generation parameters (like `min_p`, `top_p`, etc.), they will override them.
+ chat_template_kwargs (`dict[str, Any]`, *optional*):
+ Additional keyword arguments to pass to the `apply_chat_template` function when generating completions.
+ repetition_penalty (`float`, *optional*, defaults to `1.0`):
+ Float that penalizes new tokens based on whether they appear in the prompt and the generated text so far.
+ Values > `1.0` encourage the model to use new tokens, while values < `1.0` encourage the model to repeat
+ tokens.
+ cache_implementation (`str`, *optional*):
+ Implementation of the cache method for faster generation when `use_vllm` is set to `False`.
+
+ > Parameters that control generation acceleration powered by vLLM
+
+ use_vllm (`bool`, *optional*, defaults to `False`):
+ Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for generation
+ instead of the default model.generate(). Requires `vllm` to be installed.
+ vllm_mode (`str`, *optional*, defaults to `"colocate"`):
+ Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `"server"` or
+ `"colocate"`.
+
+ - `"server"`: The trainer will send generation requests to a separate vLLM server. Make sure a TRL vLLM
+ server is running (start with `trl vllm-serve`).
+ - `"colocate"`: vLLM will run in the same process and share the training GPUs. This avoids the need for a
+ separate server but may cause resource contention with training.
+ vllm_model_impl (`str`, *optional*, defaults to `"vllm"`):
+ Model implementation to use for vLLM. Must be one of `"transformers"` or `"vllm"`. `"transformers"`: Use
+ the `transformers` backend for model implementation. `"vllm"`: Use the `vllm` library for model
+ implementation.
+ vllm_structured_outputs_regex (`str`, *optional*):
+ Regex for vLLM structured outputs. If `None` (default), structured outputs is disabled.
+
+ > Parameters that control the vLLM server (only used when `vllm_mode` is `"server"`)
+
+ vllm_server_base_url (`str`, *optional*):
+ Base URL for the vLLM server (e.g., `"http://localhost:8000"`). If provided, `vllm_server_host` and
+ `vllm_server_port` are ignored.
+ vllm_server_host (`str`, *optional*, defaults to `"0.0.0.0"`):
+ Host of the vLLM server to connect to. Ignored if `vllm_server_base_url` is provided.
+ vllm_server_port (`int`, *optional*, defaults to `8000`):
+ Port of the vLLM server to connect to. Ignored if `vllm_server_base_url` is provided.
+ vllm_server_timeout (`float`, *optional*, defaults to `240.0`):
+ Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up after the
+ timeout, a `ConnectionError` is raised.
+ vllm_group_port (`int`, *optional*, defaults to `51216`):
+ Port number for the weight update group. This is used to communicate with the vLLM server. Unless the port
+ is occupied, there is no need to change it.
+
+ > Parameters that control colocated vLLM execution (only used when `vllm_mode` is `"colocate"`)
+
+ vllm_gpu_memory_utilization (`float`, *optional*, defaults to `0.3`):
+ Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set to
+ `"colocate"`. If you are using `vllm_mode="server"`, this parameter must be passed separately when
+ launching the vLLM server via the `--vllm_gpu_memory_utilization` flag.
+ vllm_max_model_length (`int`, *optional*):
+ Context window for vLLM. Set it to at least the maximum prompt length in the dataset plus
+ `max_completion_length`; if omitted, it is inferred from the model config.
+ vllm_tensor_parallel_size (`int`, *optional*, defaults to `1`):
+ Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set to
+ `"colocate"`. If you are using `vllm_mode="server"`, this parameter must be passed separately when
+ launching the vLLM server via the `--vllm_tensor_parallel_size` flag.
+ vllm_enable_sleep_mode (`bool`, *optional*, defaults to `False`):
+ Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory usage low, but
+ waking the engine adds host–device transfer latency.
+
+ > Parameters that control generation acceleration powered by transformers continuous batching
+
+ use_transformers_continuous_batching (`bool`, *optional*, defaults to `False`):
+ Whether to use transformers' continuous batching engine for generating completions. Requires
+ `transformers>=5.8.0`.
+ transformers_continuous_batching_config (`dict`, *optional*):
+ Keyword arguments for [`~transformers.generation.ContinuousBatchingConfig`].
+
+ > Parameters that control the training
+
+ beta (`float`, *optional*, defaults to `0.05`):
+ KL coefficient. If `0.0`, the reference model is not loaded, reducing memory usage and improving training
+ speed.
+ num_iterations (`int`, *optional*, defaults to `1`):
+ Number of iterations per batch (denoted as μ in the algorithm).
+ epsilon (`float`, *optional*, defaults to `0.2`):
+ Epsilon value for clipping.
+ epsilon_high (`float`, *optional*):
+ Upper-bound epsilon value for clipping. If not specified, it defaults to the same value as the lower-bound
+ specified in argument `epsilon`. Paper [DAPO](https://huggingface.co/papers/2503.14476) recommends `0.28`.
+ reward_weights (`list[float]`, *optional*):
+ Weights for each reward function. Must match the number of reward functions. If `None`, all rewards are
+ weighted equally with weight `1.0`.
+ normalize_advantages (`bool`, *optional*, defaults to `False`):
+ Whether to normalize advantages. Normalization is done per generation batch to have mean `0.0` and standard
+ deviation of `1.0`.
+ reward_clip_range (`tuple[float, float]`, *optional*):
+ Clip range for rewards as (min, max). If `None`, no clipping is applied.
+ mask_truncated_completions (`bool`, *optional*, defaults to `False`):
+ When enabled, truncated completions are excluded from the loss calculation, preventing them from being
+ incorrectly penalized and introducing noise during training. According to the
+ [DAPO](https://huggingface.co/papers/2503.14476) paper, this is a good practice for training stability.
+ sync_ref_model (`bool`, *optional*, defaults to `False`):
+ Whether to synchronize the reference model with the active model every `ref_model_sync_steps` steps, using
+ the `ref_model_mixup_alpha` parameter. This synchronization originates from the
+ [TR-DPO](https://huggingface.co/papers/2404.09656) paper.
+ ref_model_mixup_alpha (`float`, *optional*, defaults to `0.6`):
+ α parameter from the [TR-DPO](https://huggingface.co/papers/2404.09656) paper, which controls the mix
+ between the current policy and the previous reference policy during updates. The reference policy is
+ updated according to the equation: `π_ref = α * π_θ + (1 - α) * π_ref_prev`. To use this parameter, you
+ must set `sync_ref_model=True`.
+ ref_model_sync_steps (`int`, *optional*, defaults to `512`):
+ τ parameter from the [TR-DPO](https://huggingface.co/papers/2404.09656) paper, which determines how
+ frequently the current policy is synchronized with the reference policy. To use this parameter, you must
+ set `sync_ref_model=True`.
+
+ > Parameters that control the logging
+
+ log_completions (`bool`, *optional*, defaults to `False`):
+ Whether to log a sample of (prompt, completion) pairs every `logging_steps` steps. If `rich` is installed,
+ it prints the sample. If `wandb` and/or `trackio` logging is enabled, it logs it to `wandb` and/or
+ `trackio`.
+ num_completions_to_print (`int`, *optional*):
+ Number of completions to print with `rich`. If `None`, all completions are logged.
+ log_unique_prompts (`bool`, *optional*, defaults to `False`):
+ Whether to log unique prompts. If `True`, only unique prompts are logged. If `False`, all prompts are
+ logged.
+
+ > Deprecated parameters
+
+ use_transformers_paged:
+
+
+
+ Parameter `use_transformers_paged` is deprecated and will be removed in version v2.0.0. Use
+ `use_transformers_continuous_batching` instead.
+
+
+
+ > [!NOTE]
+ > These parameters have default values different from [`~transformers.TrainingArguments`]:
+ > - `logging_steps`: Defaults to `10` instead of `500`.
+ > - `gradient_checkpointing`: Defaults to `True` instead of `False`.
+ > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`.
+ > - `learning_rate`: Defaults to `1e-6` instead of `5e-5`.
+ """
+
+ _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + [
+ "model_init_kwargs",
+ "transformers_continuous_batching_config",
+ ]
+
+ # Parameters whose default values are overridden from TrainingArguments
+ learning_rate: float = field(
+ default=1e-6,
+ metadata={"help": "The initial learning rate for AdamW."},
+ )
+
+ # Parameters that control the model and reference model
+ model_init_kwargs: dict[str, Any] | str | None = field(
+ default=None,
+ metadata={
+ "help": "Keyword arguments for `transformers.AutoModelForCausalLM.from_pretrained`, used when the `model` "
+ "argument of the `RLOOTrainer` is provided as a string."
+ },
+ )
+ trust_remote_code: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. "
+ "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoProcessor.from_pretrained`. Also applied to "
+ "reward-model and reward-tokenizer loads."
+ },
+ )
+ router_aux_loss_coef: float = field(
+ default=0.001,
+ metadata={
+ "help": "Coefficient of the load-balancing auxiliary loss. Only has an effect when training a "
+ "Mixture-of-Experts (MoE) model; for other models it does nothing. The auxiliary loss is added to the "
+ "training loss with this weight. Set to `0.0` to disable it."
+ },
+ )
+ disable_dropout: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to disable dropout in the model. This is useful for training with a reference model, as "
+ "it prevents the model from generating different logprobs for the same input."
+ },
+ )
+
+ # Parameters that control the data preprocessing
+ # The default value remove_unused_columns is overwritten from the parent class, because in RLOO we usually rely on
+ # additional columns to compute the reward
+ remove_unused_columns: bool | None = field(
+ default=False,
+ metadata={
+ "help": "Whether to only keep the column 'prompt' in the dataset. If you use a custom reward function "
+ "that requires any column other than 'prompts' and 'completions', you should keep this to `False`."
+ },
+ )
+ num_generations: int | None = field(
+ default=2,
+ metadata={
+ "help": "Number of generations to sample. The effective batch size (num_processes * per_device_batch_size "
+ "* gradient_accumulation_steps) must be evenly divisible by this value."
+ },
+ )
+ num_generations_eval: int | None = field(
+ default=None,
+ metadata={
+ "help": "Number of generations to sample during evaluation. This allows using fewer generations during "
+ "evaluation to save computation. If `None`, uses the value of `num_generations`."
+ },
+ )
+ max_completion_length: int | None = field(
+ default=256,
+ metadata={"help": "Maximum length of the generated completion."},
+ )
+ ds3_gather_for_generation: bool = field(
+ default=True,
+ metadata={
+ "help": "This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for "
+ "generation, improving generation speed. However, disabling this option allows training models that "
+ "exceed the VRAM capacity of a single GPU, albeit at the cost of slower generation. Disabling this option "
+ "is not compatible with vLLM generation."
+ },
+ )
+ shuffle_dataset: bool | None = field(
+ default=True,
+ metadata={"help": "Whether to shuffle the training dataset."},
+ )
+ pad_to_multiple_of: int | None = field(
+ default=None,
+ metadata={"help": "If set, the prompts ids and completions ids will be padded to a multiple of this value."},
+ )
+
+ # Parameters that control generation
+ generation_batch_size: int | None = field(
+ default=None,
+ metadata={
+ "help": "Batch size to use for generation. If `None`, it defaults to the effective training batch size: "
+ "`per_device_train_batch_size * num_processes * steps_per_generation`."
+ },
+ )
+ steps_per_generation: int | None = field(
+ default=None,
+ metadata={"help": "Number of steps per generation. If `None`, it defaults to `gradient_accumulation_steps`."},
+ )
+ temperature: float = field(
+ default=1.0,
+ metadata={"help": "Temperature for sampling. The higher the temperature, the more random the completions."},
+ )
+ top_p: float = field(
+ default=1.0,
+ metadata={
+ "help": "Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. "
+ "Set to 1.0 to consider all tokens."
+ },
+ )
+ top_k: int = field(
+ default=0,
+ metadata={
+ "help": "Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, "
+ "top-k-filtering is disabled and all tokens are considered."
+ },
+ )
+ min_p: float | None = field(
+ default=None,
+ metadata={
+ "help": "Minimum token probability, which will be scaled by the probability of the most likely token. It "
+ "must be a value between 0.0 and 1.0. Typical values are in the 0.01-0.2 range."
+ },
+ )
+ generation_kwargs: dict | None = field(
+ default=None,
+ metadata={
+ "help": "Additional keyword arguments to pass to `GenerationConfig` (if using transformers) or "
+ "`SamplingParams` (if using vLLM) when sampling completions. This can be used to further customize the "
+ "generation behavior, such as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that "
+ "conflict with the other generation parameters (like `min_p`, `top_p`, etc.), they will override them."
+ },
+ )
+ chat_template_kwargs: dict | None = field(
+ default=None,
+ metadata={
+ "help": "Additional keyword arguments to pass to the `apply_chat_template` function when generating "
+ "completions."
+ },
+ )
+ repetition_penalty: float = field(
+ default=1.0,
+ metadata={
+ "help": "Float that penalizes new tokens based on whether they appear in the prompt and the generated "
+ "text so far. Values > 1.0 encourage the model to use new tokens, while values < 1.0 encourage the model "
+ "to repeat tokens."
+ },
+ )
+ cache_implementation: str | None = field(
+ default=None,
+ metadata={"help": "Implementation of the cache method for faster generation when use_vllm is set to False."},
+ )
+
+ # Parameters that control generation acceleration powered by vLLM
+ use_vllm: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for "
+ "generation instead of the default model.generate(). Requires `vllm` to be installed."
+ },
+ )
+ vllm_mode: str = field(
+ default="colocate",
+ metadata={
+ "help": "Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `'server'` or "
+ "`'colocate'`. `'server'`: The trainer will send generation requests to a separate vLLM server. Make sure "
+ "a TRL vLLM server is running (start with `trl vllm-serve`). `'colocate'`: vLLM will run in the same "
+ "process and share the training GPUs. This avoids the need for a separate server but may cause resource "
+ "contention with training."
+ },
+ )
+ vllm_model_impl: str = field(
+ default="vllm",
+ metadata={
+ "help": "Model implementation to use for vLLM. Must be one of `transformers` or `vllm`. `transformers`: "
+ "Use the `transformers` backend for model implementation. `vllm`: Use the `vllm` library for "
+ "model implementation."
+ },
+ )
+ vllm_enable_sleep_mode: bool = field(
+ default=False,
+ metadata={
+ "help": "Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory "
+ "usage low, but waking the engine adds host–device transfer latency."
+ },
+ )
+ vllm_structured_outputs_regex: str | None = field(
+ default=None,
+ metadata={"help": "Regex for vLLM structured outputs. If `None` (default), structured outputs is disabled."},
+ )
+
+ # Parameters that control the vLLM server (only used when `vllm_mode` is `"server"`)
+ vllm_server_base_url: str | None = field(
+ default=None,
+ metadata={
+ "help": "Base URL for the vLLM server (e.g., 'http://localhost:8000'). If provided, `vllm_server_host` "
+ "and `vllm_server_port` are ignored."
+ },
+ )
+ vllm_server_host: str = field(
+ default="0.0.0.0",
+ metadata={"help": "Host of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."},
+ )
+ vllm_server_port: int = field(
+ default=8000,
+ metadata={"help": "Port of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."},
+ )
+ vllm_server_timeout: float = field(
+ default=240.0,
+ metadata={
+ "help": "Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up "
+ "after the timeout, a `ConnectionError` is raised."
+ },
+ )
+ vllm_group_port: int = field(
+ default=51216,
+ metadata={
+ "help": "Port number for the weight update group. This is used to communicate with the vLLM server. "
+ "Unless the port is occupied, there is no need to change it.",
+ },
+ )
+
+ # Parameters that control colocated vLLM execution (only used when `vllm_mode` is `"colocate"`)
+ vllm_gpu_memory_utilization: float = field(
+ default=0.3,
+ metadata={
+ "help": "Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set "
+ "to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when "
+ "launching the vLLM server via the `--vllm_gpu_memory_utilization` flag."
+ },
+ )
+ vllm_max_model_length: int | None = field(
+ default=None,
+ metadata={
+ "help": "Context window for vLLM. Set it to at least the maximum prompt length in the dataset plus "
+ "`max_completion_length`; if omitted, it is inferred from the model config."
+ },
+ )
+ vllm_tensor_parallel_size: int = field(
+ default=1,
+ metadata={
+ "help": "Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set "
+ "to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when "
+ "launching the vLLM server via the `--vllm_tensor_parallel_size` flag."
+ },
+ )
+
+ # Parameters that control the training
+ beta: float = field(
+ default=0.05,
+ metadata={
+ "help": "KL coefficient. If `0.0`, the reference model is not loaded, reducing memory usage and improving "
+ "training speed."
+ },
+ )
+ num_iterations: int = field(
+ default=1,
+ metadata={"help": "Number of iterations per batch (denoted as μ in the algorithm)."},
+ )
+ epsilon: float = field(
+ default=0.2,
+ metadata={"help": "Epsilon value for clipping."},
+ )
+ epsilon_high: float | None = field(
+ default=None,
+ metadata={
+ "help": "Upper-bound epsilon value for clipping. If not specified, it defaults to the same value as the "
+ "lower-bound specified in argument `epsilon`. Paper DAPO recommends `0.28`."
+ },
+ )
+ reward_weights: list[float] | None = field(
+ default=None,
+ metadata={
+ "help": "Weights for each reward function. Must match the number of reward functions. If `None`, all "
+ "rewards are weighted equally with weight `1.0`."
+ },
+ )
+ normalize_advantages: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to normalize advantages. Normalization is done per generation batch to have mean `0.0` "
+ "and standard deviation of `1.0`."
+ },
+ )
+ reward_clip_range: tuple[float, float] | None = field(
+ default=None,
+ metadata={"help": "Clip range for rewards as (min, max). If None, no clipping is applied."},
+ )
+ mask_truncated_completions: bool = field(
+ default=False,
+ metadata={
+ "help": "When enabled, truncated completions are excluded from the loss calculation, preventing them from "
+ "being incorrectly penalized and introducing noise during training. According to the DAPO paper, this is "
+ "a good practice for training stability."
+ },
+ )
+ sync_ref_model: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to synchronize the reference model with the active model every `ref_model_sync_steps` "
+ "steps, using the `ref_model_mixup_alpha` parameter."
+ },
+ )
+ ref_model_mixup_alpha: float = field(
+ default=0.6,
+ metadata={
+ "help": "α parameter from the TR-DPO paper, which controls the mix between the current policy and the "
+ "previous reference policy during updates. The reference policy is updated according to the equation: "
+ "`π_ref = α * π_θ + (1 - α) * π_ref_prev`. To use this parameter, you must set `sync_ref_model=True`."
+ },
+ )
+ ref_model_sync_steps: int = field(
+ default=512,
+ metadata={
+ "help": "τ parameter from the TR-DPO paper, which determines how frequently the current policy is "
+ "synchronized with the reference policy. To use this parameter, you must set `sync_ref_model=True`."
+ },
+ )
+
+ # Parameters that control the logging
+ log_completions: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to log a sample of (prompt, completion) pairs every `logging_steps` steps. If `rich` is "
+ "installed, it prints the sample. If `wandb` logging is enabled, it logs it to `wandb`."
+ },
+ )
+ num_completions_to_print: int | None = field(
+ default=None,
+ metadata={"help": "Number of completions to print with `rich`. If `None`, all completions are logged."},
+ )
+ log_unique_prompts: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to log unique prompts. If `True`, only unique prompts are logged. If `False`, all "
+ "prompts are logged."
+ },
+ )
+
+ # Parameters that control generation acceleration powered by transformers continuous batching
+ use_transformers_continuous_batching: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to use transformers' continuous batching engine for generating completions. Requires "
+ "transformers>=5.8.0."
+ },
+ )
+ transformers_continuous_batching_config: dict | None = field(
+ default=None,
+ metadata={"help": "Keyword arguments for `transformers.generation.ContinuousBatchingConfig`."},
+ )
+
+ # Deprecated parameters
+ use_transformers_paged: bool = field(
+ default=False,
+ metadata={"help": "Deprecated. Use `use_transformers_continuous_batching` instead."},
+ )
+
+ def __post_init__(self):
+ super().__post_init__()
+
+ if self.use_transformers_paged:
+ warnings.warn(
+ "`use_transformers_paged` is deprecated and will be removed in v2.0.0. Use "
+ "`use_transformers_continuous_batching` instead.",
+ FutureWarning,
+ stacklevel=3,
+ )
+ self.use_transformers_continuous_batching = True
+
+ if self.parallelism_config is not None and (
+ self.parallelism_config.cp_enabled or self.parallelism_config.sp_enabled
+ ):
+ raise ValueError(
+ "RLOOTrainer does not support sequence-dim parallelism (`parallelism_config.cp_size > 1` or "
+ "`parallelism_config.sp_size > 1`) yet. RLOO builds model inputs after generation inside the trainer, "
+ "so Transformers' context-parallel / Ulysses sequence-parallel input sharding cannot be applied to the "
+ "raw generation batch. Set both `cp_size=1` and `sp_size=1`, or disable `parallelism_config`."
+ )
+
+ num_processes = self.world_size
+ # The current default effective batch size
+ if self.generation_batch_size is None and self.steps_per_generation is None:
+ self.steps_per_generation = self.gradient_accumulation_steps
+ self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation
+ elif self.generation_batch_size is not None and self.steps_per_generation is None:
+ # Just ensure the value is divisible by the global batch size
+ if self.generation_batch_size % (self.per_device_train_batch_size * num_processes) != 0:
+ raise ValueError(
+ f"generation_batch_size ({self.generation_batch_size}) must be divisible by the global batch size "
+ f"({self.per_device_train_batch_size * num_processes})."
+ )
+ self.steps_per_generation = self.generation_batch_size // (
+ self.per_device_train_batch_size * num_processes
+ )
+ elif self.generation_batch_size is None and self.steps_per_generation is not None:
+ self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation
+ else:
+ raise ValueError(
+ "'generation_batch_size' and 'steps_per_generation' can not be both configured at the same time"
+ )
+
+ if self.do_eval and self.eval_strategy != "no":
+ # Determine the number of generations to use for evaluation
+ num_generations = self.num_generations_eval or self.num_generations
+
+ # Just ensure the value is divisible by the global batch size
+ if (self.per_device_eval_batch_size * num_processes) % num_generations != 0:
+ raise ValueError(
+ f"The global eval batch size ({self.per_device_eval_batch_size} * {num_processes}) must be "
+ f"divisible by the number of generations used for evaluation ({num_generations})."
+ )
+
+ # The generation batch must contain full prompt groups (no partials), so it must be divisible by
+ # num_generations.
+ if self.generation_batch_size % self.num_generations != 0:
+ raise ValueError(
+ f"generation_batch_size ({self.generation_batch_size}) must be divisible by num_generations "
+ f"({self.num_generations})."
+ )
+
+ if self.num_generations < 2:
+ raise ValueError(
+ "RLOO requires at least 2 generations per prompt to calculate the advantages. You provided "
+ f"{self.num_generations}, which is less than the minimum required."
+ )
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/rloo_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/rloo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e316481efd4f330b069ff259512c462c055ca56
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/rloo_trainer.py
@@ -0,0 +1,1638 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import atexit
+import copy
+import inspect
+import math
+import textwrap
+import time
+from collections import defaultdict, deque
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.utils.data
+import transformers
+from accelerate.logging import get_logger
+from accelerate.utils import gather, gather_object, is_peft_model, set_seed
+from datasets import Dataset, IterableDataset
+from packaging.version import Version
+from torch import nn
+from torch.utils.data import Sampler
+from transformers import (
+ AutoModelForSequenceClassification,
+ AutoProcessor,
+ AutoTokenizer,
+ GenerationConfig,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+ ProcessorMixin,
+ TrainerCallback,
+ is_trackio_available,
+ is_wandb_available,
+)
+from transformers.utils import is_peft_available, is_rich_available
+
+from ..data_utils import apply_chat_template, is_conversational, prepare_multimodal_messages
+from ..distributed import DistributedBackend
+from ..extras.profiling import profiling_context, profiling_decorator
+from ..generation.vllm_generation import VLLMGeneration
+from ..models import prepare_deepspeed, prepare_fsdp, unwrap_model_for_generation
+from ..models.utils import disable_gradient_checkpointing
+from .base_trainer import _BaseTrainer
+from .callbacks import SyncRefModelCallback
+from .rloo_config import RLOOConfig
+from .utils import (
+ RepeatSampler,
+ create_model_from_path,
+ disable_dropout_in_model,
+ entropy_from_logits,
+ get_config_model_id,
+ identity,
+ nanmax,
+ nanmin,
+ nanstd,
+ pad,
+ print_prompt_completions_sample,
+ selective_log_softmax,
+ shuffle_sequence_dict,
+ shutdown_event_loop_in_daemon,
+ split_pixel_values_by_grid,
+ split_tensor_dict,
+ start_event_loop_in_daemon,
+ unsplit_pixel_values_by_grid,
+ use_adapter,
+)
+
+
+if is_peft_available():
+ import peft
+ from peft import LoraConfig, PeftConfig, PeftModel, get_peft_model
+
+
+if is_wandb_available():
+ import wandb
+
+if is_trackio_available():
+ import trackio
+
+
+logger = get_logger(__name__)
+
+# A reward function can be a string, interpreted as a model ID and loaded as a pretrained model, a pretrained model, or
+# a callable that returns a list of floats (the rewards). The callable receives prompts, completions, and additional
+# arguments from the trainer (refer to the trainer's source for details). To ensure forward compatibility, it should
+# accept **kwargs.
+RewardFunc = str | PreTrainedModel | Callable[..., list[float | None]]
+
+
+class RLOOTrainer(_BaseTrainer):
+ """
+ Trainer for the Reinforce Leave One Out (RLOO) method. This algorithm was initially proposed in the paper [Back to
+ Basics: Revisiting REINFORCE Style Optimization for Learning from Human Feedback in
+ LLMs](https://huggingface.co/papers/2402.14740).
+
+ Example:
+
+ ```python
+ from trl import RLOOTrainer
+ from trl.rewards import accuracy_reward
+ from datasets import load_dataset
+
+ dataset = load_dataset("trl-lib/DeepMath-103K", split="train")
+
+ trainer = RLOOTrainer(
+ model="Qwen/Qwen2.5-0.5B-Instruct",
+ reward_funcs=accuracy_reward,
+ train_dataset=dataset,
+ )
+ trainer.train()
+ ```
+
+ Args:
+ model (`str` or [`~transformers.PreTrainedModel`] or [`~peft.PeftModel`]):
+ Model to be trained. Can be either:
+
+ - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a
+ path to a *directory* containing model weights saved using
+ [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded
+ using `.from_pretrained` (where `` is derived from the model
+ config) with the keyword arguments in `args.model_init_kwargs`.
+ - A [`~transformers.PreTrainedModel`] object. Only causal language models are supported.
+ - A [`~peft.PeftModel`] object. Only causal language models are supported.
+ reward_funcs (`RewardFunc | list[RewardFunc]`):
+ Reward functions to be used for computing the rewards. To compute the rewards, we call all the reward
+ functions with the prompts and completions and sum the rewards. Can be either:
+
+ - A single reward function, such as:
+ - A string: The *model ID* of a pretrained model hosted inside a model repo on huggingface.co, or a
+ path to a *directory* containing model weights saved using
+ [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded
+ using [`~transformers.AutoModelForSequenceClassification.from_pretrained`] with `num_labels=1` and the
+ keyword arguments in `args.model_init_kwargs`.
+ - A [`~transformers.PreTrainedModel`] object: Only sequence classification models are supported.
+ - A custom reward function: The function is provided with the prompts and the generated completions,
+ plus any additional columns in the dataset. It should return a list of rewards. Custom reward
+ functions can be either synchronous or asynchronous and can also return `None` when the reward is
+ not applicable to those samples. This is useful for multi-task training where different reward
+ functions apply to different types of samples. When a reward function returns `None` for a sample,
+ that reward function is excluded from the reward calculation for that sample. For more details, see
+ [Using a custom reward
+ function](#using-a-custom-reward-function).
+
+ The trainer's state is also passed to the reward function. The trainer's state is an instance of
+ [`~transformers.TrainerState`] and can be accessed by accessing the `trainer_state` argument to the
+ reward function's signature.
+ - A list of reward functions, where each item can independently be any of the above types. Mixing different
+ types within the list (e.g., a string model ID and a custom reward function) is allowed.
+ args ([`RLOOConfig`], *optional*):
+ Configuration for this trainer. If `None`, a default configuration is used.
+ train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]):
+ Dataset to use for training. It must include a column `"prompt"`. Any additional columns in the dataset is
+ ignored. The format of the samples can be either:
+
+ - [Standard](dataset_formats#standard): Each sample contains plain text.
+ - [Conversational](dataset_formats#conversational): Each sample contains structured messages (e.g., role
+ and content).
+ eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`):
+ Dataset to use for evaluation. It must meet the same requirements as `train_dataset`.
+ processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.ProcessorMixin`], *optional*):
+ Processing class used to process the data. The padding side must be set to "left". If `None`, the
+ processing class is loaded from the model's name with [`~transformers.AutoProcessor.from_pretrained`]. A
+ padding token, `tokenizer.pad_token`, must be set. If the processing class has not set a padding token,
+ `tokenizer.eos_token` will be used as the default.
+ reward_processing_classes ([`~transformers.PreTrainedTokenizerBase`] or `list[PreTrainedTokenizerBase]`, *optional*):
+ Processing classes corresponding to the reward functions specified in `reward_funcs`. Can be either:
+
+ - A single processing class: Used when `reward_funcs` contains only one reward function.
+ - A list of processing classes: Must match the order and length of the reward functions in `reward_funcs`.
+ If set to `None`, or if an element of the list corresponding to a [`~transformers.PreTrainedModel`] is
+ `None`, the tokenizer for the model is automatically loaded using
+ [`~transformers.AutoTokenizer.from_pretrained`]. For elements in `reward_funcs` that are custom reward
+ functions (not [`~transformers.PreTrainedModel`]), the corresponding entries in `reward_processing_classes`
+ are ignored.
+ callbacks (list of [`~transformers.TrainerCallback`], *optional*):
+ List of callbacks to customize the training loop. Will add those to the list of default callbacks detailed
+ in [here](https://huggingface.co/docs/transformers/main_classes/callback).
+
+ If you want to remove one of the default callbacks used, use the [`~transformers.Trainer.remove_callback`]
+ method.
+ optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *optional*, defaults to `(None, None)`):
+ A tuple containing the optimizer and the scheduler to use. Will default to an instance of `AdamW` on your
+ model and a scheduler given by [`~transformers.get_linear_schedule_with_warmup`] controlled by `args`.
+ peft_config ([`~peft.PeftConfig`], *optional*):
+ PEFT configuration used to wrap the model. If `None`, the model is not wrapped.
+ """
+
+ _tag_names = ["trl", "rloo"]
+ _name = "RLOO"
+ _paper = {
+ "title": "Back to Basics: Revisiting REINFORCE-Style Optimization for Learning from Human Feedback in LLMs",
+ "id": "2402.14740",
+ # docstyle-ignore
+ "citation": textwrap.dedent("""\
+ @inproceedings{ahmadian2024back,
+ title = {{Back to Basics: Revisiting REINFORCE-Style Optimization for Learning from Human Feedback in LLMs}},
+ author = {Arash Ahmadian and Chris Cremer and Matthias Gall{\'{e}} and Marzieh Fadaee and Julia Kreutzer and Olivier Pietquin and Ahmet {\"{U}}st{\"{u}}n and Sara Hooker},
+ year = 2024,
+ booktitle = {Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), {ACL} 2024, Bangkok, Thailand, August 11-16, 2024},
+ pages = {12248--12267},
+ publisher = {Association for Computational Linguistics},
+ editor = {Lun{-}Wei Ku and Andre Martins and Vivek Srikumar},
+ }"""),
+ }
+
+ def __init__(
+ self,
+ model: "str | PreTrainedModel | PeftModel",
+ reward_funcs: RewardFunc | list[RewardFunc],
+ args: RLOOConfig | None = None,
+ train_dataset: Dataset | IterableDataset | None = None,
+ eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None,
+ processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None,
+ reward_processing_classes: PreTrainedTokenizerBase | list[PreTrainedTokenizerBase] | None = None,
+ callbacks: list[TrainerCallback] | None = None,
+ optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None),
+ peft_config: "PeftConfig | None" = None,
+ ):
+ # Args
+ if args is None:
+ model_name = model if isinstance(model, str) else get_config_model_id(model.config)
+ model_name = model_name.split("/")[-1]
+ args = RLOOConfig(f"{model_name}-RLOO")
+
+ # Model
+ if isinstance(model, str):
+ model_init_kwargs = args.model_init_kwargs or {}
+ # Distributed training requires device_map=None ("auto" fails)
+ if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]:
+ model_init_kwargs["device_map"] = None
+ model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+ model = create_model_from_path(model, **model_init_kwargs)
+ else:
+ if args.model_init_kwargs is not None:
+ logger.warning(
+ "You passed `model_init_kwargs` to the `RLOOConfig`, but your model is already instantiated. "
+ "The `model_init_kwargs` will be ignored."
+ )
+ # Non-quantized models do not have the `is_loaded_in_{8,4}bit` attributes, whereas quantized models do
+ _is_quantized_model = getattr(model, "is_loaded_in_4bit", False) or getattr(model, "is_loaded_in_8bit", False)
+
+ # Some models (SmolVLM/Idefics3) don't support `logits_to_keep` argument and error out if we pass it
+ # Inspect the forward method before we wrap the model with PEFT
+ self.model_kwarg_keys = (
+ inspect.signature(model.forward).parameters.keys()
+ if not hasattr(model, "get_base_model")
+ else inspect.signature(model.get_base_model().forward).parameters.keys()
+ )
+
+ # Processing class
+ if processing_class is None:
+ processing_class = AutoProcessor.from_pretrained(
+ get_config_model_id(model.config),
+ truncation_side="left",
+ padding_side="left",
+ trust_remote_code=args.trust_remote_code,
+ )
+
+ if args.use_transformers_continuous_batching and isinstance(processing_class, ProcessorMixin):
+ raise ValueError(
+ "`use_transformers_continuous_batching` does not support multimodal models. Use `use_vllm` instead."
+ )
+
+ # Handle pad token for processors or tokenizers
+ if isinstance(processing_class, ProcessorMixin):
+ self._tokenizer = processing_class.tokenizer
+ elif isinstance(processing_class, PreTrainedTokenizerBase):
+ self._tokenizer = processing_class
+ else:
+ raise TypeError("The `processing_class` must be either a `PreTrainedTokenizerBase` or a `ProcessorMixin`")
+
+ if self._tokenizer.pad_token is None:
+ self._tokenizer.pad_token = self._tokenizer.eos_token
+
+ # PEFT
+ if peft_config is not None:
+ if not is_peft_available():
+ raise ImportError(
+ "You passed `peft_config` but the `peft` library is not installed. "
+ "Install it with `pip install trl[peft]`."
+ )
+ if not isinstance(peft_config, PeftConfig):
+ raise TypeError(
+ f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), "
+ f"got {type(peft_config).__name__}."
+ )
+ if is_peft_model(model):
+ raise ValueError(
+ "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first merge "
+ "and unload the existing adapter, save the resulting base model, and then pass that base model along "
+ "with the new `peft_config` to the trainer."
+ )
+ # Create PEFT model
+ # ZeRO-3 + PEFT for non-quantized models:
+ # - PEFT's default autocast_adapter_dtype=True upcasts LoRA adapter params to fp32 even when the base model is bf16.
+ # - ZeRO-3's _allgather_params_coalesced allocates output buffers using the dtype of the first persistent parameter,
+ # so mixed-dtype persistent_parameters (bf16 base + fp32 LoRA) cause a TypeError on the first optimizer step.
+ # - Passing autocast_adapter_dtype=False keeps adapter params in the base model dtype (bf16), fixing the mismatch.
+ # - This is safe: the fp32 upcast is a QLoRA-specific concern (low-bit quantized base models), not needed for
+ # non-quantized bf16 training.
+ # - See:
+ # - TRL issue: https://github.com/huggingface/trl/issues/6089
+ # - Upstream issue: https://github.com/deepspeedai/DeepSpeed/issues/8072
+ # - autocast_adapter_dtype was introduced in PEFT 0.12.0; before, no upcast existed: no need to pass the kwarg
+ get_peft_model_kwargs = {}
+ if (
+ args.deepspeed_plugin is not None
+ and args.deepspeed_plugin.zero_stage == 3
+ and not _is_quantized_model
+ and Version(peft.__version__) >= Version("0.12.0")
+ ):
+ get_peft_model_kwargs["autocast_adapter_dtype"] = False
+ model = get_peft_model(model, peft_config, **get_peft_model_kwargs)
+
+ elif is_peft_model(model):
+ # If the model is a PEFT model with a pretrained adapter, we need to create a "ref" adapter that is a copy
+ # of the "default" adapter, so that we can use it as the reference model during the training. PEFT only
+ # supports one adapter per model when the LoRA config uses `target_parameters` (see peft#3340), so in that
+ # case we skip the "ref" adapter and compute the reference log probs with adapters disabled, i.e. with the
+ # base model.
+ default_config = model.peft_config["default"]
+ if isinstance(default_config, LoraConfig) and default_config.target_parameters:
+ logger.warning(
+ "PEFT can't add a frozen reference adapter alongside one that uses `target_parameters` "
+ "(peft#3340), so the reference log probs are computed from the base model (adapters disabled). "
+ "If you wrapped the model only to apply LoRA, pass a `peft_config` to the trainer instead; if you "
+ "wrapped it deliberately (pretrained adapter or custom init), note that the base model matches "
+ "your adapter only when it's freshly zero-initialized. If it is, this warning is safe to ignore."
+ )
+ else:
+ model.add_adapter("ref", default_config)
+ for name, param in model.named_parameters():
+ if ".default." in name:
+ ref_name = name.replace(".default.", ".ref.")
+ ref_param = model.get_parameter(ref_name)
+ ref_param.data.copy_(param.data)
+
+ # When using gradient checkpointing with PEFT, we need to enable input gradients. transformers.Trainer normally
+ # handles this, but a bug currently prevents it; see https://github.com/huggingface/transformers/issues/42489
+ if is_peft_model(model) and args.gradient_checkpointing:
+ model.enable_input_require_grads()
+
+ # When using QLoRA, the PEFT adapter weights are converted to bf16 to follow the recommendations from the
+ # original paper (see https://huggingface.co/papers/2305.14314, paragraph 3). Normally, this can be done by
+ # passing `autocast_adapter_dtype=False` to `get_peft_model`, but this option is not yet supported for
+ # quantized models. See: https://github.com/huggingface/peft/issues/2889
+ if _is_quantized_model:
+ for param in model.parameters():
+ if param.requires_grad:
+ param.data = param.data.to(torch.bfloat16)
+
+ # Reward functions
+ if not isinstance(reward_funcs, list):
+ reward_funcs = [reward_funcs]
+ self.reward_func_names = []
+ for i, reward_func in enumerate(reward_funcs):
+ if isinstance(reward_func, str):
+ model_init_kwargs = args.model_init_kwargs or {}
+ # Distributed training requires device_map=None ("auto" fails)
+ if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]:
+ model_init_kwargs["device_map"] = None
+ model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+ reward_funcs[i] = AutoModelForSequenceClassification.from_pretrained(
+ reward_func, num_labels=1, **model_init_kwargs
+ )
+ if isinstance(reward_funcs[i], nn.Module): # Use Module over PretrainedModel for compat w/ compiled models
+ self.reward_func_names.append(get_config_model_id(reward_funcs[i].config).split("/")[-1])
+ else:
+ self.reward_func_names.append(reward_funcs[i].__name__)
+ self.reward_funcs = reward_funcs
+
+ self._has_async_funcs = any(inspect.iscoroutinefunction(func) for func in self.reward_funcs)
+ if self._has_async_funcs:
+ self.async_loop_thread, self.async_loop, self.async_loop_ready_event = start_event_loop_in_daemon(
+ name="RLOOTrainer-AsyncRewardLoop"
+ )
+ # wait until the event loop is running in the daemon thread
+ self.async_loop_ready_event.wait()
+ atexit.register(shutdown_event_loop_in_daemon, self.async_loop_thread, self.async_loop)
+
+ # Reward weights
+ if args.reward_weights is not None:
+ if len(args.reward_weights) != len(reward_funcs):
+ raise ValueError(
+ f"Number of reward weights ({len(args.reward_weights)}) must match number of reward "
+ f"functions ({len(reward_funcs)})"
+ )
+ self.reward_weights = torch.tensor(args.reward_weights, dtype=torch.float32)
+ else:
+ self.reward_weights = torch.ones(len(reward_funcs), dtype=torch.float32)
+
+ # Reward processing class
+ if reward_processing_classes is None:
+ reward_processing_classes = [None] * len(reward_funcs)
+ elif not isinstance(reward_processing_classes, list):
+ reward_processing_classes = [reward_processing_classes]
+ if len(reward_processing_classes) != len(reward_funcs):
+ raise ValueError(
+ f"The number of reward processing classes ({len(reward_processing_classes)}) must match the number of "
+ f"reward functions ({len(reward_funcs)})."
+ )
+
+ for i, (reward_processing_class, reward_func) in enumerate(
+ zip(reward_processing_classes, reward_funcs, strict=True)
+ ):
+ if isinstance(reward_func, PreTrainedModel):
+ if reward_processing_class is None:
+ reward_processing_class = AutoTokenizer.from_pretrained(
+ get_config_model_id(reward_func.config), trust_remote_code=args.trust_remote_code
+ )
+ if reward_processing_class.pad_token_id is None:
+ reward_processing_class.pad_token = reward_processing_class.eos_token
+ # The reward model computes the reward for the latest non-padded token in the input sequence.
+ # So it's important to set the pad token ID to the padding token ID of the processing class.
+ reward_func.config.pad_token_id = reward_processing_class.pad_token_id
+ reward_processing_classes[i] = reward_processing_class
+
+ self.reward_processing_classes = reward_processing_classes
+
+ # Training arguments
+ self.max_completion_length = args.max_completion_length
+ self.num_generations = args.num_generations
+ self.num_generations_eval = args.num_generations_eval or self.num_generations
+ self.chat_template_kwargs = args.chat_template_kwargs or {}
+ self.temperature = args.temperature
+ self.top_p = args.top_p
+ self.top_k = args.top_k
+ self.min_p = args.min_p
+ self.repetition_penalty = args.repetition_penalty
+ self.use_transformers_continuous_batching = args.use_transformers_continuous_batching
+ if self.use_transformers_continuous_batching:
+ if not Version(transformers.__version__) >= Version("5.8.0"):
+ raise ImportError(
+ "Using `use_transformers_continuous_batching` requires transformers>=5.8.0. "
+ "Please upgrade with `pip install --upgrade transformers`."
+ )
+ from transformers.generation import ContinuousBatchingConfig
+
+ cb_kwargs = dict(args.transformers_continuous_batching_config or {})
+ # The transformers default (0.9) leaves almost no VRAM for the training backward pass;
+ # use a training-aware default unless the user has set it explicitly.
+ cb_kwargs.setdefault("max_memory_percent", 0.5)
+ self.continuous_batching_config = ContinuousBatchingConfig(**cb_kwargs)
+ else:
+ self.continuous_batching_config = None
+ self.pad_to_multiple_of = args.pad_to_multiple_of
+ self.use_vllm = args.use_vllm
+ self.vllm_mode = args.vllm_mode
+ self.vllm_gpu_memory_utilization = args.vllm_gpu_memory_utilization # only applies to colocation mode
+ self.vllm_tensor_parallel_size = args.vllm_tensor_parallel_size # only applies to colocation mode
+ self.normalize_advantages = args.normalize_advantages
+ self.mask_truncated_completions = args.mask_truncated_completions
+ self.reward_clip_range = args.reward_clip_range
+
+ # Datasets
+ self.shuffle_dataset = args.shuffle_dataset
+
+ if train_dataset is None:
+ raise ValueError("`train_dataset` is required")
+ elif (
+ isinstance(train_dataset, IterableDataset)
+ or isinstance(eval_dataset, IterableDataset)
+ or (
+ isinstance(eval_dataset, dict) and any(isinstance(ds, IterableDataset) for ds in eval_dataset.values())
+ )
+ ):
+ # See https://github.com/huggingface/trl/issues/3213
+ raise NotImplementedError(
+ "Iterable datasets are not yet supported in RLOOTrainer. Please use a standard dataset instead."
+ )
+
+ # Multi-step
+ self.num_iterations = args.num_iterations
+ self.epsilon_low = args.epsilon
+ self.epsilon_high = args.epsilon_high if args.epsilon_high is not None else args.epsilon
+
+ # MoE load-balancing auxiliary loss, applied to Mixture-of-Experts models (no effect otherwise)
+ text_config = model.config.get_text_config()
+ is_moe = getattr(text_config, "output_router_logits", None) is not None
+ self.aux_loss_enabled = is_moe and args.router_aux_loss_coef != 0.0
+ self.router_aux_loss_coef = args.router_aux_loss_coef
+ # Tracks the number of iterations (forward + backward passes), including those within a grad accum cycle
+ self._step = 0
+ # Buffer the batch to reuse generated outputs across multiple updates. For more details, see
+ # `_get_train_sampler` and `_prepare_inputs`.
+ self._buffered_inputs = None
+
+ # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was
+ # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream
+ # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we
+ # default to the recommended non-reentrant behavior here, while preserving any user-provided value.
+ if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"):
+ args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {}
+ args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False)
+
+ super().__init__(
+ model=model,
+ args=args,
+ data_collator=identity, # No data collation is needed in RLOO
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=processing_class,
+ callbacks=callbacks,
+ optimizers=optimizers,
+ )
+
+ # Reference model
+ self.beta = args.beta
+ if self.beta == 0.0:
+ # If beta is 0.0, the reference model is not needed
+ self.ref_model = None
+ elif is_peft_model(model):
+ # If PEFT is used, the reference model is not needed since the adapter can be disabled
+ # to revert to the initial model.
+ self.ref_model = None
+ else:
+ # For deepspeed, fsdp or non-distributed models, create a reference model from scratch
+ model_init_kwargs = args.model_init_kwargs or {}
+ # Distributed training requires device_map=None ("auto" fails)
+ if self.args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]:
+ model_init_kwargs["device_map"] = None
+ model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+ self.ref_model = create_model_from_path(get_config_model_id(self.model.config), **model_init_kwargs)
+
+ # Disable dropout in the models
+ if args.disable_dropout:
+ disable_dropout_in_model(model)
+ if self.ref_model is not None:
+ disable_dropout_in_model(self.ref_model)
+
+ # Initialize the metrics
+ self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)}
+ self._total_train_tokens = 0
+ self._current_train_step_time = 0.0
+ self.log_completions = args.log_completions
+ self.log_unique_prompts = args.log_unique_prompts
+ self.num_completions_to_print = args.num_completions_to_print
+ # Keep logs sized to the generation batch to record only outputs from the latest model update.
+ self._logs = {
+ "images": deque(maxlen=args.generation_batch_size),
+ "prompt": deque(maxlen=args.generation_batch_size),
+ "completion": deque(maxlen=args.generation_batch_size),
+ "rewards": defaultdict(lambda: deque(maxlen=args.generation_batch_size)),
+ "advantages": deque(maxlen=args.generation_batch_size),
+ "extra": defaultdict(lambda: deque(maxlen=args.generation_batch_size)),
+ }
+ # Buffers for user-logged data from reward functions, flushed after gathering
+ self._pending_extra_logs = defaultdict(list)
+ self._pending_metrics = defaultdict(list)
+
+ # Ensure each process receives a unique seed to prevent duplicate completions when generating with
+ # transformers if num_generations exceeds per_device_train_batch_size. We could skip it if we use vLLM, but
+ # it's safer to set it in all cases.
+ set_seed(args.seed, device_specific=True)
+
+ if self.use_vllm:
+ # Initialize vLLM generation backend
+ self.vllm_generation = VLLMGeneration(
+ model=self.model,
+ accelerator=self.accelerator,
+ processing_class=self.processing_class,
+ # vLLM configuration
+ mode=args.vllm_mode,
+ structured_outputs_regex=args.vllm_structured_outputs_regex,
+ # Server mode configuration
+ server_base_url=args.vllm_server_base_url,
+ server_host=args.vllm_server_host,
+ server_port=args.vllm_server_port,
+ group_port=args.vllm_group_port,
+ server_timeout=args.vllm_server_timeout,
+ # Colocate mode configuration
+ tensor_parallel_size=args.vllm_tensor_parallel_size,
+ gpu_memory_utilization=args.vllm_gpu_memory_utilization,
+ max_model_length=args.vllm_max_model_length,
+ max_num_seqs=args.per_device_train_batch_size
+ * args.vllm_tensor_parallel_size
+ * args.steps_per_generation,
+ enable_sleep_mode=args.vllm_enable_sleep_mode,
+ model_impl=args.vllm_model_impl,
+ # Generation configuration
+ repetition_penalty=self.repetition_penalty,
+ temperature=self.temperature,
+ top_p=self.top_p,
+ top_k=self.top_k,
+ min_p=self.min_p,
+ max_completion_length=self.max_completion_length,
+ logprobs=None, # we don't need logprobs from vLLM in RLOO
+ generation_kwargs=args.generation_kwargs,
+ )
+ self._last_loaded_step = -1 # tag to avoid useless loading during grad accumulation
+ else:
+ generation_kwargs = {
+ "max_new_tokens": self.max_completion_length,
+ "do_sample": True,
+ "pad_token_id": self._tokenizer.pad_token_id,
+ "bos_token_id": self._tokenizer.bos_token_id,
+ "eos_token_id": self._tokenizer.eos_token_id,
+ "temperature": self.temperature,
+ "top_p": self.top_p,
+ "top_k": self.top_k,
+ "min_p": self.min_p,
+ "repetition_penalty": self.repetition_penalty,
+ "cache_implementation": args.cache_implementation,
+ }
+ if args.generation_kwargs is not None:
+ generation_kwargs.update(args.generation_kwargs)
+ self.generation_config = GenerationConfig(**generation_kwargs, disable_compile=True)
+ # Keep training-specific generation kwargs to overwrite model's original generation config
+ self.generation_kwargs = generation_kwargs
+
+ # Gradient accumulation requires scaled loss. Normally, loss scaling in the parent class depends on whether the
+ # model accepts loss-related kwargs. Since we compute our own loss, this check is irrelevant. We set
+ # self.model_accepts_loss_kwargs to False to enable scaling.
+ self.model_accepts_loss_kwargs = False
+ self._dist = DistributedBackend(self.accelerator)
+
+ # Add tags to the model
+ self.model.add_model_tags(self._tag_names)
+
+ if self.ref_model is not None:
+ if self.is_deepspeed_enabled:
+ self.ref_model = prepare_deepspeed(self.ref_model, self.accelerator)
+ elif self.is_fsdp_enabled:
+ self.ref_model = prepare_fsdp(self.ref_model, self.accelerator)
+ else:
+ self.ref_model = self.accelerator.prepare_model(self.ref_model, evaluation_mode=True)
+
+ if args.sync_ref_model:
+ if self.beta == 0.0:
+ raise ValueError(
+ "You passed `sync_ref_model=True` while `beta=0.0`, which means the reference model is not used "
+ "during training. Consequently, RLOOTrainer does not create a `ref_model` instance, and there is "
+ "nothing to synchronize. Please set `sync_ref_model=False`, or set `beta` to a non-zero value."
+ )
+ if is_peft_model(model):
+ raise NotImplementedError(
+ "You passed `sync_ref_model=True` while using a PEFT model, which is currently not supported. "
+ "With PEFT, RLOOTrainer does not keep a separate reference model in memory; instead, it recovers "
+ "reference behavior by temporarily disabling the adapter. As a result, there is no standalone "
+ "`ref_model` instance to synchronize. Use `sync_ref_model=False`, or opt for full fine-tuning if "
+ "you need a synced reference model. If you need `sync_ref_model` to work with PEFT, please open a "
+ "feature request at https://github.com/huggingface/trl/issues."
+ )
+ self.add_callback(SyncRefModelCallback(ref_model=self.ref_model, accelerator=self.accelerator))
+
+ for i, reward_func in enumerate(self.reward_funcs):
+ if isinstance(reward_func, PreTrainedModel):
+ if self.is_deepspeed_enabled:
+ self.reward_funcs[i] = prepare_deepspeed(reward_func, self.accelerator)
+ else:
+ # set device placement to True to make `prepare_model` move `reward_func` to device when using fsdp
+ self.reward_funcs[i] = self.accelerator.prepare_model(
+ reward_func, evaluation_mode=True, device_placement=True
+ )
+
+ def _set_signature_columns_if_needed(self):
+ # If `self.args.remove_unused_columns` is True, non-signature columns are removed.
+ # By default, this method sets `self._signature_columns` to the model's expected inputs (usually, "input_ids"
+ # and "attention_mask"). In RLOOTrainer, we preprocess data, so using the model's signature columns doesn't
+ # work. Instead, we set them to the columns expected by the `training_step` method, hence the override.
+ if self._signature_columns is None:
+ self._signature_columns = ["prompt", "image", "images"]
+
+ # This method overrides `Trainer.get_train_dataloader` to support our custom batching strategy.
+ # Instead of returning a standard per-step batch (i.e., `per_device_batch_size), our dataloader loads an
+ # *generation* batch (i.e., `per_device_batch_size × steps_per_generation`). This allows us to generate completions
+ # once every steps_per_generation step—rather than once per accumulation step—which is significantly more
+ # efficient. The only change from the original implementation is multiplying the batch size by
+ # `steps_per_generation`. Thus, `_prepare_inputs` is called with this *generation* batch, and it handles the
+ # splitting internally.
+ # Maintenance note: This method is a copy-paste of the original `Trainer.get_train_dataloader` with only one line
+ # modification.
+ def get_train_dataloader(self):
+ return self._get_dataloader(
+ dataset=self.train_dataset,
+ description="Training",
+ batch_size=self._train_batch_size * self.args.steps_per_generation, # < this is the change
+ sampler_fn=self._get_train_sampler,
+ is_training=True,
+ )
+
+ def _get_train_sampler(self, dataset: Dataset | None = None) -> Sampler:
+ # Returns a sampler that
+ # 1. ensures each prompt is repeated across multiple processes. This guarantees that identical prompts are
+ # distributed to different GPUs, allowing rewards to be computed and normalized correctly within each prompt
+ # group. Using the same seed across processes ensures consistent prompt assignment, preventing discrepancies
+ # in group formation.
+ # 2. repeats the batch multiple times to allow reusing generations across multiple updates. Refer to
+ # _prepare_inputs to see how the generations are stored and reused.
+
+ # In the following figure, the values are the prompt indices. The first row shows the first sampled batch, the
+ # second row shows the second sampled batch, and so on.
+ #
+ # | GPU 0 | GPU 1 |
+ #
+ # global_step step <-───> num_generations=2
+ # <-───────> per_device_train_batch_size=3
+ # grad_accum ▲ ▲ 0 0 0 0 1 1 2 2 <- Generate for the first `steps_per_generation` (prompts 0 to 11); store the completions; use the first slice to compute the loss
+ # =2 ▼ | 0 1 3 3 4 4 5 5 <- Take the stored generations and use the second slice to compute the loss
+ # |
+ # | 1 2 6 6 7 7 8 8 <- Take the stored generations and use the third slice to compute the loss
+ # steps_per_gen=4 ▼ 1 3 9 9 10 10 11 11 <- Take the stored generations and use the fourth slice to compute the loss
+ #
+ # 2 4 12 12 13 13 14 14 <- Generate for the second `steps_per_generation` (prompts 12 to 23); store the completions; use the first slice to compute the loss
+ # 2 5 15 15 16 16 17 17 <- Take the stored generations and use the second slice to compute the loss
+ # ...
+ if dataset is None:
+ dataset = self.train_dataset
+ return RepeatSampler(
+ data_source=dataset,
+ mini_repeat_count=self.num_generations,
+ batch_size=self.args.generation_batch_size // self.num_generations,
+ repeat_count=self.num_iterations * self.args.steps_per_generation,
+ shuffle=self.shuffle_dataset,
+ seed=self.args.seed,
+ )
+
+ def _get_eval_sampler(self, eval_dataset) -> Sampler:
+ # See _get_train_sampler for an explanation of the sampler.
+ return RepeatSampler(
+ data_source=eval_dataset,
+ mini_repeat_count=self.num_generations_eval,
+ seed=self.args.seed,
+ )
+
+ @profiling_decorator
+ def _get_per_token_logps_and_entropies(
+ self,
+ model,
+ input_ids,
+ attention_mask,
+ logits_to_keep,
+ batch_size=None,
+ compute_entropy=False,
+ compute_aux_loss=False,
+ pixel_values=None,
+ image_grid_thw=None,
+ num_images=None,
+ pixel_attention_mask=None,
+ image_sizes=None,
+ token_type_ids=None,
+ mm_token_type_ids=None,
+ image_position_ids=None,
+ ) -> tuple[torch.Tensor, torch.Tensor | None, torch.Tensor | None]:
+ """Compute log-probs, (optionally) entropies, and (optionally) the MoE load-balancing aux loss."""
+ batch_size = batch_size or input_ids.size(0) # Chunk inputs into smaller batches to reduce memory peak
+ all_logps = []
+ all_entropies = []
+ all_aux_losses = []
+ for start in range(0, input_ids.size(0), batch_size):
+ input_ids_batch = input_ids[start : start + batch_size]
+ attention_mask_batch = attention_mask[start : start + batch_size]
+
+ # Build model inputs
+ model_inputs = {"input_ids": input_ids_batch, "attention_mask": attention_mask_batch}
+ if image_grid_thw is not None and pixel_values is not None:
+ rows_per_image = image_grid_thw.prod(dim=-1)
+ rows_per_sample = torch.split(rows_per_image, num_images)
+ rows_per_sample = torch.stack([s.sum() for s in rows_per_sample])
+ cum_rows = torch.cat([torch.tensor([0], device=rows_per_sample.device), rows_per_sample.cumsum(0)])
+ row_start, row_end = cum_rows[start].item(), cum_rows[start + batch_size].item()
+ model_inputs["pixel_values"] = pixel_values[row_start:row_end]
+ cum_imgs = torch.tensor([0] + num_images).cumsum(0)
+ img_start, img_end = cum_imgs[start], cum_imgs[start + batch_size]
+ model_inputs["image_grid_thw"] = image_grid_thw[img_start:img_end]
+ elif image_position_ids is not None and pixel_values is not None:
+ cum_imgs = torch.tensor([0] + num_images).cumsum(0)
+ img_start, img_end = cum_imgs[start], cum_imgs[start + batch_size]
+ model_inputs["pixel_values"] = pixel_values[img_start:img_end]
+ model_inputs["image_position_ids"] = image_position_ids[img_start:img_end]
+ elif pixel_values is not None:
+ model_inputs["pixel_values"] = pixel_values[start : start + batch_size]
+ if pixel_attention_mask is not None:
+ model_inputs["pixel_attention_mask"] = pixel_attention_mask[start : start + batch_size]
+ if image_sizes is not None:
+ model_inputs["image_sizes"] = image_sizes[start : start + batch_size]
+ if token_type_ids is not None:
+ model_inputs["token_type_ids"] = token_type_ids[start : start + batch_size]
+ if mm_token_type_ids is not None:
+ model_inputs["mm_token_type_ids"] = mm_token_type_ids[start : start + batch_size]
+
+ # Only add logits_to_keep if the model supports it
+ if "logits_to_keep" in self.model_kwarg_keys:
+ # We add 1 to `logits_to_keep` because the last logits of the sequence is later excluded
+ model_inputs["logits_to_keep"] = logits_to_keep + 1
+
+ model_inputs["use_cache"] = False # only used in generation; set False to suppress warnings
+
+ # MoE models: request router logits so the model returns `outputs.aux_loss`. VLM wrappers honor this only
+ # as a forward kwarg (not from the model config), so it must be passed here.
+ if compute_aux_loss:
+ model_inputs["output_router_logits"] = True
+
+ outputs = model(**model_inputs)
+ logits = outputs.logits
+ # Exclude the last value: it corresponds to the next token pred
+ logits = logits[:, :-1, :] # (B, L-1, H)
+ # Only keep the last logits_to_keep. For model that support logits_to_keep, this is a no-op.
+ logits = logits[:, -logits_to_keep:, :] # (B, logits_to_keep, H)
+ # Divide logits by sampling temperature.
+ # See https://huggingface.co/blog/the_n_implementation_details_of_rlhf_with_ppo#policy-training-implementation-details
+ logits.div_(self.temperature)
+ completion_ids = input_ids_batch[:, -logits_to_keep:]
+ logps = selective_log_softmax(logits, completion_ids) # compute logprobs
+ all_logps.append(logps)
+
+ if compute_entropy:
+ with torch.no_grad():
+ entropies = entropy_from_logits(logits)
+ all_entropies.append(entropies)
+
+ if compute_aux_loss:
+ all_aux_losses.append(outputs.aux_loss)
+
+ logps = torch.cat(all_logps, dim=0)
+ entropies = torch.cat(all_entropies, dim=0) if compute_entropy else None
+ aux_loss = torch.stack(all_aux_losses).mean() if compute_aux_loss else None
+ return logps, entropies, aux_loss
+
+ def training_step(self, model, inputs, num_items_in_batch):
+ time_before = time.perf_counter()
+ output = super().training_step(model, inputs, num_items_in_batch)
+ self._step += 1
+ time_after = time.perf_counter()
+ self._current_train_step_time += time_after - time_before
+ if self._step % self.current_gradient_accumulation_steps == 0:
+ self._metrics["train"]["step_time"].append(self._current_train_step_time)
+ self._current_train_step_time = 0.0
+ return output
+
+ @profiling_decorator
+ def _prepare_inputs(self, generation_batch: dict[str, torch.Tensor | Any]) -> dict[str, torch.Tensor | Any]:
+ # Prepares inputs for model training/evaluation by managing completion generation and batch handling.
+ # During training:
+ # - Receives the local generation batch (Per-GPU batch size × steps per generation)
+ # from the modified training dataloader instead of the standard local batch
+ # - Generates completions once for the entire generation batch and splits it into batches of size
+ # `per_device_train_batch_size`
+ # - Buffers these completions and returns the appropriate slice for the current accumulation step
+ # - Optimizes by regenerating completions only periodically (every steps_per_generation * num_iterations)
+ # During evaluation:
+ # - The input is treated as a standard local batch (no accumulation, no multiple iterations)
+ # - Completions are generated for each batch without buffering or reuse
+ # Returns a single local batch in both cases.
+
+ mode = "train" if self.model.training else "eval"
+ if mode == "train":
+ generate_every = self.args.steps_per_generation * self.num_iterations
+ if self._step % generate_every == 0 or self._buffered_inputs is None:
+ # self._buffered_inputs=None can occur when resuming from a checkpoint
+ generation_batch = self._generate_and_score_completions(generation_batch)
+ generation_batch = split_pixel_values_by_grid(generation_batch)
+ generation_batch = shuffle_sequence_dict(generation_batch)
+ generation_batches = split_tensor_dict(generation_batch, self.args.steps_per_generation)
+ self._buffered_inputs = [unsplit_pixel_values_by_grid(batch) for batch in generation_batches]
+ inputs = self._buffered_inputs[self._step % self.args.steps_per_generation]
+ else:
+ # In evaluation, there is neither batch grouping for generation, nor multiple iterations, hence
+ # local generation batch == local eval batch
+ inputs = self._generate_and_score_completions(generation_batch)
+ return inputs
+
+ def _log_completion_extra(self, column: str, values: list):
+ """
+ Log extra columns to the completions table. Called from reward functions via the `log_extra` kwarg.
+
+ Args:
+ column (`str`):
+ Name of the column to add.
+ values (`list`):
+ Values for the column, one per sample in the batch.
+ """
+ self._pending_extra_logs[column].extend(values)
+
+ def _log_metric(self, name: str, value: float):
+ """
+ Log a scalar metric from a reward function. Called via the `log_metric` kwarg. Values are averaged over each
+ logging step and reported alongside built-in metrics like `kl` and `entropy`.
+
+ Args:
+ name (`str`):
+ Name of the metric.
+ value (`float`):
+ Scalar value for this batch.
+ """
+ self._pending_metrics[name].append(value)
+
+ @profiling_decorator
+ def _calculate_rewards(self, inputs, prompts, completions, completion_ids_list):
+ device = self.accelerator.device
+ rewards_per_func = torch.zeros(len(prompts), len(self.reward_funcs), device=device)
+
+ # Repeat all input columns (but "prompt", "completion", and "completion_ids") to match the num of generations
+ keys = [key for key in inputs[0] if key not in ["prompt", "completion", "completion_ids"]]
+ reward_kwargs = {key: [example[key] for example in inputs] for key in keys}
+
+ # This allows for dynamic reward shaping based on training progress.
+ reward_kwargs["trainer_state"] = self.state
+
+ # Allow reward functions to log extra columns to the completions table.
+ reward_kwargs["log_extra"] = self._log_completion_extra
+
+ # Allow reward functions to log additional scalar metrics.
+ reward_kwargs["log_metric"] = self._log_metric
+
+ async_funcs_info = [] # async custom functions for asyncio.gather
+
+ for i, (reward_func, reward_processing_class, reward_func_name) in enumerate(
+ zip(self.reward_funcs, self.reward_processing_classes, self.reward_func_names, strict=True)
+ ):
+ if isinstance(reward_func, nn.Module): # Module (no PretrainedModel) for compat with compiled models
+ with profiling_context(self, reward_func_name):
+ if is_conversational(inputs[0]):
+ messages = [{"messages": p + c} for p, c in zip(prompts, completions, strict=True)]
+ texts = [
+ apply_chat_template(x, reward_processing_class, **self.chat_template_kwargs)["text"]
+ for x in messages
+ ]
+ else:
+ texts = [p + c for p, c in zip(prompts, completions, strict=True)]
+ reward_inputs = reward_processing_class(
+ text=texts, return_tensors="pt", padding=True, padding_side="right", add_special_tokens=False
+ )
+ reward_inputs = super()._prepare_inputs(reward_inputs)
+ with torch.inference_mode():
+ rewards_per_func[:, i] = reward_func(**reward_inputs).logits[:, 0] # Shape (B*G,)
+ elif inspect.iscoroutinefunction(reward_func): # Separate async reward funcs to run them in parallel later
+ async_funcs_info.append((i, reward_func, reward_func_name))
+ else:
+ # Run synchronous reward function
+ with profiling_context(self, reward_func_name):
+ output_reward_func = reward_func(
+ prompts=prompts, completions=completions, completion_ids=completion_ids_list, **reward_kwargs
+ )
+ # Convert None values to NaN
+ output_reward_func = [reward if reward is not None else torch.nan for reward in output_reward_func]
+ rewards_per_func[:, i] = torch.tensor(output_reward_func, dtype=torch.float32, device=device)
+
+ # Execute async custom functions in parallel using asyncio.gather
+ if async_funcs_info:
+
+ async def _invoke_async(index, func, func_name):
+ with profiling_context(self, func_name):
+ output = await func(
+ prompts=prompts, completions=completions, completion_ids=completion_ids_list, **reward_kwargs
+ )
+ output = [r if r is not None else torch.nan for r in output]
+ return index, output
+
+ async def _run_async_funcs():
+ coros = [_invoke_async(i, func, func_name) for (i, func, func_name) in async_funcs_info]
+ return await asyncio.gather(*coros)
+
+ async_results = asyncio.run_coroutine_threadsafe(_run_async_funcs(), self.async_loop).result()
+ for idx, output_reward_func in async_results:
+ rewards_per_func[:, idx] = torch.tensor(output_reward_func, dtype=torch.float32, device=device)
+
+ # If all reward functions return None for a given row, issue a detailed warning
+ if torch.isnan(rewards_per_func).all(dim=1).any():
+ nan_row_idx = torch.isnan(rewards_per_func).all(dim=1).nonzero(as_tuple=True)[0][0]
+ row_reward_kwargs = {
+ key: value[nan_row_idx]
+ for key, value in reward_kwargs.items()
+ if key not in ("trainer_state", "log_extra", "log_metric")
+ }
+ row_reward_kwargs["prompt"] = prompts[nan_row_idx]
+ row_reward_kwargs["completion"] = completions[nan_row_idx]
+ logger.warning(
+ f"All reward functions returned None for the following kwargs:\n{row_reward_kwargs}\n"
+ "Please ensure that at least one reward function returns a valid reward."
+ )
+
+ # Gather the reward per function: this part is crucial, because the rewards are normalized per group and the
+ # completions may be distributed across processes
+ rewards_per_func = gather(rewards_per_func)
+ return rewards_per_func
+
+ def _tokenize_prompts(self, prompts: list):
+ """Tokenize prompts and extract images/multimodal fields for generation."""
+ if is_conversational({"prompt": prompts[0]}):
+ # Extract images from messages for VLM support
+ images = []
+ has_images = False
+ for prompt in prompts:
+ prompt_images = []
+ for message in prompt:
+ if isinstance(message["content"], list):
+ for part in message["content"]:
+ if part["type"] == "image":
+ prompt_images.append(part["image"])
+ has_images = True
+ images.append(prompt_images if prompt_images else None)
+ images = images if has_images else None
+
+ # Workaround for a bug in transformers 5.3.0 where some processors (e.g. Qwen2.5-VL) crash on
+ # batched unpadded input (transformers#44514).
+ # Fixed in transformers 5.4.0 (transformers#44563).
+ needs_padding_workaround = Version("5.3.0") <= Version(transformers.__version__) < Version("5.4.0")
+ tokenized = self.processing_class.apply_chat_template(
+ conversation=prompts,
+ add_generation_prompt=True,
+ tokenize=True,
+ return_dict=True,
+ **({"padding": True} if needs_padding_workaround else {}),
+ **self.chat_template_kwargs,
+ )
+ if needs_padding_workaround:
+ # Unpad input_ids: remove padding tokens using attention_mask to get per-sequence lists
+ prompt_ids = [
+ [tok for tok, m in zip(ids, mask, strict=True) if m]
+ for ids, mask in zip(tokenized["input_ids"], tokenized["attention_mask"], strict=True)
+ ]
+ else:
+ prompt_ids = tokenized["input_ids"]
+ # For VLMs, the processor returns extra multimodal fields (pixel_values, image_grid_thw, etc.)
+ multimodal_fields = {k: v for k, v in tokenized.items() if k not in ("input_ids", "attention_mask")}
+ else:
+ prompt_ids = self.processing_class(text=prompts)["input_ids"]
+ images = None
+ multimodal_fields = {}
+ return prompt_ids, images, multimodal_fields
+
+ def _generate_single_turn(self, prompt_ids, images, multimodal_fields):
+ device = self.accelerator.device
+ mode = "train" if self.model.training else "eval"
+
+ # Generate completions using either vLLM or regular generation
+ if self.use_vllm:
+ # Sync weights if training step changed
+ if self.state.global_step != self._last_loaded_step:
+ with profiling_context(self, "sync_weights"):
+ self.vllm_generation.sync_weights()
+ self._last_loaded_step = self.state.global_step
+
+ # Generate using vLLM (note: RLOO doesn't use logprobs from generation, so we ignore them)
+ num_generations = self.num_generations if mode == "train" else self.num_generations_eval
+ _, completion_ids, _, _ = self.vllm_generation.generate(
+ prompts=prompt_ids,
+ images=images,
+ num_generations=num_generations,
+ profiler=profiling_context(self, "vLLM.generate"),
+ )
+
+ elif self.use_transformers_continuous_batching:
+ with (
+ profiling_context(self, "transformers.generate_batch"),
+ unwrap_model_for_generation(
+ self.model_wrapped, self.accelerator, gather_deepspeed3_params=self.args.ds3_gather_for_generation
+ ) as unwrapped_model,
+ torch.no_grad(),
+ self._dist.summon_full_params(self.model_wrapped, recurse=False),
+ ):
+ # Cast to the appropriate dtype based on training configuration
+ if self.args.bf16:
+ unwrapped_model.to(torch.bfloat16)
+ elif self.args.fp16:
+ unwrapped_model.to(torch.float16)
+ all_outputs = unwrapped_model.generate_batch(
+ prompt_ids,
+ generation_config=self.generation_config,
+ continuous_batching_config=self.continuous_batching_config,
+ progress_bar=False,
+ )
+ unwrapped_model.train()
+ completion_ids = [output.generated_tokens for output in all_outputs.values()]
+
+ else:
+ # Regular generation path: left-pad token IDs into tensors
+ prompt_tensors = [torch.tensor(ids) for ids in prompt_ids]
+ padded_ids = pad(prompt_tensors, padding_value=self._tokenizer.pad_token_id, padding_side="left")
+ attention_mask = pad([torch.ones_like(t) for t in prompt_tensors], padding_value=0, padding_side="left")
+ generate_inputs = {"input_ids": padded_ids, "attention_mask": attention_mask}
+ # For VLMs, include multimodal fields as tensors (pixel_values, image_grid_thw, etc.)
+ for k, v in multimodal_fields.items():
+ if isinstance(v, torch.Tensor):
+ generate_inputs[k] = v
+ elif isinstance(v, list) and v and isinstance(v[0], list):
+ # Per-token field (e.g., token_type_ids): left-pad like input_ids
+ generate_inputs[k] = pad([torch.tensor(x) for x in v], padding_value=0, padding_side="left")
+ else:
+ generate_inputs[k] = torch.tensor(np.array(v))
+ generate_inputs = super()._prepare_inputs(generate_inputs)
+
+ with (
+ profiling_context(self, "transformers.generate"),
+ unwrap_model_for_generation(
+ self.model_wrapped,
+ self.accelerator,
+ gather_deepspeed3_params=self.args.ds3_gather_for_generation,
+ generation_kwargs=self.generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762
+ ) as unwrapped_model,
+ torch.no_grad(),
+ self._dist.summon_full_params(self.model_wrapped, recurse=False),
+ ):
+ prompt_completion_ids = unwrapped_model.generate(
+ **generate_inputs, generation_config=self.generation_config
+ )
+ # Compute prompt length and extract completion ids
+ prompt_length = generate_inputs["input_ids"].size(1)
+ completion_ids = prompt_completion_ids[:, prompt_length:]
+
+ # Mask everything after the first EOS token
+ is_eos = completion_ids == self._tokenizer.eos_token_id
+ eos_idx = torch.full((is_eos.size(0),), is_eos.size(1), dtype=torch.long, device=device)
+ eos_idx[is_eos.any(dim=1)] = is_eos.int().argmax(dim=1)[is_eos.any(dim=1)]
+ sequence_indices = torch.arange(is_eos.size(1), device=device).expand(is_eos.size(0), -1)
+ completion_mask = (sequence_indices <= eos_idx.unsqueeze(1)).int()
+ completion_ids = [
+ c[m].tolist() for c, m in zip(completion_ids.cpu(), completion_mask.bool().cpu(), strict=True)
+ ]
+
+ return completion_ids
+
+ def _generate(self, prompts: list):
+ device = self.accelerator.device
+ mode = "train" if self.model.training else "eval"
+
+ # Copy the prompts to avoid modifying the original list
+ prompts = copy.deepcopy(prompts)
+
+ prompt_ids, images, multimodal_fields = self._tokenize_prompts(prompts)
+ completion_ids = self._generate_single_turn(prompt_ids, images, multimodal_fields)
+
+ # Decode completions. It's important to use `parse_response` when possible, because it handles tool calls.
+ if is_conversational({"prompt": prompts[0]}):
+ contents = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True)
+ completions = [[{"role": "assistant", "content": content}] for content in contents]
+ else:
+ completions = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True)
+
+ # Get completion length per sequence, used for logging
+ prompt_lengths = torch.tensor([len(ids) for ids in prompt_ids], device=device)
+ completion_lengths = torch.tensor([len(ids) for ids in completion_ids], device=device)
+ agg_prompt_lengths = self.accelerator.gather(prompt_lengths)
+ agg_completion_lengths = self.accelerator.gather(completion_lengths)
+ total_prompt_tokens = agg_prompt_lengths.sum()
+ total_completion_tokens = agg_completion_lengths.sum() # = num_items_in_batch, required for the DAPO loss
+
+ # Log the metrics
+ if mode == "train":
+ self.state.num_input_tokens_seen += (total_prompt_tokens + total_completion_tokens).item()
+ self._metrics[mode]["num_tokens"] = [self.state.num_input_tokens_seen]
+
+ # Log completion lengths, mean, min, max
+ self._metrics[mode]["completions/mean_length"].append(agg_completion_lengths.float().mean().item())
+ self._metrics[mode]["completions/min_length"].append(agg_completion_lengths.float().min().item())
+ self._metrics[mode]["completions/max_length"].append(agg_completion_lengths.float().max().item())
+
+ # Identify sequences that terminated with EOS and log their lengths
+ eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id]
+ is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids], device=device)
+ agg_is_truncated = self.accelerator.gather(is_truncated)
+ self._metrics[mode]["completions/clipped_ratio"].append(agg_is_truncated.float().mean().item())
+ term_completion_lengths = agg_completion_lengths[~agg_is_truncated]
+ if len(term_completion_lengths) == 0: # edge case where no terminated sequences are found
+ term_completion_lengths = torch.zeros(1, device=device)
+ self._metrics[mode]["completions/mean_terminated_length"].append(term_completion_lengths.float().mean().item())
+ self._metrics[mode]["completions/min_terminated_length"].append(term_completion_lengths.float().min().item())
+ self._metrics[mode]["completions/max_terminated_length"].append(term_completion_lengths.float().max().item())
+
+ return prompt_ids, completion_ids, completions
+
+ def _generate_and_score_completions(
+ self, inputs: list[dict[str, torch.Tensor | Any]]
+ ) -> dict[str, torch.Tensor | Any]:
+ device = self.accelerator.device
+ mode = "train" if self.model.training else "eval"
+
+ prompts = [x["prompt"] for x in inputs]
+
+ if "images" in inputs[0]:
+ images = [example.get("images") for example in inputs]
+ elif "image" in inputs[0]:
+ images = [[example.get("image")] if example.get("image") is not None else None for example in inputs]
+ else:
+ images = None
+ # Transformers requires at least one image in the batch, otherwise it throws an error
+ if images is not None and all(img_list == [] for img_list in images):
+ images = None
+
+ # If the prompts are conversational and the inputs contain images, we need to convert the prompts from
+ # [{"role": "user", "content": "What color is the sky?"}] to
+ # [{"role": "user", "content": [{"type": "image", "image": }, {"type": "text", "text": "What color is the sky?"}]}]
+ if images is not None:
+ if not is_conversational(inputs[0]):
+ raise ValueError(
+ "Multimodal training requires conversational prompts. It looks like the dataset contains "
+ "non-conversational inputs, likely because a chat template was applied before passing the dataset "
+ "to the trainer. Please provide the raw conversational prompts and let the trainer apply the chat "
+ "template internally."
+ )
+ prompts = [
+ prepare_multimodal_messages(prompt, images=image_list)
+ for prompt, image_list in zip(prompts, images, strict=True)
+ ]
+
+ prompt_ids_list, completion_ids_list, completions = self._generate(prompts)
+
+ # Convert lists of token IDs to padded tensors
+ prompt_ids = [torch.tensor(ids) for ids in prompt_ids_list]
+ prompt_mask = [torch.ones_like(ids, dtype=torch.long) for ids in prompt_ids]
+ prompt_ids = pad(
+ prompt_ids,
+ padding_value=self._tokenizer.pad_token_id,
+ padding_side="left",
+ pad_to_multiple_of=self.pad_to_multiple_of,
+ ).to(device=device)
+ prompt_mask = pad(
+ prompt_mask, padding_value=0, padding_side="left", pad_to_multiple_of=self.pad_to_multiple_of
+ ).to(device=device)
+ completion_ids = [torch.tensor(ids) for ids in completion_ids_list]
+ completion_mask = [torch.ones_like(ids, dtype=torch.long) for ids in completion_ids]
+ completion_ids = pad(
+ completion_ids,
+ padding_value=self._tokenizer.pad_token_id,
+ padding_side="right",
+ pad_to_multiple_of=self.pad_to_multiple_of,
+ ).to(device=device)
+ completion_mask = pad(
+ completion_mask, padding_value=0, padding_side="right", pad_to_multiple_of=self.pad_to_multiple_of
+ ).to(device=device)
+
+ # If mask_truncated_completions is enabled, zero out truncated completions in completion_mask
+ if self.mask_truncated_completions:
+ eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id]
+ # Mask completion_mask for attention masking
+ is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids_list], device=device)
+ completion_mask = completion_mask * (~is_truncated).unsqueeze(1).int()
+
+ # Concatenate prompt_mask with completion_mask for logit computation
+ prompt_completion_ids = torch.cat([prompt_ids, completion_ids], dim=1) # (B, P+C)
+ attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) # (B, P+C)
+
+ logits_to_keep = completion_ids.size(1) # we only need to compute the logits for the completion tokens
+ batch_size = self.args.per_device_train_batch_size if mode == "train" else self.args.per_device_eval_batch_size
+
+ num_images = [len(img_list) if img_list else 0 for img_list in images] if images is not None else None
+
+ # Get forward_kwargs for models with multimodal inputs
+ if images is not None:
+ prompts_text = [
+ apply_chat_template({"prompt": prompt}, self.processing_class, **self.chat_template_kwargs)["prompt"]
+ for prompt in prompts
+ ]
+ prompt_inputs = self.processing_class(images=images, text=prompts_text, padding=True, return_tensors="pt")
+ prompt_inputs = super()._prepare_inputs(prompt_inputs)
+ forward_kwargs = {k: v for k, v in prompt_inputs.items() if k not in ["input_ids", "attention_mask"]}
+ else:
+ forward_kwargs = {}
+
+ # If token_type_ids are used, extend them with zeros for the completion part
+ if "token_type_ids" in forward_kwargs:
+ token_type_ids = forward_kwargs["token_type_ids"]
+ if self.pad_to_multiple_of is not None:
+ # Needed only with pad_to_multiple_of: otherwise prompt_ids and token_type_ids must have equal len
+ padding_size = prompt_ids.size(1) - token_type_ids.size(1)
+ if padding_size > 0:
+ token_type_ids = torch.cat(
+ [token_type_ids.new_zeros((token_type_ids.size(0), padding_size)), token_type_ids], dim=1
+ )
+ forward_kwargs["token_type_ids"] = torch.cat(
+ [token_type_ids, token_type_ids.new_zeros(completion_ids.shape)], dim=1
+ )
+ # If mm_token_type_ids are used, extend them with zeros for the completion part
+ if "mm_token_type_ids" in forward_kwargs:
+ mm_token_type_ids = forward_kwargs["mm_token_type_ids"]
+ if self.pad_to_multiple_of is not None:
+ # Needed only with pad_to_multiple_of: otherwise prompt_ids and mm_token_type_ids must have equal len
+ padding_size = prompt_ids.size(1) - mm_token_type_ids.size(1)
+ if padding_size > 0:
+ mm_token_type_ids = torch.cat(
+ [mm_token_type_ids.new_zeros((mm_token_type_ids.size(0), padding_size)), mm_token_type_ids],
+ dim=1,
+ )
+ forward_kwargs["mm_token_type_ids"] = torch.cat(
+ [mm_token_type_ids, mm_token_type_ids.new_zeros(completion_ids.shape)], dim=1
+ )
+
+ # When gradient checkpointing is enabled with use_reentrant=True (non default), calling the model inside a
+ # torch.no_grad() block triggers a harmless PyTorch warning ("None of the inputs have requires_grad=True").
+ # Temporarily disable checkpointing to avoid this warning during inference.
+ with torch.no_grad(), disable_gradient_checkpointing(self.model, self.args.gradient_checkpointing_kwargs):
+ # Compute the per-token log probabilities for the current model
+ old_per_token_logps, _, _ = self._get_per_token_logps_and_entropies(
+ self.model,
+ prompt_completion_ids,
+ attention_mask,
+ logits_to_keep,
+ batch_size,
+ num_images=num_images,
+ **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask, image_sizes, image_position_ids
+ )
+ old_logps = (old_per_token_logps * completion_mask).sum(1) # mask out padding and tokens after EOS
+
+ # Compute the per-token log probabilities for the reference model
+ if self.beta != 0.0:
+ if self.ref_model is not None:
+ ref_per_token_logps, _, _ = self._get_per_token_logps_and_entropies(
+ self.ref_model,
+ prompt_completion_ids,
+ attention_mask,
+ logits_to_keep,
+ batch_size=batch_size,
+ num_images=num_images,
+ **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask, image_sizes, image_position_ids
+ )
+ else:
+ # When training a PEFT adapter, how we obtain the reference depends on the setup:
+ # - New adapter: disabling adapters yields the base model.
+ # - Re-training an existing adapter: an initial copy is loaded under the name "ref".
+ model = self.accelerator.unwrap_model(self.model)
+ with use_adapter(model, adapter_name="ref" if "ref" in model.peft_config else None):
+ ref_per_token_logps, _, _ = self._get_per_token_logps_and_entropies(
+ self.model,
+ prompt_completion_ids,
+ attention_mask,
+ logits_to_keep,
+ batch_size=batch_size,
+ num_images=num_images,
+ **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask, image_sizes, image_position_ids
+ )
+ else:
+ ref_per_token_logps = None
+
+ # Decode
+ prompts_text = self.processing_class.batch_decode(prompt_ids, skip_special_tokens=True)
+ completions_text = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True)
+
+ # Calculate rewards for each reward function. rewards_per_func aggregates rewards across all processes. This is
+ # important because rewards will be normalized per group, and completions are distributed. We will later slice
+ # rewards_per_func to extract each process's subset.
+ rewards_per_func = self._calculate_rewards(inputs, prompts, completions, completion_ids_list)
+ num_generations = self.num_generations if mode == "train" else self.num_generations_eval
+
+ # A completion for which every reward function returned None is unscorable. nansum would collapse it to 0,
+ # which both biases the leave-one-out baseline and hands the completion a spurious advantage. Mark these rows
+ # NaN so they're excluded from the (nan-aware) baseline below; their advantage is forced to 0 afterwards.
+ unscorable_mask = torch.isnan(rewards_per_func).all(dim=1)
+
+ # Apply weights to each reward function's output and sum
+ rewards = (rewards_per_func * self.reward_weights.to(device).unsqueeze(0)).nansum(dim=1)
+ rewards[unscorable_mask] = torch.nan
+
+ # Apply reward clipping if specified
+ if self.reward_clip_range:
+ rewards = rewards.clamp(min=self.reward_clip_range[0], max=self.reward_clip_range[1])
+
+ # Include the KL penalty in the reward
+ if self.beta != 0.0:
+ # RLOO uses the first-order log ratio for the per-token KL estimate, following the original RLOO paper
+ # (Ahmadian et al., 2024, https://huggingface.co/papers/2405.14782). Unlike GRPOTrainer's Schulman
+ # approximation (always >= 0), this can be negative per token. The divergence is intentional: RLOO applies
+ # KL as a reward penalty (summed across tokens per sequence), while GRPO adds it to the per-token loss.
+ per_token_kl = old_per_token_logps - ref_per_token_logps
+ # Apply sequence-level KL penalty to rewards (sum KL across tokens first, then apply to each sequence)
+ kl = (per_token_kl * completion_mask).sum(-1)
+ kl = gather(kl) # rewards are gathered, so kl must be too
+ rewards = rewards - self.beta * kl
+
+ grouped_rewards = rewards.view(-1, num_generations)
+ mean_grouped_rewards = torch.nanmean(grouped_rewards, dim=1)
+ if num_generations > 1:
+ std_rewards = nanstd(grouped_rewards, dim=1)
+ else: # doesn't occur during training, but could occur in eval when num_generations_eval=1
+ std_rewards = torch.zeros_like(mean_grouped_rewards)
+
+ # RLOO advantages computation. The leave-one-out baseline averages over scorable siblings only: nansum drops
+ # unscorable rewards and the divisor is (scorable count − 1). A group with a single scorable completion yields
+ # 0/0 = NaN, and unscorable rows stay NaN; both are zeroed by nan_to_num below.
+ scorable_counts = (~torch.isnan(grouped_rewards)).sum(dim=1, keepdim=True) # (num_prompts, 1)
+ grouped_sum = torch.nansum(grouped_rewards, dim=1, keepdim=True) # (num_prompts, 1)
+ if num_generations > 1:
+ baselines = (grouped_sum - grouped_rewards) / (scorable_counts - 1) # (num_prompts, num_generations)
+ baselines = baselines.view(-1) # Flatten back to match rewards shape
+ advantages = rewards - baselines
+ else: # this case doesn't occur during training, but could in eval when num_generations_eval=1
+ advantages = torch.zeros_like(rewards)
+
+ # Normalize advantages over the scorable subset only (unscorable advantages are still NaN here).
+ if self.normalize_advantages:
+ advantages = (advantages - torch.nanmean(advantages)) / (nanstd(advantages) + 1e-4)
+
+ # Unscorable completions carry no learning signal: zero their advantage to keep them from moving the policy.
+ advantages = torch.nan_to_num(advantages, nan=0.0)
+
+ is_std_zero = torch.isclose(std_rewards, torch.zeros_like(std_rewards)) # for logging
+
+ # Slice to keep only the local part of the data
+ process_slice = slice(
+ self.accelerator.process_index * len(prompts),
+ (self.accelerator.process_index + 1) * len(prompts),
+ )
+ all_process_advantages = advantages.clone() # keep the aggregated advantages for logging
+ advantages = advantages[process_slice]
+
+ # Calculate and log the mean KL divergence between current and reference model
+ if self.beta != 0.0:
+ mean_kl = (per_token_kl * completion_mask).sum() / completion_mask.sum().clamp(min=1.0)
+ self._metrics[mode]["kl"].append(self.accelerator.gather(mean_kl).nanmean().item())
+
+ # Calculate mean reward per function, but only for samples where the function was applied (non-NaN values)
+ for i, reward_func_name in enumerate(self.reward_func_names):
+ mean_rewards = torch.nanmean(rewards_per_func[:, i]).item()
+ self._metrics[mode][f"rewards/{reward_func_name}/mean"].append(mean_rewards)
+ std_func_rewards = nanstd(rewards_per_func[:, i]).item()
+ self._metrics[mode][f"rewards/{reward_func_name}/std"].append(std_func_rewards)
+ rewards = (rewards_per_func * self.reward_weights.to(rewards_per_func.device).unsqueeze(0)).nansum(dim=1)
+ rewards[unscorable_mask] = torch.nan # exclude unscorable rows from the logged reward stats
+ self._metrics[mode]["reward"].append(torch.nanmean(rewards).item())
+ self._metrics[mode]["reward_std"].append(nanstd(rewards).item())
+ self._metrics[mode]["frac_reward_zero_std"].append(is_std_zero.float().mean().item())
+
+ # Log prompt and completion texts
+ self._logs["prompt"].extend(gather_object(prompts_text))
+ self._logs["completion"].extend(gather_object(completions_text))
+ for i, name in enumerate(self.reward_func_names):
+ self._logs["rewards"][name].extend(rewards_per_func[:, i].tolist())
+ self._logs["advantages"].extend(all_process_advantages.tolist())
+
+ # Flush user-logged extra columns (from log_extra), gathering across processes.
+ # Keys must be sorted so that all ranks call gather_object in the same order, otherwise values
+ # get mis-attributed across columns (dict insertion order may differ between processes).
+ for column in sorted(self._pending_extra_logs):
+ self._logs["extra"][column].extend(gather_object(self._pending_extra_logs[column]))
+ self._pending_extra_logs.clear()
+
+ # Flush user-logged metrics (from log_metric), averaging across processes.
+ # Keys must be sorted so that all ranks call accelerator.gather in the same order, otherwise values
+ # get mis-attributed across metrics (dict insertion order may differ between processes).
+ for name in sorted(self._pending_metrics):
+ values = self._pending_metrics[name]
+ local_mean = sum(values) / len(values)
+ global_mean = self.accelerator.gather(torch.tensor(local_mean, device=device)).mean().item()
+ self._metrics[mode][name].append(global_mean)
+ self._pending_metrics.clear()
+
+ if images is not None:
+ self._logs["images"].extend(gather_object(images))
+
+ output = {
+ "prompt_ids": prompt_ids,
+ "prompt_mask": prompt_mask,
+ "completion_ids": completion_ids,
+ "completion_mask": completion_mask,
+ "old_logps": old_logps,
+ "advantages": advantages,
+ }
+ if "pixel_values" in forward_kwargs:
+ output["pixel_values"] = forward_kwargs["pixel_values"]
+ if "image_grid_thw" in forward_kwargs:
+ output["image_grid_thw"] = forward_kwargs["image_grid_thw"]
+ if "pixel_attention_mask" in forward_kwargs:
+ output["pixel_attention_mask"] = forward_kwargs["pixel_attention_mask"]
+ if "image_sizes" in forward_kwargs:
+ output["image_sizes"] = forward_kwargs["image_sizes"]
+ if "token_type_ids" in forward_kwargs:
+ output["token_type_ids"] = forward_kwargs["token_type_ids"]
+ if "mm_token_type_ids" in forward_kwargs:
+ output["mm_token_type_ids"] = forward_kwargs["mm_token_type_ids"]
+ if "image_position_ids" in forward_kwargs:
+ output["image_position_ids"] = forward_kwargs["image_position_ids"]
+ if images is not None:
+ output["num_images"] = num_images
+ return output
+
+ @profiling_decorator
+ def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
+ if return_outputs:
+ raise ValueError("The RLOOTrainer does not support returning outputs")
+ return self._compute_loss(model, inputs)
+
+ def _compute_loss(self, model, inputs):
+ # Compute the per-token log probabilities for the model
+ prompt_ids, prompt_mask = inputs["prompt_ids"], inputs["prompt_mask"]
+ completion_ids, completion_mask = inputs["completion_ids"], inputs["completion_mask"]
+ input_ids = torch.cat([prompt_ids, completion_ids], dim=1)
+ attention_mask = torch.cat([prompt_mask, completion_mask], dim=1)
+ logits_to_keep = completion_ids.size(1) # we only need to compute the logits for the completion tokens
+
+ # Compute the per_token_logps and the entropy at each position in the completion
+ per_token_logps, entropies, aux_loss = self._get_per_token_logps_and_entropies(
+ model,
+ input_ids,
+ attention_mask,
+ logits_to_keep,
+ compute_entropy=True,
+ compute_aux_loss=self.aux_loss_enabled,
+ pixel_values=inputs.get("pixel_values"),
+ image_grid_thw=inputs.get("image_grid_thw"),
+ num_images=inputs.get("num_images"),
+ pixel_attention_mask=inputs.get("pixel_attention_mask"),
+ image_sizes=inputs.get("image_sizes"),
+ token_type_ids=inputs.get("token_type_ids"),
+ mm_token_type_ids=inputs.get("mm_token_type_ids"),
+ image_position_ids=inputs.get("image_position_ids"),
+ )
+
+ logps = (per_token_logps * completion_mask).sum(1) # mask out padding and tokens after EOS
+ old_logps = inputs["old_logps"]
+ log_ratio = logps - old_logps
+
+ # Compute the loss
+ advantages = inputs["advantages"]
+ coef_1 = torch.exp(log_ratio)
+ coef_2 = torch.clamp(coef_1, 1 - self.epsilon_low, 1 + self.epsilon_high)
+ per_sequence_loss1 = coef_1 * advantages
+ per_sequence_loss2 = coef_2 * advantages
+ per_sequence_loss = -torch.min(per_sequence_loss1, per_sequence_loss2)
+ loss = per_sequence_loss.mean()
+
+ # Log the metrics
+ mode = "train" if self.model.training else "eval"
+
+ # RLOO returns an unscaled loss (the HF Trainer divides by gradient accumulation), so add the aux term unscaled
+ if self.aux_loss_enabled:
+ loss = loss + self.router_aux_loss_coef * aux_loss
+ self._metrics[mode]["aux_loss"].append(self.accelerator.gather_for_metrics(aux_loss).mean().item())
+
+ # Entropy
+ mean_entropy = (entropies * completion_mask).sum() / completion_mask.sum().clamp(min=1.0)
+ self._metrics[mode]["entropy"].append(self.accelerator.gather(mean_entropy).nanmean().item())
+
+ # Compute the clipped probability ratios
+ is_low_clipped = (coef_1 < 1 - self.epsilon_low) & (advantages < 0)
+ is_high_clipped = (coef_1 > 1 + self.epsilon_high) & (advantages > 0)
+ is_region_clipped = is_low_clipped | is_high_clipped
+ gathered_low_clip = self.accelerator.gather(is_low_clipped.float().mean())
+ self._metrics[mode]["clip_ratio/low_mean"].append(gathered_low_clip.nanmean().item())
+ self._metrics[mode]["clip_ratio/low_min"].append(nanmin(gathered_low_clip).item())
+ gathered_high_clip = self.accelerator.gather(is_high_clipped.float().mean())
+ self._metrics[mode]["clip_ratio/high_mean"].append(gathered_high_clip.nanmean().item())
+ self._metrics[mode]["clip_ratio/high_max"].append(nanmax(gathered_high_clip).item())
+ gathered_clip_ratio = self.accelerator.gather(is_region_clipped.float().mean())
+ self._metrics[mode]["clip_ratio/region_mean"].append(gathered_clip_ratio.nanmean().item())
+ return loss
+
+ # During eval, Trainer calls prediction_step. If no labels are present in the inputs, it only runs forward and
+ # returns logits. We override prediction_step to force compute_loss, because this trainer doesn't involve labels.
+ def prediction_step(self, model, inputs, prediction_loss_only, ignore_keys: list[str] | None = None):
+ inputs = self._prepare_inputs(inputs)
+ with torch.no_grad():
+ with self.compute_loss_context_manager():
+ loss = self.compute_loss(model, inputs)
+ loss = loss.mean().detach()
+ return loss, None, None
+
+ def log(self, logs: dict[str, float], start_time: float | None = None) -> None:
+ mode = "train" if self.model.training else "eval"
+ # Average the metrics
+ metrics = {}
+ for key, val in self._metrics[mode].items():
+ # Filter out NaN values before averaging. A reward function that returns None for all samples
+ # in a batch produces NaN for that batch's metric. With logging_steps > 1, a naive sum()/len()
+ # would let a single NaN contaminate valid data from other batches. Only return None when no
+ # valid values remain (e.g. JSON loggers crash on float NaN).
+ valid = [v for v in val if not math.isnan(v)]
+ metrics[key] = sum(valid) / len(valid) if valid else None
+
+ # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs`
+ # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format.
+ if mode == "eval":
+ metrics = {f"eval_{key}": val for key, val in metrics.items()}
+
+ logs.update(metrics)
+ super().log(logs, start_time)
+ self._metrics[mode].clear()
+
+ if self.accelerator.is_main_process and self.log_completions:
+ if is_rich_available():
+ print_prompt_completions_sample(
+ self._logs["prompt"],
+ self._logs["completion"],
+ self._logs["rewards"],
+ self._logs["advantages"],
+ self.state.global_step,
+ self.num_completions_to_print,
+ extra=dict(self._logs["extra"]),
+ )
+
+ logging_backends = []
+ if self.args.report_to and "wandb" in self.args.report_to and wandb.run is not None:
+ logging_backends.append(wandb)
+ if self.args.report_to and "trackio" in self.args.report_to:
+ logging_backends.append(trackio)
+
+ table = {
+ "step": [self.state.global_step] * len(self._logs["prompt"]),
+ "prompt": self._logs["prompt"],
+ "completion": self._logs["completion"],
+ **self._logs["rewards"],
+ **self._logs["extra"],
+ "advantage": self._logs["advantages"],
+ }
+
+ df_base = pd.DataFrame(table)
+ images_raw = self._logs["images"] or []
+
+ for logging_backend in logging_backends:
+ if images_raw:
+ images = []
+ for image_list in self._logs["images"]:
+ images.append([logging_backend.Image(image) for image in image_list])
+ df = pd.concat(
+ [df_base, pd.Series(images, name="image")],
+ axis=1,
+ copy=False,
+ )
+ else:
+ df = df_base
+
+ if self.log_unique_prompts:
+ df = df.drop_duplicates(subset=["prompt"])
+
+ logging_backend.log({"completions": logging_backend.Table(dataframe=df)})
+
+ # Ensure the model card is saved along with the checkpoint
+ def _save_checkpoint(self, model, trial):
+ if self.args.hub_model_id is None:
+ model_name = Path(self.args.output_dir).name
+ else:
+ model_name = self.args.hub_model_id.split("/")[-1]
+ self.create_model_card(model_name=model_name)
+ super()._save_checkpoint(model, trial)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/sft_config.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/sft_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..de1b554bbbe88d8c1693519f517224c223760b59
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/sft_config.py
@@ -0,0 +1,336 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import warnings
+from dataclasses import dataclass, field
+from typing import Any
+
+from .base_config import _BaseConfig
+
+
+@dataclass
+class SFTConfig(_BaseConfig):
+ # docstyle-ignore
+ r"""
+ Configuration class for the [`SFTTrainer`].
+
+ This class includes only the parameters that are specific to SFT training. For a full list of training arguments,
+ please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may
+ differ from those in [`~transformers.TrainingArguments`].
+
+ Using [`~transformers.HfArgumentParser`] we can turn this class into
+ [argparse](https://docs.python.org/3/library/argparse#module-argparse) arguments that can be specified on the
+ command line.
+
+ Parameters:
+ > Parameters that control the model
+
+ model_init_kwargs (`dict[str, Any]`, *optional*):
+ Keyword arguments for [`~transformers.AutoModelForCausalLM.from_pretrained`], used when the `model`
+ argument of the [`SFTTrainer`] is provided as a string.
+ trust_remote_code (`bool`, *optional*, defaults to `False`):
+ Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to
+ [`~transformers.AutoModelForCausalLM.from_pretrained`] and
+ [`~transformers.AutoProcessor.from_pretrained`].
+ router_aux_loss_coef (`float`, *optional*, defaults to `0.001`):
+ Coefficient of the load-balancing auxiliary loss. Only has an effect when training a Mixture-of-Experts
+ (MoE) model; for other models it does nothing. The auxiliary loss is added to the training loss with this
+ weight. Set to `0.0` to disable it.
+ chat_template_path (`str`, *optional*):
+ If specified, sets the model's chat template. This can either be the path to a tokenizer (local directory
+ or Hugging Face Hub model) or a direct path to a Jinja template file. When using a Jinja file, you must
+ ensure that any special tokens referenced in the template are added to the tokenizer and that the model's
+ embedding layer is resized accordingly.
+
+ > Parameters that control the data preprocessing
+
+ dataset_text_field (`str`, *optional*, defaults to `"text"`):
+ Name of the column that contains text data in the dataset.
+ dataset_kwargs (`dict[str, Any]`, *optional*):
+ Dictionary of optional keyword arguments for the dataset preparation. The only supported key is
+ `skip_prepare_dataset`. When the model is a VLM, `skip_prepare_dataset` is automatically treated as `True`
+ regardless of the provided value, since preprocessing is done on the fly.
+ dataset_num_proc (`int`, *optional*):
+ Number of processes to use for processing the dataset.
+ eos_token (`str`, *optional*):
+ Token used to indicate the end of a turn or sequence. If `None`, it defaults to
+ `processing_class.eos_token`.
+ max_length (`int` or `None`, *optional*, defaults to `1024`):
+ Maximum length of the tokenized sequence. Sequences longer than `max_length` are truncated from the left
+ or right depending on `truncation_mode`. If `None`, no truncation is applied. When packing is enabled,
+ this value sets the sequence length.
+ truncation_mode (`str`, *optional*, defaults to `"keep_start"`):
+ Truncation mode to use when the sequence exceeds `max_length`. The only supported value is
+ `"keep_start"`. The `"keep_end"` value is deprecated and will be removed in v2.0.0.
+ shuffle_dataset (`bool`, *optional*, defaults to `False`):
+ Whether to shuffle the dataset.
+ packing (`bool`, *optional*, defaults to `False`):
+ Whether to group multiple sequences into fixed-length blocks to improve computational efficiency and reduce
+ padding. Uses `max_length` to define sequence length.
+ packing_strategy (`str`, *optional*, defaults to `"bfd"`):
+ Strategy for packing sequences. Can be `"bfd"` (best-fit decreasing, truncates overflow), `"bfd_split"`
+ (best-fit decreasing, splits overflow sequences), or `"wrapped"` (aggressive, cuts mid-sequence).
+ padding_free (`bool`, *optional*, defaults to `False`):
+ Whether to perform forward passes without padding by flattening all sequences in the batch into a single
+ continuous sequence. This reduces memory usage by eliminating padding overhead. Currently, this is only
+ supported with the FlashAttention 2 or 3, which can efficiently handle the flattened batch structure. When
+ packing is enabled with strategy `"bfd"`, padding-free is enabled, regardless of the value of this
+ parameter.
+ pad_to_multiple_of (`int`, *optional*):
+ If set, the sequences will be padded to a multiple of this value.
+ eval_packing (`bool`, *optional*):
+ Whether to pack the eval dataset. If `None`, uses the same value as `packing`.
+
+ > Parameters that control the training
+
+ completion_only_loss (`bool`, *optional*):
+ Whether to compute loss only on the completion part of the sequence. If set to `True`, loss is computed
+ only on the completion, which is supported only for [prompt-completion](#prompt-completion) datasets. If
+ `False`, loss is computed on the entire sequence. If `None` (default), the behavior depends on the dataset:
+ loss is computed on the completion for [prompt-completion](#prompt-completion) datasets, and on the full
+ sequence for [language modeling](#language-modeling) datasets.
+ assistant_only_loss (`bool`, *optional*, defaults to `False`):
+ Whether to compute loss only on the assistant part of the sequence. If set to `True`, loss is computed only
+ on the assistant responses, which is supported only for [conversational](#conversational) datasets. If
+ `False`, loss is computed on the entire sequence.
+ loss_type (`str`, *optional*, defaults to `"chunked_nll"`):
+ Type of loss to use. When left unset, it defaults to `"chunked_nll"`, except when `use_liger_kernel=True`,
+ in which case it defaults to `"nll"`. Possible values are:
+
+ - `"nll"`: standard negative log-likelihood.
+ - `"dft"`: Dynamic Fine-Tuning, as described in
+ [this paper](https://huggingface.co/papers/2508.05629).
+ - `"chunked_nll"`: same math as `"nll"`, but the `lm_head` projection is computed on non-ignored tokens
+ only (positions with `labels == -100` are dropped before the matmul) and the cross-entropy is processed
+ in chunks of tokens to reduce peak activation memory. Not compatible with `use_liger_kernel`.
+
+ activation_offloading (`bool`, *optional*, defaults to `False`):
+ Whether to offload the activations to the CPU.
+
+ > Deprecated parameters
+
+ pad_token:
+
+
+
+ Parameter `pad_token` is deprecated and will be removed in version v2.0.0. Set `tokenizer.pad_token`
+ directly and pass it as `processing_class` to the trainer instead.
+
+
+
+ > [!NOTE]
+ > These parameters have default values different from [`~transformers.TrainingArguments`]:
+ > - `logging_steps`: Defaults to `10` instead of `500`.
+ > - `gradient_checkpointing`: Defaults to `True` instead of `False`.
+ > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`.
+ > - `learning_rate`: Defaults to `2e-5` instead of `5e-5`.
+ """
+
+ _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs"]
+
+ # Parameters whose default values are overridden from TrainingArguments
+ learning_rate: float = field(
+ default=2e-5,
+ metadata={"help": "The initial learning rate for AdamW."},
+ )
+
+ # Parameters that control the model
+ model_init_kwargs: dict[str, Any] | str | None = field(
+ default=None,
+ metadata={
+ "help": "Keyword arguments for `AutoModelForCausalLM.from_pretrained`, used when the `model` argument of "
+ "the `SFTTrainer` is provided as a string."
+ },
+ )
+ router_aux_loss_coef: float = field(
+ default=0.001,
+ metadata={
+ "help": "Coefficient of the load-balancing auxiliary loss. Only has an effect when training a "
+ "Mixture-of-Experts (MoE) model; for other models it does nothing. The auxiliary loss is added to the "
+ "training loss with this weight. Set to `0.0` to disable it."
+ },
+ )
+ trust_remote_code: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. "
+ "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoProcessor.from_pretrained`."
+ },
+ )
+ chat_template_path: str | None = field(
+ default=None,
+ metadata={
+ "help": "If specified, sets the model's chat template. This can either be the path to a tokenizer (local "
+ "directory or Hugging Face Hub model) or a direct path to a Jinja template file. When using a Jinja file, "
+ "you must ensure that any special tokens referenced in the template are added to the tokenizer and "
+ "that the model's embedding layer is resized accordingly."
+ },
+ )
+
+ # Parameters that control the data preprocessing
+ dataset_text_field: str = field(
+ default="text",
+ metadata={"help": "Name of the column that contains text data in the dataset."},
+ )
+ dataset_kwargs: dict[str, Any] | None = field(
+ default=None,
+ metadata={
+ "help": "Dictionary of optional keyword arguments for the dataset preparation. The only supported key is "
+ "`skip_prepare_dataset`. If the model is a VLM, `skip_prepare_dataset` value is ignored. When the model "
+ "is a VLM, `skip_prepare_dataset` is automatically treated as `True` regardless of the provided value, "
+ "since preprocessing is done on the fly."
+ },
+ )
+ dataset_num_proc: int | None = field(
+ default=None,
+ metadata={"help": "Number of processes to use for processing the dataset."},
+ )
+ eos_token: str | None = field(
+ default=None,
+ metadata={
+ "help": "Token used to indicate the end of a turn or sequence. If `None`, it defaults to `processing_class.eos_token`."
+ },
+ )
+ max_length: int | None = field(
+ default=1024,
+ metadata={
+ "help": "Maximum length of the tokenized sequence. Sequences longer than `max_length` are truncated from "
+ "the left or right depending on the `truncation_mode`. If `None`, no truncation is applied. When packing "
+ "is enabled, this value sets the sequence length."
+ },
+ )
+ truncation_mode: str = field(
+ default="keep_start",
+ metadata={
+ "help": "Truncation mode to use when the sequence exceeds `max_length`. The only supported value is "
+ "`'keep_start'`. The `'keep_end'` value is deprecated and will be removed in v2.0.0.",
+ "choices": ["keep_end", "keep_start"],
+ },
+ )
+ shuffle_dataset: bool = field(
+ default=False,
+ metadata={"help": "Whether to shuffle the dataset."},
+ )
+ packing: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to group multiple sequences into fixed-length blocks to improve computational efficiency "
+ "and reduce padding. Uses `max_length` to define sequence length."
+ },
+ )
+ packing_strategy: str = field(
+ default="bfd",
+ metadata={
+ "help": "Strategy for packing sequences. Can be `'bfd'` (best-fit decreasing, truncates overflow), "
+ "`'bfd_split'` (best-fit decreasing, splits overflow sequences), or `'wrapped'` (aggressive, cuts "
+ "mid-sequence).",
+ "choices": ["bfd", "bfd_split", "wrapped"],
+ },
+ )
+ padding_free: bool = field(
+ default=False,
+ metadata={
+ "help": "Whether to perform forward passes without padding by flattening all sequences in the batch into "
+ "a single continuous sequence. This reduces memory usage by eliminating padding overhead. Currently, this "
+ "is only supported with the FlashAttention 2 or 3, which can efficiently handle the flattened batch "
+ "structure. When packing is enabled with strategy `'bfd'`, padding-free is enabled, regardless of the "
+ "value of this parameter."
+ },
+ )
+ pad_to_multiple_of: int | None = field(
+ default=None,
+ metadata={"help": "If set, the sequences will be padded to a multiple of this value."},
+ )
+ eval_packing: bool | None = field(
+ default=None,
+ metadata={"help": "Whether to pack the eval dataset. If `None`, uses the same value as `packing`."},
+ )
+
+ # Parameters that control the training
+ completion_only_loss: bool | None = field(
+ default=None,
+ metadata={
+ "help": (
+ "Whether to compute loss only on the completion part of the sequence. If set to `True`, loss is "
+ "computed only on the completion, which is supported only for prompt-completion datasets. If `False`, "
+ "loss is computed on the entire sequence. If `None` (default), the behavior depends on the dataset: "
+ "loss is computed on the completion for prompt-completion datasets, and on the full sequence for "
+ "language modeling datasets."
+ )
+ },
+ )
+ assistant_only_loss: bool = field(
+ default=False,
+ metadata={
+ "help": (
+ "Whether to compute loss only on the assistant part of the sequence. If set to `True`, loss is "
+ "computed only on the assistant responses, which is supported only for conversational datasets. If `False`, "
+ "loss is computed on the entire sequence."
+ )
+ },
+ )
+ loss_type: str | None = field(
+ default=None,
+ metadata={
+ "help": "Type of loss to use. When left unset, it defaults to `'chunked_nll'`, except when "
+ "`use_liger_kernel=True`, in which case it defaults to `'nll'`. Possible values are `'nll'` (standard "
+ "negative log-likelihood), `'dft'` (Dynamic Fine-Tuning, https://huggingface.co/papers/2508.05629), and "
+ "`'chunked_nll'` (same math as `'nll'`, but the `lm_head` projection is computed on non-ignored tokens "
+ "only — positions with `labels == -100` are dropped before the matmul — and the cross-entropy is "
+ "processed in chunks of tokens to reduce peak activation memory; not compatible with `use_liger_kernel`; "
+ "the patched `lm_head` path covers standard causal LMs and VLMs whose language model exposes a top-level "
+ "`lm_head`, architectures with a non-standard head are not supported)."
+ },
+ )
+ activation_offloading: bool = field(
+ default=False,
+ metadata={"help": "Whether to offload the activations to the CPU."},
+ )
+
+ # Deprecated parameters
+ pad_token: str | None = field(
+ default=None,
+ metadata={
+ "help": "Deprecated. Set `tokenizer.pad_token` directly and pass it as `processing_class` to the trainer instead."
+ },
+ )
+
+ def __post_init__(self):
+ super().__post_init__()
+ if self.pad_token is not None:
+ warnings.warn(
+ "`pad_token` is deprecated and will be removed in v2.0.0. "
+ "Set `tokenizer.pad_token` directly and pass it as `processing_class` to the trainer instead.",
+ FutureWarning,
+ stacklevel=3,
+ )
+ if self.truncation_mode == "keep_end":
+ warnings.warn(
+ "The `'keep_end'` truncation mode is deprecated and will be removed in v2.0.0. "
+ "Use `truncation_mode='keep_start'` (the default) instead.",
+ FutureWarning,
+ stacklevel=3,
+ )
+ if self.packing_strategy == "bfd-requeue":
+ warnings.warn(
+ "The `bfd-requeue` packing strategy has been renamed to `bfd_split`. Please update your configuration accordingly. "
+ "The `bfd-requeue` strategy is deprecated and will be removed in v2.0.0.",
+ FutureWarning,
+ stacklevel=3,
+ )
+ self.packing_strategy = "bfd_split"
+
+ # When unset, default to "chunked_nll" unless `use_liger_kernel=True`, in which case default to "nll".
+ if self.loss_type is None:
+ self.loss_type = "nll" if self.use_liger_kernel else "chunked_nll"
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/sft_trainer.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/sft_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6dc55a04dd380831a562f9f423f61ec015fd8f6
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/sft_trainer.py
@@ -0,0 +1,1848 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import contextlib
+import json
+import os
+import types
+import warnings
+from collections import defaultdict
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import transformers
+from accelerate import PartialState
+from accelerate.logging import get_logger
+from accelerate.utils import is_peft_model
+from datasets import Dataset, IterableDataset
+from packaging.version import Version
+from transformers import (
+ AutoProcessor,
+ DataCollator,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+ ProcessorMixin,
+ TrainingArguments,
+)
+from transformers.data.data_collator import DataCollatorMixin
+from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast
+from transformers.trainer_callback import TrainerCallback
+from transformers.trainer_utils import EvalPrediction
+from transformers.utils import is_peft_available
+
+from ..chat_template_utils import (
+ clone_chat_template,
+ get_training_chat_template,
+ has_generation_markers,
+ is_chat_template_stop_token_trained,
+)
+from ..data_utils import (
+ apply_chat_template,
+ is_conversational,
+ is_conversational_from_value,
+ maybe_convert_to_chatml,
+ pack_dataset,
+ prepare_multimodal_messages,
+)
+from ..models import get_act_offloading_ctx_manager
+from .base_trainer import _BaseTrainer
+from .sft_config import SFTConfig
+from .utils import (
+ create_model_from_path,
+ entropy_from_logits,
+ flush_left,
+ get_config_model_id,
+ pad,
+ selective_log_softmax,
+)
+
+
+_CHUNKED_LM_HEAD_CHUNK_SIZE = 256
+
+
+if is_peft_available():
+ import peft
+ from peft import PeftConfig, PeftModel, PeftType, get_peft_model
+
+
+@dataclass
+class _ChunkedCELMHeadOutput(CausalLMOutputWithPast):
+ """`CausalLMOutputWithPast` with extra fields populated by the chunked-CE path."""
+
+ num_correct_tokens: torch.Tensor | None = None
+ entropy_sum: torch.Tensor | None = None
+ num_valid_tokens: torch.Tensor | None = None
+ aux_loss: torch.Tensor | None = None
+
+
+def _maybe_gather_lm_head_ctx(w, b):
+ # Allgather ZeRO-3 partitioned `lm_head` weight/bias for the chunked matmul. No-op if not ZeRO-3, or if the
+ # param is already gathered (tied embeddings: `embed_tokens` shares the weight and keeps it `AVAILABLE`, so
+ # partitioning on our exit would collide with its active-submodule tracking).
+ from transformers.integrations.deepspeed import is_deepspeed_zero3_enabled
+
+ if not is_deepspeed_zero3_enabled():
+ return contextlib.nullcontext()
+
+ import deepspeed
+ from deepspeed.runtime.zero.partition_parameters import ZeroParamStatus
+
+ params = [w] if b is None else [w, b]
+ if all(p.ds_status == ZeroParamStatus.AVAILABLE for p in params):
+ return contextlib.nullcontext()
+ return deepspeed.zero.GatheredParameters(params)
+
+
+def _chunk(h, w, b, lbl, logit_scale, final_logit_softcapping):
+ with _maybe_gather_lm_head_ctx(w, b):
+ logits = h.float() @ w.float().t()
+ if b is not None:
+ logits = logits + b.float()
+ if logit_scale != 1.0:
+ logits = logits * logit_scale
+ if final_logit_softcapping is not None:
+ logits = final_logit_softcapping * torch.tanh(logits / final_logit_softcapping)
+ log_p = F.log_softmax(logits, dim=-1)
+ chunk_loss = F.nll_loss(log_p, lbl, reduction="sum")
+ chunk_correct = (logits.argmax(dim=-1) == lbl).sum().float()
+ chunk_entropy = -(log_p.exp() * log_p).sum(dim=-1).sum()
+ return chunk_loss, chunk_correct, chunk_entropy
+
+
+def _chunked_cross_entropy_loss(
+ hidden_states: torch.Tensor,
+ lm_head_weight: torch.Tensor,
+ chunk_size: int,
+ labels: torch.Tensor | None = None,
+ shift_labels: torch.Tensor | None = None,
+ num_items_in_batch: torch.Tensor | int | None = None,
+ logit_scale: float = 1.0,
+ final_logit_softcapping: float | None = None,
+ lm_head_bias: torch.Tensor | None = None,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+ """
+ Memory-efficient next-token cross-entropy over hidden states and an `lm_head` weight.
+
+ The full `lm_head` projection is never materialized. Positions where labels equal `-100` are dropped before the
+ matmul, and the remaining tokens are processed in chunks of `chunk_size`. Each chunk's `[chunk_size, vocab_size]`
+ logits tensor is kept alive only during its own forward/backward pass via gradient checkpointing, so peak
+ logits-activation memory is `chunk_size * vocab_size` instead of `batch_size * seq_len * vocab_size`.
+
+ At least one of `labels` or `shift_labels` must be provided. Passing `labels` alone is the standard path and
+ triggers the internal `labels[..., 1:]` / `hidden_states[..., :-1, :]` shift. Passing `shift_labels` skips the
+ shift and assumes the caller has already aligned labels with hidden states — this is the contract used under
+ context / sequence parallelism, where labels are shifted before being sharded. If both are provided, `shift_labels`
+ wins (matching [`~transformers.loss.ForCausalLMLoss`]).
+
+ Args:
+ hidden_states (`torch.Tensor`):
+ Base decoder output of shape `(B, S, H)`, i.e. before the `lm_head` projection.
+ lm_head_weight (`torch.Tensor`):
+ Weight of the `lm_head` linear layer, shape `(V, H)`.
+ chunk_size (`int`):
+ Number of valid tokens processed per chunk. Peak memory scales linearly with this.
+ labels (`torch.Tensor`, *optional*):
+ Labels of shape `(B, S)`. Positions equal to `-100` are excluded from both the `lm_head` matmul and the
+ loss. Mutually exclusive with `shift_labels`.
+ shift_labels (`torch.Tensor`, *optional*):
+ Pre-shifted labels of shape `(B, S)`, aligned with `hidden_states` (position `i` predicts
+ `shift_labels[i]`). Mutually exclusive with `labels`.
+ num_items_in_batch (`torch.Tensor`, `int` or `None`, *optional*):
+ Total number of valid tokens across the global batch, as plumbed by [`~transformers.Trainer`]. When
+ provided, the loss is reduced as `sum / num_items_in_batch`, matching the gradient-accumulation-correct
+ behavior of HF's default cross-entropy. When `None`, reduction is `mean` over local valid tokens.
+ logit_scale (`float`, *optional*, defaults to `1.0`):
+ Multiplier applied to each chunk's logits before the cross-entropy, matching the `logit_scale` behavior of
+ Cohere-style models.
+ final_logit_softcapping (`float`, *optional*):
+ If set, applies `softcap * tanh(logits / softcap)` to each chunk's logits before the cross-entropy,
+ matching the `final_logit_softcapping` behavior of Gemma-style models. Applied after `logit_scale`.
+ lm_head_bias (`torch.Tensor`, *optional*):
+ Bias of the `lm_head` linear layer, shape `(V,)`. Added to each chunk's logits when provided.
+
+ Returns:
+ `tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]`: scalar loss, number of correctly-predicted
+ tokens (count), sum of per-token Shannon entropy (in nats), and number of valid (non-`-100`) target tokens —
+ all over the local batch. Raw sums are returned so callers can reduce correctly across ranks.
+ """
+ if labels is None and shift_labels is None:
+ raise ValueError("At least one of `labels` or `shift_labels` must be provided.")
+
+ if shift_labels is not None:
+ hidden = hidden_states.reshape(-1, hidden_states.size(-1))
+ labels = shift_labels.reshape(-1)
+ else:
+ hidden = hidden_states[..., :-1, :].reshape(-1, hidden_states.size(-1))
+ labels = labels[..., 1:].reshape(-1)
+
+ valid = labels != -100
+ hidden = hidden[valid]
+ labels = labels[valid]
+ n_valid = hidden.size(0)
+
+ correct = hidden.new_zeros((), dtype=torch.float32)
+ entropy_sum = hidden.new_zeros((), dtype=torch.float32)
+ n_valid_tensor = torch.tensor(n_valid, device=hidden.device, dtype=torch.long)
+ if n_valid == 0:
+ # Whole micro-batch masked (e.g. completion-only loss + truncation). Keep the loss connected
+ # to the autograd graph through every trainable parameter so `.backward()` succeeds and DDP /
+ # FSDP gradient sync doesn't hang on a missing param.
+ with _maybe_gather_lm_head_ctx(lm_head_weight, lm_head_bias):
+ loss = (hidden_states.float().sum() + lm_head_weight.float().sum()) * 0.0
+ if lm_head_bias is not None:
+ loss = loss + lm_head_bias.float().sum() * 0.0
+ return loss, correct, entropy_sum, n_valid_tensor
+
+ loss = hidden.new_zeros((), dtype=torch.float32)
+
+ for start in range(0, n_valid, chunk_size):
+ h_chunk = hidden[start : start + chunk_size]
+ lbl_chunk = labels[start : start + chunk_size]
+ chunk_loss, chunk_correct, chunk_entropy = torch.utils.checkpoint.checkpoint(
+ _chunk,
+ h_chunk,
+ lm_head_weight,
+ lm_head_bias,
+ lbl_chunk,
+ logit_scale,
+ final_logit_softcapping,
+ use_reentrant=False,
+ )
+ loss = loss + chunk_loss
+ correct = correct + chunk_correct
+ entropy_sum = entropy_sum + chunk_entropy
+
+ if num_items_in_batch is None:
+ loss = loss / n_valid
+ else:
+ if isinstance(num_items_in_batch, torch.Tensor):
+ num_items_in_batch = num_items_in_batch.to(loss.device)
+ loss = loss / num_items_in_batch
+ return loss, correct, entropy_sum, n_valid_tensor
+
+
+def _patch_chunked_ce_lm_head(model: torch.nn.Module, chunk_size: int, is_vlm: bool = False) -> None:
+ """
+ Patch `model.forward` to compute the LM loss via [`_chunked_cross_entropy_loss`].
+
+ When `labels` (or pre-shifted `shift_labels`, for CP/SP) are provided, the patched forward runs the decoder up to
+ `last_hidden_state` (skipping the `lm_head` matmul), drops `labels == -100` positions, and computes the
+ cross-entropy in chunks of `chunk_size` valid tokens. Returns a [`_ChunkedCELMHeadOutput`] with `loss` set,
+ `logits=None`, and `num_correct_tokens` / `entropy_sum` / `num_valid_tokens` over non-ignored tokens. For MoE
+ models (`output_router_logits=True`), the load-balancing aux loss is added with the same coefficient and formula as
+ the model's reference forward.
+
+ Without labels, the original forward runs unchanged — generation and labels-free eval preserve any per-model logits
+ post-processing (`logit_scale`, `final_logit_softcapping`, `logits_to_keep` slicing).
+
+ Args:
+ model (`torch.nn.Module`):
+ Model to patch. For PEFT, pass `peft_model.get_base_model()` rather than the `PeftModel` wrapper, so
+ prompt-learning variants (PromptTuning, PrefixTuning, PTuning) keep their virtual-token injection in
+ `PeftModel.forward` before delegating into the patched forward.
+ chunk_size (`int`):
+ Number of valid tokens processed per CE chunk.
+ is_vlm (`bool`):
+ Set to `True` for VLMs. Only used to read `logit_scale` / `final_logit_softcapping` /
+ `output_router_logits` from `model.config.text_config` instead of the top-level config.
+ """
+ # VLM scaling configs (`logit_scale`, `final_logit_softcapping`, MoE `output_router_logits`) live on `text_config`;
+ # text-only models keep them on the top-level config.
+ text_config = model.config.text_config if is_vlm else model.config
+ final_logit_softcapping = getattr(text_config, "final_logit_softcapping", None)
+ logit_scale = getattr(text_config, "logit_scale", 1.0)
+ original_forward = model.forward
+ lm_head = model.get_output_embeddings()
+
+ def _chunked_ce_forward(
+ self: torch.nn.Module,
+ input_ids: torch.Tensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ labels: torch.Tensor | None = None,
+ num_items_in_batch: torch.Tensor | int | None = None,
+ shift_labels: torch.Tensor | None = None,
+ output_router_logits: bool | None = None,
+ **kwargs,
+ ) -> CausalLMOutputWithPast:
+ # Without labels, fall back to the original forward so generation and labels-free evaluation
+ # preserve any per-model logits post-processing (e.g. Cohere `logit_scale`, Gemma
+ # `final_logit_softcapping`, `logits_to_keep` slicing).
+ if labels is None and shift_labels is None:
+ # MoE models: request router logits so the model returns `outputs.aux_loss`. VLM wrappers honor this only
+ # as a forward kwarg (not from the model config), so it must be passed here.
+ if output_router_logits is not None:
+ kwargs["output_router_logits"] = output_router_logits
+ return original_forward(input_ids=input_ids, attention_mask=attention_mask, **kwargs)
+
+ if output_router_logits is None:
+ output_router_logits = getattr(text_config, "output_router_logits", False)
+
+ kwargs.pop("use_cache", None)
+ decoder_kwargs = {}
+ # MoE models: request router logits so the model returns `outputs.aux_loss`. VLM wrappers honor this only
+ # as a forward kwarg (not from the model config), so it must be passed here.
+ if output_router_logits:
+ decoder_kwargs["output_router_logits"] = True
+ # `base_model` gives the backbone model (skipping `lm_head`) — text decoder for LMs, multimodal wrapper
+ # for VLMs (so vision-token injection runs before the text decoder). `get_decoder()` won't do: on VLMs it
+ # returns just the text stack and feeds image-placeholder IDs through it.
+ # Pre-5.0 transformers VLMs set `base_model_prefix = ""` so `self.base_model is self` (re-runs `lm_head`).
+ # Fall back to `self.model` there.
+ if is_vlm and Version(transformers.__version__) < Version("5.0.0"):
+ backbone = self.model
+ else:
+ backbone = self.base_model
+ outputs: BaseModelOutputWithPast = backbone(
+ input_ids=input_ids, attention_mask=attention_mask, use_cache=False, **decoder_kwargs, **kwargs
+ )
+ hidden_states = outputs.last_hidden_state
+
+ lm_head_weight = lm_head.weight
+ lm_head_bias = lm_head.bias
+ # Under FSDP2, lm_head.weight is a DTensor (Shard(0) or Replicate). Passing it directly
+ # into the gradient-checkpointed chunk loop causes FSDP2 to re-gather it once per chunk
+ # during backward recomputation. full_tensor() converts it to a plain tensor once; all
+ # chunks reference that tensor, so only one all-gather occurs (in full_tensor()'s backward).
+ if isinstance(lm_head_weight, torch.distributed.tensor.DTensor):
+ lm_head_weight = lm_head_weight.full_tensor()
+ if lm_head_bias is not None:
+ lm_head_bias = lm_head_bias.full_tensor()
+ loss, num_correct_tokens, entropy_sum, num_valid_tokens = _chunked_cross_entropy_loss(
+ hidden_states,
+ lm_head_weight,
+ chunk_size,
+ labels=labels,
+ shift_labels=shift_labels,
+ num_items_in_batch=num_items_in_batch,
+ logit_scale=logit_scale,
+ final_logit_softcapping=final_logit_softcapping,
+ lm_head_bias=lm_head_bias,
+ )
+
+ aux_loss = None
+ if output_router_logits:
+ # Mirror the per-family MoE forward: add `router_aux_loss_coef * load_balancing_loss_func(...)` to
+ # the main loss. Mixtral is the source of truth — every MoE family (Qwen3Moe, GptOss, OLMoE,
+ # Qwen2Moe, DBRX, JetMoE, PhiMoE, …) pulls this function from mixtral via the modular system, so a
+ # single import keeps us in lockstep with upstream for every family we test.
+ from transformers.models.mixtral.modeling_mixtral import load_balancing_loss_func
+
+ if Version(transformers.__version__) < Version("5.0.0") and not is_vlm:
+ num_experts = self.num_experts
+ num_experts_per_tok = self.num_experts_per_tok
+ router_aux_loss_coef = self.router_aux_loss_coef
+ else:
+ # Upstream bug AttributeError: 'GptOssConfig' object has no attribute 'num_experts'; see #5754
+ if text_config.model_type == "gpt_oss" and Version("5.0.0") <= Version(
+ transformers.__version__
+ ) < Version("5.6.0"):
+ num_experts = self.num_experts
+ else:
+ num_experts = text_config.num_experts
+ num_experts_per_tok = text_config.num_experts_per_tok
+ router_aux_loss_coef = text_config.router_aux_loss_coef
+ aux_loss = load_balancing_loss_func(
+ outputs.router_logits, num_experts, num_experts_per_tok, attention_mask
+ )
+ loss = loss + router_aux_loss_coef * aux_loss.to(loss.device)
+
+ return _ChunkedCELMHeadOutput(
+ loss=loss,
+ logits=None,
+ past_key_values=outputs.past_key_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ num_correct_tokens=num_correct_tokens,
+ entropy_sum=entropy_sum,
+ num_valid_tokens=num_valid_tokens,
+ aux_loss=aux_loss,
+ )
+
+ model.forward = types.MethodType(_chunked_ce_forward, model)
+
+
+logger = get_logger(__name__)
+
+
+FLASH_ATTENTION_VARIANTS = {
+ "flash_attention_2",
+ "flash_attention_3",
+ "kernels-community/flash-attn2",
+ "kernels-community/flash-attn3",
+ "kernels-community/vllm-flash-attn3",
+}
+
+
+def get_dataset_column_names(dataset: Dataset | IterableDataset) -> list[str]:
+ return list(next(iter(dataset)).keys()) if dataset.column_names is None else dataset.column_names
+
+
+@dataclass
+class DataCollatorForLanguageModeling(DataCollatorMixin):
+ """
+ Data collator used for language modeling data. Inputs are dynamically padded to the maximum length of a batch.
+
+ This collator expects each example in the input list to be a dictionary containing at least the `"input_ids"` key.
+ If the input contains `"labels"`, they are used as is (truncated and padded like the input IDs); otherwise the
+ labels default to the input IDs. Tokens that shouldn't contribute to the loss are expected to be already set to
+ `-100` in the labels; the [`SFTTrainer`] takes care of this during dataset preparation. The collator returns a
+ dictionary containing the following keys:
+ - `"input_ids"`: Tensor of input IDs, padded to the maximum length of the batch.
+ - `"labels"`: Tensor of labels, padded with `-100` to the maximum length of the batch. If `padding_free` is set
+ to `False`, the following key is also returned:
+ - `"attention_mask"`: Tensor of attention masks, padded to the maximum length of the batch.
+ If `padding_free` is set to `True`, the following key is also returned:
+ - `"position_ids"`: Tensor of position IDs, padded to the maximum length of the batch.
+
+ Args:
+ pad_token_id (`int`):
+ Token ID to use for padding.
+ max_length (`int`, *optional*):
+ Maximum length of the sequences in the batch. Sequences longer than `max_length` are truncated to
+ `max_length`.
+ truncation_mode (`str`, *optional*, defaults to `"keep_start"`):
+ Truncation mode to use when the sequence exceeds `max_length`. Possible values are `"keep_end"` and
+ `"keep_start"`.
+ padding_free (`bool`, *optional*, defaults to `False`):
+ If set to `True`, the sequences will be flattened into a single sequence, and the position IDs will be
+ generated accordingly and returned instead of the attention mask.
+ pad_to_multiple_of (`int`, *optional*):
+ If set, the sequences will be padded to a multiple of this value.
+ return_tensors (`str`, *optional*, defaults to `"pt"`):
+ Type of Tensor to return. Only `"pt"` is currently supported.
+
+ Examples:
+ ```python
+ >>> from trl.trainer.sft_trainer import DataCollatorForLanguageModeling
+
+ >>> collator = DataCollatorForLanguageModeling(pad_token_id=0)
+ >>> examples = [{"input_ids": [1, 2, 3]}, {"input_ids": [4, 5]}]
+ >>> collator(examples)
+ {'input_ids': tensor([[ 1, 2, 3],
+ [ 4, 5, 0]]),
+ 'attention_mask': tensor([[ 1, 1, 1],
+ [ 1, 1, 0]]),
+ 'labels': tensor([[ 1, 2, 3],
+ [ 4, 5, -100]])}
+
+ >>> # With prebuilt labels
+ >>> examples = [
+ ... {"input_ids": [1, 2, 3], "labels": [-100, 2, 3]},
+ ... {"input_ids": [4, 5], "labels": [-100, 5]},
+ ... ]
+ >>> collator(examples)
+ {'input_ids': tensor([[ 1, 2, 3],
+ [ 4, 5, 0]]),
+ 'attention_mask': tensor([[ 1, 1, 1],
+ [ 1, 1, 0]]),
+ 'labels': tensor([[-100, 2, 3],
+ [-100, 5, -100]])}
+
+ >>> # With padding_free
+ >>> collator = DataCollatorForLanguageModeling(pad_token_id=0, padding_free=True)
+ >>> collator(examples)
+ {'input_ids': tensor([[ 1, 2, 3, 4, 5]]),
+ 'position_ids': tensor([[0, 1, 2, 0, 1]]),
+ 'labels': tensor([[-100, 2, 3, -100, 5]])}
+ ```
+ """
+
+ pad_token_id: int
+ max_length: int | None = None
+ truncation_mode: str = "keep_start"
+ padding_free: bool = False
+ pad_to_multiple_of: int | None = None
+ return_tensors: str = "pt"
+
+ def torch_call(self, examples: list[dict[str, Any]]) -> dict[str, Any]:
+ input_ids = [example["input_ids"] for example in examples]
+ batch_seq_lengths = [example["seq_lengths"] for example in examples] if "seq_lengths" in examples[0] else None
+ labels = [example.get("labels", example["input_ids"]) for example in examples]
+
+ # Truncate per sequence if necessary
+ if self.max_length is not None and not self.padding_free:
+ if self.truncation_mode == "keep_start":
+ sl = slice(None, self.max_length)
+ elif self.truncation_mode == "keep_end":
+ sl = slice(-self.max_length, None)
+ else:
+ raise ValueError(
+ f"Unsupported truncation mode: {self.truncation_mode}, expected 'keep_start' or 'keep_end'"
+ )
+ input_ids = [ids[sl] for ids in input_ids]
+ labels = [lbl[sl] for lbl in labels]
+
+ # Convert to tensor
+ input_ids = [torch.tensor(ids) for ids in input_ids]
+ labels = [torch.tensor(lbl) for lbl in labels]
+
+ # For padding-free, we should NOT create attention_mask as it causes FlashAttention to ignore position_ids and
+ # compute wrong cu_seq_lens from the all-1s mask
+ if self.padding_free:
+ if batch_seq_lengths is not None:
+ position_ids = self.get_position_ids_from_packed_seq_lengths(batch_seq_lengths)
+ else:
+ position_ids = [torch.arange(len(ids)) for ids in input_ids]
+ else:
+ attention_mask = [torch.ones_like(ids) for ids in input_ids]
+
+ # If padding_free, flatten everything into a single sequence
+ output = {}
+ if self.padding_free:
+ input_ids = [torch.cat(input_ids, dim=0)]
+ labels = [torch.cat(labels, dim=0)]
+ position_ids = [torch.cat(position_ids, dim=0)]
+
+ # Pad
+ output["input_ids"] = pad(
+ input_ids,
+ padding_value=self.pad_token_id,
+ padding_side="right",
+ pad_to_multiple_of=self.pad_to_multiple_of,
+ )
+ output["labels"] = pad(
+ labels, padding_value=-100, padding_side="right", pad_to_multiple_of=self.pad_to_multiple_of
+ )
+ if self.padding_free:
+ output["position_ids"] = pad(
+ position_ids, padding_value=0, padding_side="right", pad_to_multiple_of=self.pad_to_multiple_of
+ )
+ output["labels"][output["position_ids"] == 0] = -100
+ else:
+ output["attention_mask"] = pad(
+ attention_mask, padding_value=0, padding_side="right", pad_to_multiple_of=self.pad_to_multiple_of
+ )
+ return output
+
+ @staticmethod
+ def get_position_ids_from_packed_seq_lengths(batch_seq_lengths: list[list[int]]) -> list[torch.Tensor]:
+ """
+ Get position IDs for packed sequences.
+
+ Args:
+ batch_seq_lengths (`list[list[int]]`):
+ A list of lists containing the lengths of each individual document in the packed batch.
+
+ Return:
+ `list[torch.Tensor]`:
+ A list of tensors containing the position IDs for each packed sequence.
+ """
+ # Get lengths per row
+ example_lengths = [sum(seq_lengths) for seq_lengths in batch_seq_lengths]
+ # Flat list of lengths
+ batch_seq_lengths = torch.tensor(
+ [seq_length for seq_lengths in batch_seq_lengths for seq_length in seq_lengths]
+ )
+ position_ids = torch.ones(sum(example_lengths), dtype=batch_seq_lengths.dtype)
+ position_ids[0] = 0
+ # Reset position ids to 0 at the start of each sequence
+ position_ids[batch_seq_lengths[:-1].cumsum(0)] = -(batch_seq_lengths[:-1] - 1)
+ position_ids = position_ids.cumsum(0)
+ # Split back into one tensor per example
+ return list(position_ids.split(example_lengths))
+
+
+@dataclass
+class DataCollatorForVisionLanguageModeling(DataCollatorMixin):
+ """
+ Data collator for vision-language modeling tasks.
+
+ Unlike text-only datasets, where the collator typically receives pre-tokenized inputs ready for batching,
+ vision-language data processing involves converting images into pixel values. This conversion is disk-intensive,
+ making upfront preprocessing of the entire dataset impractical. Therefore, this collator performs tokenization and
+ image processing on-the-fly to efficiently prepare batches.
+
+ Each input example should be a dictionary containing at least:
+ - An `"images"` key holding a list of images, or an `"image"` key holding a single image.
+ - [language modeling](#language-modeling) type: either a `"messages"` key for conversational inputs or a `"text"`
+ key for standard text inputs.
+ - [prompt-completion](#prompt-completion) type: keys `"prompt"` and `"completion"` for the prompt and completion.
+
+ The collator outputs a dictionary including:
+ - `"input_ids"`: Tensor of token IDs.
+ - `"attention_mask"`: Tensor indicating attention mask.
+ - `"pixel_values"`: Tensor representing image pixel values.
+ - `"labels"`: Tensor for training labels.
+
+ Additional keys may be present depending on the processor, such as `"image_grid_thw"` or `"image_position_ids"`.
+
+ Args:
+ processor ([`~transformers.ProcessorMixin`]):
+ The processor used to tokenize text and process images. It must be a subclass of
+ [`~transformers.ProcessorMixin`] and include a `tokenizer` with a defined `pad_token_id`.
+ max_length (`int`, *optional*):
+ Maximum sequence length for input tokens. If `None`, no truncation is applied.
+ completion_only_loss (`bool`, *optional*, defaults to `False`):
+ Whether to compute loss only on the completion part of the sequence. When `True`, the labels for the prompt
+ part are set to -100. It requires the dataset type to be prompt-completion.
+ pad_to_multiple_of (`int`, *optional*):
+ If set, the sequences will be padded to a multiple of this value.
+ dataset_text_field (`str`, *optional*, defaults to `"text"`):
+ Name of the column that contains text data in the dataset. This parameter is only relevant for [standard
+ datasets format](dataset_formats#standard).
+ return_tensors (`str`, *optional*, defaults to `"pt"`):
+ The tensor type to return. Currently, only `"pt"` (PyTorch tensors) is supported.
+
+ Example:
+ ```python
+ >>> from trl.trainer.sft_trainer import DataCollatorForVisionLanguageModeling
+ >>> from transformers import AutoProcessor
+
+ >>> processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-VL-7B-Instruct")
+ >>> collator = DataCollatorForVisionLanguageModeling(processor)
+ >>> examples = [
+ ... {"images": [Image.open("image_0.png")], "messages": [{"role": "user", "content": "What is this?"}]},
+ ... {"images": [Image.open("image_1.png")], "messages": [{"role": "user", "content": "Describe this image."}]},
+ ... ]
+ >>> collator(examples)
+ {'input_ids': tensor([[151644, 8948, 198, 2610, 525, 264, 10950, 17847, 13, 151645, 198,
+ 151644, 872, 198, 151652, 151655, 151655, 151655, 151655, 151653, 3838, 374,
+ 419, 30, 151645, 198],
+ [151644, 8948, 198, 2610, 525, 264, 10950, 17847, 13, 151645, 198,
+ 151644, 872, 198, 151652, 151655, 151655, 151655, 151655, 151653, 74785, 419,
+ 2168, 13, 151645, 198]]),
+ 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]),
+ 'pixel_values': tensor([[-0.9893, 0.1785, 1.5362, ..., -0.0582, 0.8661, -0.2431],
+ [-0.2302, 0.9522, -1.1061, ..., 0.0555, 1.3354, -0.6412],
+ [ 1.2150, 0.9084, 0.7041, ..., 0.2404, -0.8403, -0.5133],
+ ...,
+ [ 0.6895, 0.2807, 0.2515, ..., -0.2004, -1.2100, 0.0555],
+ [ 0.8209, -0.9748, 1.5654, ..., 1.6055, -0.4706, 0.5817],
+ [-1.0915, 0.4559, 0.9230, ..., 0.5106, 0.0982, -0.1720]]),
+ 'image_grid_thw': tensor([[1, 4, 4],
+ [1, 4, 4]]),
+ 'labels': tensor([[151644, 8948, 198, 2610, 525, 264, 10950, 17847, 13, 151645, 198,
+ 151644, 872, 198, 151652, 151655, 151655, 151655, 151655, 151653, 3838, 374,
+ 419, 30, 151645, 198],
+ [151644, 8948, 198, 2610, 525, 264, 10950, 17847, 13, 151645, 198,
+ 151644, 872, 198, 151652, 151655, 151655, 151655, 151655, 151653, 74785, 419,
+ 2168, 13, 151645, 198]])}
+ ```
+ """
+
+ processor: ProcessorMixin
+ max_length: int | None = None
+ completion_only_loss: bool = False # default not used in practice; SFTTrainer always passes the relevant value
+ pad_to_multiple_of: int | None = None
+ dataset_text_field: str = "text"
+ return_tensors: str = "pt"
+
+ def torch_call(self, examples: list[dict[str, Any]]) -> dict[str, Any]:
+ if "messages" in examples[0] or self.dataset_text_field in examples[0]:
+ if self.completion_only_loss:
+ raise ValueError(
+ "The `completion_only_loss` argument is not supported for language modeling datasets."
+ )
+ return self._collate_language_modeling(examples)
+ elif "prompt" in examples[0] and "completion" in examples[0]:
+ return self._collate_prompt_completion(examples)
+ else:
+ raise KeyError(f"Unexpected input keys in examples: {list(examples[0].keys())}.")
+
+ def _collate_language_modeling(self, examples: list[dict[str, Any]]) -> dict[str, Any]:
+ if "image" in examples[0]:
+ for example in examples:
+ example["images"] = [example.pop("image")]
+ images = [example["images"] for example in examples]
+ # Transformers requires at least one image in the batch, otherwise it throws an error
+ if all(img_list == [] for img_list in images):
+ images = None
+
+ if "messages" in examples[0]: # conversational case
+ messages = [
+ prepare_multimodal_messages(example["messages"], images=example["images"]) for example in examples
+ ]
+ texts = self.processor.apply_chat_template(messages)
+ elif self.dataset_text_field in examples[0]: # standard case
+ texts = [example[self.dataset_text_field] for example in examples]
+ else:
+ raise KeyError(
+ "The input examples must contain either 'messages' for conversational data or 'text' for standard "
+ "data."
+ )
+
+ output = self.processor(
+ images=images,
+ text=texts,
+ padding=True,
+ padding_side="right",
+ pad_to_multiple_of=self.pad_to_multiple_of,
+ truncation=self.max_length is not None,
+ max_length=self.max_length,
+ return_tensors=self.return_tensors,
+ add_special_tokens=False, # to avoid adding the BOS, twice see https://huggingface.co/blog/qgallouedec/gotchas-in-tokenizer-behavior#7-chat-template-and-tokenization-dont-compose-due-to-special-tokens
+ )
+ labels = output["input_ids"].clone()
+ labels[output["attention_mask"] == 0] = -100
+ # We mask only padding tokens (-100) in the labels. Vision tokens are left unchanged because their handling in
+ # loss computation has to be done by the model, and masking them here would be infeasible in practice as vision
+ # token definitions vary across architectures.
+ output["labels"] = labels
+ return output
+
+ def _collate_prompt_completion(self, examples: list[dict[str, Any]]) -> dict[str, Any]:
+ if self.pad_to_multiple_of is not None:
+ raise NotImplementedError(
+ "Padding to a multiple of a value is not yet implemented for vision-language modeling and "
+ "prompt-completion data."
+ )
+ if "image" in examples[0]:
+ for example in examples:
+ example["images"] = [example.pop("image")]
+ images = [example["images"] for example in examples]
+ # Transformers requires at least one image in the batch, otherwise it throws an error
+ if all(img_list == [] for img_list in images):
+ images = None
+ if is_conversational(examples[0]): # conversational case
+ for example in examples:
+ example["prompt"] = prepare_multimodal_messages(example["prompt"], images=example["images"])
+ example["completion"] = prepare_multimodal_messages(example["completion"])
+ examples = [apply_chat_template(example, self.processor) for example in examples]
+
+ prompts = [example["prompt"] for example in examples]
+ completions = [example["completion"] for example in examples]
+
+ processed_prompts = self.processor(
+ images=images,
+ text=prompts,
+ padding=True,
+ padding_side="left",
+ return_tensors=self.return_tensors,
+ add_special_tokens=False, # to avoid adding the BOS, twice see https://huggingface.co/blog/qgallouedec/gotchas-in-tokenizer-behavior#7-chat-template-and-tokenization-dont-compose-due-to-special-tokens
+ )
+ processed_completions = self.processor(
+ text=completions,
+ padding=True,
+ padding_side="right",
+ return_tensors=self.return_tensors,
+ add_special_tokens=False, # to avoid adding the BOS, twice see https://huggingface.co/blog/qgallouedec/gotchas-in-tokenizer-behavior#7-chat-template-and-tokenization-dont-compose-due-to-special-tokens
+ )
+
+ # Concatenate prompts and completions
+ prompt_ids, prompt_mask = processed_prompts["input_ids"], processed_prompts["attention_mask"]
+ completion_ids, completion_mask = processed_completions["input_ids"], processed_completions["attention_mask"]
+ input_ids = torch.cat((prompt_ids, completion_ids), dim=1)
+ attention_mask = torch.cat((prompt_mask, completion_mask), dim=1)
+ completion_mask = torch.cat((torch.zeros_like(prompt_mask), completion_mask), dim=1)
+ if "token_type_ids" in processed_prompts: # special case for Gemma
+ prompt_token_type_ids = processed_prompts["token_type_ids"]
+ completion_token_type_ids = processed_completions["token_type_ids"]
+ token_type_ids = torch.cat((prompt_token_type_ids, completion_token_type_ids), dim=1)
+ if "mm_token_type_ids" in processed_prompts: # special case for ERNIE-VL
+ prompt_mm_token_type_ids = processed_prompts["mm_token_type_ids"]
+ completion_mm_token_type_ids = processed_completions.get(
+ "mm_token_type_ids", torch.zeros_like(completion_ids)
+ )
+ mm_token_type_ids = torch.cat((prompt_mm_token_type_ids, completion_mm_token_type_ids), dim=1)
+
+ # Flush left to reduce padding
+ if "token_type_ids" in processed_prompts and "mm_token_type_ids" in processed_prompts:
+ attention_mask, input_ids, completion_mask, token_type_ids, mm_token_type_ids = flush_left(
+ attention_mask, input_ids, completion_mask, token_type_ids, mm_token_type_ids
+ )
+ elif "token_type_ids" in processed_prompts:
+ attention_mask, input_ids, completion_mask, token_type_ids = flush_left(
+ attention_mask, input_ids, completion_mask, token_type_ids
+ )
+ elif "mm_token_type_ids" in processed_prompts:
+ attention_mask, input_ids, completion_mask, mm_token_type_ids = flush_left(
+ attention_mask, input_ids, completion_mask, mm_token_type_ids
+ )
+ else:
+ attention_mask, input_ids, completion_mask = flush_left(attention_mask, input_ids, completion_mask)
+
+ # Truncate if necessary
+ if self.max_length is not None:
+ input_ids = input_ids[:, : self.max_length]
+ attention_mask = attention_mask[:, : self.max_length]
+ completion_mask = completion_mask[:, : self.max_length]
+ if "token_type_ids" in processed_prompts:
+ token_type_ids = token_type_ids[:, : self.max_length]
+ if "mm_token_type_ids" in processed_prompts:
+ mm_token_type_ids = mm_token_type_ids[:, : self.max_length]
+
+ # Create labels and mask padding tokens
+ labels = input_ids.clone()
+ labels[attention_mask == 0] = -100
+ if self.completion_only_loss:
+ labels[completion_mask == 0] = -100
+
+ # Build the output dictionary
+ output = processed_prompts # we take processed_prompts because it contains the images
+ output["input_ids"] = input_ids
+ output["attention_mask"] = attention_mask
+ output["labels"] = labels
+ if "token_type_ids" in processed_prompts:
+ output["token_type_ids"] = token_type_ids
+ if "mm_token_type_ids" in processed_prompts:
+ output["mm_token_type_ids"] = mm_token_type_ids
+ return output
+
+
+def dft_loss(outputs, labels, num_items_in_batch=None):
+ """
+ DFT loss function, as presented in [On the Generalization of SFT: A Reinforcement Learning Perspective with Reward
+ Rectification](https://huggingface.co/papers/2508.05629)
+ """
+ labels = nn.functional.pad(labels, (0, 1), value=-100)
+ shift_labels = labels[..., 1:]
+ loss_mask = shift_labels != -100
+ shift_labels[~loss_mask] = 0
+ logprobs = selective_log_softmax(outputs.logits, shift_labels)
+ per_token_loss = -logprobs.exp().detach() * logprobs
+ if num_items_in_batch is None:
+ num_items_in_batch = loss_mask.sum()
+ loss = (per_token_loss * loss_mask).sum() / num_items_in_batch
+ return loss
+
+
+class SFTTrainer(_BaseTrainer):
+ """
+ Trainer for Supervised Fine-Tuning (SFT) method.
+
+ This class is a wrapper around the [`~transformers.Trainer`] class and inherits all of its attributes and methods.
+
+ Example:
+
+ ```python
+ 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()
+ ```
+
+ Args:
+ model (`str` or [`~transformers.PreTrainedModel`] or [`~peft.PeftModel`]):
+ Model to be trained. Can be either:
+
+ - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a
+ path to a *directory* containing model weights saved using
+ [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded
+ using `.from_pretrained` (where `` is derived from the model
+ config) with the keyword arguments in `args.model_init_kwargs`.
+ - A [`~transformers.PreTrainedModel`] object. Only causal language models are supported.
+ - A [`~peft.PeftModel`] object. Only causal language models are supported.
+ args ([`SFTConfig`], *optional*):
+ Configuration for this trainer. If `None`, a default configuration is used.
+ data_collator ([`~transformers.DataCollator`], *optional*):
+ Function to use to form a batch from a list of elements of the processed `train_dataset` or `eval_dataset`.
+ Will default to [`~trainer.sft_trainer.DataCollatorForLanguageModeling`] if the model is a language model
+ and [`~trainer.sft_trainer.DataCollatorForVisionLanguageModeling`] if the model is a vision-language model.
+ Custom collators must truncate sequences before padding; the trainer does not apply post-collation
+ truncation.
+ train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]):
+ Dataset to use for training. This trainer supports both [language modeling](#language-modeling) type and
+ [prompt-completion](#prompt-completion) type. The format of the samples can be either:
+
+ - [Standard](dataset_formats#standard): Each sample contains plain text.
+ - [Conversational](dataset_formats#conversational): Each sample contains structured messages (e.g., role
+ and content).
+
+ The trainer also supports processed datasets (tokenized) as long as they contain an `input_ids` field.
+ eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`):
+ Dataset to use for evaluation. It must meet the same requirements as `train_dataset`.
+ processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.ProcessorMixin`], *optional*):
+ Processing class used to process the data. If `None`, the processing class is loaded from the model's name
+ with [`~transformers.AutoProcessor.from_pretrained`]. A padding token, `tokenizer.pad_token`, must be set.
+ If the processing class has not set a padding token, `tokenizer.eos_token` will be used as the default.
+ compute_loss_func (`Callable`, *optional*):
+ A function that accepts the raw model outputs, labels, and the number of items in the entire accumulated
+ batch (batch_size * gradient_accumulation_steps) and returns the loss. For example, see the default [loss
+ function](https://github.com/huggingface/transformers/blob/052e652d6d53c2b26ffde87e039b723949a53493/src/transformers/trainer.py#L3618)
+ used by [`Trainer`].
+ compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*):
+ The function that will be used to compute metrics at evaluation. Must take a
+ [`~transformers.EvalPrediction`] and return a dictionary string to metric values. When passing
+ [`SFTConfig`] with `batch_eval_metrics` set to `True`, your `compute_metrics` function must take a boolean
+ `compute_result` argument. This will be triggered after the last eval batch to signal that the function
+ needs to calculate and return the global summary statistics rather than accumulating the batch-level
+ statistics.
+ callbacks (list of [`~transformers.TrainerCallback`], *optional*):
+ List of callbacks to customize the training loop. Will add those to the list of default callbacks detailed
+ in [here](https://huggingface.co/docs/transformers/main_classes/callback).
+
+ If you want to remove one of the default callbacks used, use the [`~transformers.Trainer.remove_callback`]
+ method.
+ optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *optional*, defaults to `(None, None)`):
+ A tuple containing the optimizer and the scheduler to use. Will default to an instance of `AdamW` on your
+ model and a scheduler given by [`~transformers.get_linear_schedule_with_warmup`] controlled by `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.
+
+ Unlike `optimizers`, this argument avoids the need to place model parameters on the correct devices before
+ initializing the Trainer.
+ preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`, *optional*):
+ A function that preprocess the logits right before caching them at each evaluation step. Must take two
+ tensors, the logits and the labels, and return the logits once processed as desired. The modifications made
+ by this function will be reflected in the predictions received by `compute_metrics`.
+
+ Note that the labels (second parameter) will be `None` if the dataset does not have them.
+ peft_config ([`~peft.PeftConfig`], *optional*):
+ PEFT configuration used to wrap the model. If `None`, the model is not wrapped.
+ formatting_func (`Callable`, *optional*):
+ Formatting function applied to the dataset before tokenization. Applying the formatting function explicitly
+ converts the dataset into a [language modeling](#language-modeling) type.
+ """
+
+ _tag_names = ["trl", "sft"]
+ _name = "SFT"
+
+ def __init__(
+ self,
+ model: "str | PreTrainedModel | PeftModel",
+ args: SFTConfig | TrainingArguments | None = None,
+ data_collator: DataCollator | None = None,
+ train_dataset: Dataset | IterableDataset | None = None,
+ eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None,
+ processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None,
+ compute_loss_func: Callable | None = None,
+ compute_metrics: Callable[[EvalPrediction], dict] | None = None,
+ callbacks: list[TrainerCallback] | None = None,
+ optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None),
+ optimizer_cls_and_kwargs: tuple[type[torch.optim.Optimizer], dict[str, Any]] | None = None,
+ preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None,
+ peft_config: "PeftConfig | None" = None,
+ formatting_func: Callable[[dict], str] | None = None,
+ ):
+ # Args
+ if args is None:
+ model_name = model if isinstance(model, str) else get_config_model_id(model.config)
+ model_name = model_name.split("/")[-1]
+ args = SFTConfig(f"{model_name}-SFT")
+ elif isinstance(args, TrainingArguments) and not isinstance(args, SFTConfig):
+ dict_args = args.to_dict()
+ dict_args["hub_token"] = args.hub_token # to_dict hides the hub_token
+ if Version(transformers.__version__) < Version("5.0.0"):
+ dict_args.pop("push_to_hub_token")
+ args = SFTConfig(**dict_args)
+
+ if train_dataset is None:
+ raise ValueError("`train_dataset` is required")
+ elif isinstance(train_dataset, IterableDataset):
+ # IterableDataset requires dispatch_batches=False because Accelerate's dispatch mode may try to concatenate
+ # batches from multiple processes, leading to mismatch errors.
+ if args.accelerator_config.dispatch_batches is True:
+ logger.warning(
+ "You are using an `IterableDataset` for training with `dispatch_batches=True`. `dispatch_batches` "
+ "is forced to `False` when using an `IterableDataset`. To remove this warning, unset "
+ "`dispatch_batches` in `SFTConfig` or set it to `False`."
+ )
+ args.accelerator_config.dispatch_batches = False
+
+ # Model
+ if isinstance(model, str):
+ model_init_kwargs = args.model_init_kwargs or {}
+ # Distributed training requires device_map=None ("auto" fails)
+ if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]:
+ model_init_kwargs["device_map"] = None
+ model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code)
+ model = create_model_from_path(model, **model_init_kwargs)
+ else:
+ if args.model_init_kwargs is not None:
+ logger.warning(
+ "You passed `model_init_kwargs` to the `SFTConfig`, but your model is already instantiated. "
+ "The `model_init_kwargs` will be ignored."
+ )
+ # Non-quantized models do not have the `is_loaded_in_{8,4}bit` attributes, whereas quantized models do
+ _is_quantized_model = getattr(model, "is_loaded_in_4bit", False) or getattr(model, "is_loaded_in_8bit", False)
+
+ # Processing class
+ if processing_class is None:
+ processing_class = AutoProcessor.from_pretrained(
+ get_config_model_id(model.config), trust_remote_code=args.trust_remote_code
+ )
+
+ # Handle pad token for processors or tokenizers
+ if isinstance(processing_class, ProcessorMixin):
+ self._tokenizer = processing_class.tokenizer
+ self._is_vlm = True
+ elif isinstance(processing_class, PreTrainedTokenizerBase):
+ self._tokenizer = processing_class
+ self._is_vlm = False
+ else:
+ raise TypeError("The `processing_class` must be either a `PreTrainedTokenizerBase` or a `ProcessorMixin`")
+
+ if args.eos_token is not None:
+ if args.eos_token not in self._tokenizer.get_vocab():
+ raise ValueError(
+ f"The specified `eos_token` ('{args.eos_token}') is not found in the vocabulary of the given "
+ f"`processing_class` ({processing_class.__class__.__name__}). Ensure that the `eos_token` exists "
+ "in the vocabulary before using it as an EOS token."
+ )
+ self._tokenizer.eos_token = args.eos_token
+
+ if args.chat_template_path is not None:
+ if os.path.isfile(args.chat_template_path) and args.chat_template_path.endswith((".jinja", ".j2")):
+ with open(args.chat_template_path, encoding="utf-8") as chat_template_file:
+ processing_class.chat_template = chat_template_file.read()
+ added_tokens = []
+ else:
+ model, processing_class, added_tokens = clone_chat_template(
+ model, processing_class, args.chat_template_path
+ )
+ else:
+ added_tokens = []
+
+ # Catch some wrong configurations related to VLMs
+ if self._is_vlm and args.packing:
+ raise ValueError(
+ "Packing is not supported for vision-language models. Please set `packing=False` in the SFTConfig."
+ )
+ if self._is_vlm and args.padding_free:
+ raise ValueError(
+ "Padding-free training is yet not supported for vision-language models. Please set "
+ "`padding_free=False` in the `SFTConfig`."
+ )
+ if self._is_vlm and args.assistant_only_loss:
+ raise ValueError(
+ "Assistant-only loss is not yet supported for vision-language models. Please set "
+ "`assistant_only_loss=False` in the `SFTConfig`."
+ )
+ if self._is_vlm and args.max_length is not None and args.truncation_mode == "keep_end":
+ raise ValueError(
+ "truncation_mode='keep_end' is not supported for vision-language models. Image tokens reside "
+ "inside the prompt portion of the sequence; depending on the example, keep_end may silently "
+ "drop them, causing pixel_values to be forwarded to the model with no corresponding visual "
+ "tokens in input_ids. Use truncation_mode='keep_start' (the default) or set max_length=None."
+ )
+
+ # PEFT
+ if peft_config is not None:
+ if not is_peft_available():
+ raise ImportError(
+ "You passed `peft_config` but the `peft` library is not installed. "
+ "Install it with `pip install trl[peft]`."
+ )
+ if not isinstance(peft_config, PeftConfig):
+ raise TypeError(
+ f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), "
+ f"got {type(peft_config).__name__}."
+ )
+ if is_peft_model(model):
+ raise ValueError(
+ "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first merge "
+ "and unload the existing adapter, save the resulting base model, and then pass that base model along "
+ "with the new `peft_config` to the trainer."
+ )
+ if added_tokens:
+ # Ensure that the added tokens are trainable
+ if peft_config.trainable_token_indices is None:
+ peft_config.trainable_token_indices = {"embed_tokens": added_tokens}
+ elif "embed_tokens" not in peft_config.trainable_token_indices:
+ peft_config.trainable_token_indices["embed_tokens"] = added_tokens
+ else:
+ peft_config.trainable_token_indices["embed_tokens"].extend(added_tokens)
+ # Ensure that the lm_head is trainable
+ if peft_config.modules_to_save is None or "lm_head" not in peft_config.modules_to_save:
+ logger.warning(
+ "Cloning chat template added new tokens to the tokenizer, but 'lm_head' is not in PEFT's "
+ "`modules_to_save`. As a result, the model may not learn to generate outputs with these new "
+ "tokens, leading to degraded generation quality. To fix this, add "
+ "`modules_to_save=['lm_head']` to your PEFT configuration."
+ )
+
+ if peft_config.modules_to_save is None:
+ peft_config.modules_to_save = ["lm_head"]
+ else:
+ peft_config.modules_to_save.append("lm_head")
+ # Create PEFT model
+ # ZeRO-3 + PEFT for non-quantized models:
+ # - PEFT's default autocast_adapter_dtype=True upcasts LoRA adapter params to fp32 even when the base model is bf16.
+ # - ZeRO-3's _allgather_params_coalesced allocates output buffers using the dtype of the first persistent parameter,
+ # so mixed-dtype persistent_parameters (bf16 base + fp32 LoRA) cause a TypeError on the first optimizer step.
+ # - Passing autocast_adapter_dtype=False keeps adapter params in the base model dtype (bf16), fixing the mismatch.
+ # - This is safe: the fp32 upcast is a QLoRA-specific concern (low-bit quantized base models), not needed for
+ # non-quantized bf16 training.
+ # - See:
+ # - TRL issue: https://github.com/huggingface/trl/issues/6089
+ # - Upstream issue: https://github.com/deepspeedai/DeepSpeed/issues/8072
+ # - autocast_adapter_dtype was introduced in PEFT 0.12.0; before, no upcast existed: no need to pass the kwarg
+ get_peft_model_kwargs = {}
+ if (
+ args.deepspeed_plugin is not None
+ and args.deepspeed_plugin.zero_stage == 3
+ and not _is_quantized_model
+ and Version(peft.__version__) >= Version("0.12.0")
+ ):
+ get_peft_model_kwargs["autocast_adapter_dtype"] = False
+ model = get_peft_model(model, peft_config, **get_peft_model_kwargs)
+
+ # PEFT + DeepSpeed ZeRO-3 requires reentrant checkpointing. For more details, see
+ # https://github.com/huggingface/trl/issues/2514#issuecomment-2692152703
+ if (
+ is_peft_model(model)
+ and args.deepspeed_plugin is not None
+ and args.deepspeed_plugin.zero_stage == 3
+ and args.gradient_checkpointing
+ ):
+ args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {}
+ use_reentrant = args.gradient_checkpointing_kwargs.get("use_reentrant")
+ if use_reentrant is False:
+ logger.warning(
+ "You are using PEFT with DeepSpeed ZeRO-3 and gradient checkpointing with `use_reentrant=False`. "
+ "`use_reentrant` is forced to `True` in this configuration to ensure correct training. To remove "
+ "this warning, unset `use_reentrant` in `gradient_checkpointing_kwargs` or set it to `True`."
+ )
+ args.gradient_checkpointing_kwargs["use_reentrant"] = True
+
+ # When using gradient checkpointing with PEFT, we need to enable input gradients. transformers.Trainer normally
+ # handles this, but a bug currently prevents it; see https://github.com/huggingface/transformers/issues/42489
+ if is_peft_model(model) and args.gradient_checkpointing:
+ model.enable_input_require_grads()
+
+ # When using QLoRA, the PEFT adapter weights are converted to bf16 to follow the recommendations from the
+ # original paper (see https://huggingface.co/papers/2305.14314, paragraph 3). Normally, this can be done by
+ # passing `autocast_adapter_dtype=False` to `get_peft_model`, but this option is not yet supported for
+ # quantized models. See: https://github.com/huggingface/peft/issues/2889
+ if _is_quantized_model:
+ for param in model.parameters():
+ if param.requires_grad:
+ param.data = param.data.to(torch.bfloat16)
+
+ # In Prompt Tuning a small set of trainable virtual tokens (continuous prompt embeddings) is prepended to the
+ # input. We store the number of these tokens so we can account for them correctly when calculating accuracy.
+ self.num_virtual_tokens = 0
+ if is_peft_model(model):
+ if model.active_adapter in model.peft_config:
+ peft_model_config = model.peft_config[model.active_adapter]
+ self.num_virtual_tokens = getattr(peft_model_config, "num_virtual_tokens", 0)
+
+ # Data collator
+ # BFD packing requires padding-free mode; otherwise, the collator outputs padded attention masks, causing
+ # FlashAttention to ignore position_ids and recompute them incorrectly from the padded attention mask.
+ self.padding_free = args.padding_free or (args.packing and args.packing_strategy in {"bfd", "bfd_split"})
+ use_flash_attention = model.config._attn_implementation in FLASH_ATTENTION_VARIANTS
+ if self.padding_free:
+ if data_collator is not None:
+ raise ValueError("Passing a custom data collator is not supported when using padding-free.")
+ if args.packing and args.packing_strategy == "wrapped":
+ logger.warning(
+ "You are passing `padding_free=True` with the 'wrapped' packing strategy, which is not "
+ "recommended. Please refer to the documentation to understand why this is not recommended."
+ )
+ if not use_flash_attention:
+ logger.warning(
+ "Padding-free training is enabled, but the attention implementation is not set to a supported "
+ "Flash Attention variant. Padding-free training flattens batches into a single sequence, and only "
+ "the following implementations are known to reliably support this: "
+ f"{', '.join(sorted(FLASH_ATTENTION_VARIANTS))}. Using other implementations may lead to "
+ "unexpected behavior. To ensure compatibility, set `attn_implementation` in the model "
+ "configuration to one of these supported options or verify that your attention mechanism can "
+ "handle flattened sequences."
+ )
+
+ if args.per_device_train_batch_size == 1 and not args.packing:
+ logger.warning(
+ "You are using a per_device_train_batch_size of 1 with padding-free training. Using a batch size "
+ "of 1 annihilate the benefits of padding-free training. Please consider increasing the batch size "
+ "to at least 2."
+ )
+
+ # Decide whether to use completion-only loss: if not specified, then it is set to True if the dataset format
+ # is prompt-completion, and False if the dataset format is language modeling.
+ dataset_sample = next(iter(train_dataset))
+ if args.completion_only_loss is None:
+ self.completion_only_loss = "prompt" in dataset_sample and "completion" in dataset_sample
+ else:
+ self.completion_only_loss = args.completion_only_loss
+
+ self._is_vision_dataset = "image" in dataset_sample or "images" in dataset_sample
+ if self._is_vision_dataset and not self._is_vlm:
+ raise ValueError(
+ "The dataset appears to be vision-related (contains 'image' or 'images' keys), but the provided "
+ "model does not seem to be a vision-language model. Please check your model and dataset."
+ )
+
+ if data_collator is None and not self._is_vision_dataset:
+ # Get the pad token: if not provided, use the one from the processing class or the eos token
+ # if the processing class does not have a pad token.
+ pad_token = args.pad_token or self._tokenizer.pad_token or self._tokenizer.eos_token
+ if pad_token not in self._tokenizer.get_vocab():
+ raise ValueError(
+ f"The specified `pad_token` ('{pad_token}') is not found in the vocabulary of the given "
+ f"`processing_class` ({processing_class.__class__.__name__}). Ensure that the `pad_token` exists "
+ "in the vocabulary before using it as a padding token."
+ )
+ self._tokenizer.pad_token = pad_token
+ data_collator = DataCollatorForLanguageModeling(
+ pad_token_id=self._tokenizer.pad_token_id,
+ max_length=None if self.padding_free else args.max_length,
+ truncation_mode=args.truncation_mode,
+ padding_free=self.padding_free,
+ pad_to_multiple_of=args.pad_to_multiple_of,
+ )
+ elif data_collator is None and self._is_vision_dataset:
+ data_collator = DataCollatorForVisionLanguageModeling(
+ processor=processing_class,
+ max_length=args.max_length,
+ completion_only_loss=self.completion_only_loss,
+ pad_to_multiple_of=args.pad_to_multiple_of,
+ dataset_text_field=args.dataset_text_field,
+ )
+
+ if args.packing and args.packing_strategy in {"bfd", "bfd_split"} and not use_flash_attention:
+ logger.warning(
+ "You are using packing, but the attention implementation is not set to a supported Flash Attention "
+ "variant. Packing gathers multiple samples into a single sequence, and only the following "
+ f"implementations are known to reliably support this: {', '.join(sorted(FLASH_ATTENTION_VARIANTS))}. "
+ "Using other implementations may lead to cross-contamination between samples. To avoid this, either "
+ "disable packing by setting `packing=False`, or set `attn_implementation` in the model configuration "
+ "to one of these supported options."
+ )
+ if args.assistant_only_loss and not is_conversational(dataset_sample):
+ raise ValueError(
+ "You set `assistant_only_loss=True`, but the dataset is not conversational. This option is only "
+ "supported for conversational datasets."
+ )
+
+ # When assistant_only_loss is enabled, swap in a training chat template with {% generation %} markers
+ # if the current template doesn't already have them.
+ if args.assistant_only_loss and not has_generation_markers(processing_class.chat_template):
+ self.chat_template = get_training_chat_template(processing_class)
+ else:
+ self.chat_template = None
+
+ # A template can define generation markers and still attribute the assistant's end-of-turn token to the next
+ # message, leaving it out of the assistant mask so the model is never trained to stop.
+ if args.assistant_only_loss and not is_chat_template_stop_token_trained(
+ processing_class, chat_template=self.chat_template
+ ):
+ logger.warning(
+ "The chat template does not include the assistant turn's end-of-turn token in the loss mask; "
+ "the model may not learn to stop."
+ )
+
+ # Dataset
+ if self.padding_free and not args.packing and args.max_length is not None and not self._is_vision_dataset:
+ raise ValueError(
+ "When `padding_free=True` without packing, `max_length` is not enforced. Either enable packing "
+ "(e.g., `packing=True, packing_strategy='bfd'`), provide already truncated inputs, or set "
+ "`max_length=None`."
+ )
+ # Skip dataset preparation if `skip_prepare_dataset=True` in `dataset_kwargs`, or if it's a VLM, where
+ # preprocessing (e.g., image-to-pixel conversion) is too costly and done on the fly instead.
+ self._skip_prepare_dataset = (
+ args.dataset_kwargs is not None
+ and args.dataset_kwargs.get("skip_prepare_dataset", False)
+ or self._is_vision_dataset
+ )
+ # Kept on the instance so that `evaluate` can preprocess freshly-passed eval datasets the same way.
+ self._formatting_func = formatting_func
+ eval_datasets = (
+ eval_dataset if isinstance(eval_dataset, dict) else {"eval": eval_dataset} if eval_dataset else {}
+ )
+ self._reject_skip_prepare_without_labels({"train": train_dataset, **eval_datasets}, data_collator)
+ if not self._skip_prepare_dataset:
+ if self.completion_only_loss and formatting_func:
+ raise ValueError(
+ "A formatting function was provided while `completion_only_loss=True`, which is incompatible. "
+ "Using a formatter converts the dataset to a language modeling type, conflicting with "
+ "completion-only loss. To resolve this, apply your formatting function before passing the "
+ "dataset, or disable `completion_only_loss` in `SFTConfig`."
+ )
+ train_dataset = self._prepare_dataset(
+ train_dataset, processing_class, args, args.packing, formatting_func, "train"
+ )
+ if eval_dataset is not None:
+ packing = args.packing if args.eval_packing is None else args.eval_packing
+ if isinstance(eval_dataset, dict):
+ eval_dataset = {
+ key: self._prepare_dataset(dataset, processing_class, args, packing, formatting_func, key)
+ for key, dataset in eval_dataset.items()
+ }
+ else:
+ eval_dataset = self._prepare_dataset(
+ eval_dataset, processing_class, args, packing, formatting_func, "eval"
+ )
+
+ # Loss function
+ if not args.use_liger_kernel: # liger supports dft loss by just passing use_token_scaling=True
+ if args.loss_type == "nll":
+ pass # use the default loss
+ elif args.loss_type == "dft":
+ if compute_loss_func is not None:
+ raise ValueError(
+ "You passed a `compute_loss_func` together with `loss_type='dft'` to the `SFTTrainer`. "
+ "When using `loss_type='dft'`, the loss function is internally set to the DFT loss, so "
+ "passing a `compute_loss_func` is not allowed."
+ )
+ compute_loss_func = dft_loss
+ elif args.loss_type == "chunked_nll":
+ # Same math as `"nll"` but the `lm_head` matmul is skipped on ignored tokens and the CE is computed in
+ # chunks of tokens. Implemented by patching the model's forward before `super().__init__` so accelerate
+ # wraps the patched forward.
+ # For PEFT, patch the inner causal LM rather than the `PeftModel` wrapper. LoRA / IA³ /
+ # `modules_to_save` adapters live in the module tree, so they're hit even when we bypass
+ # `PeftModel.forward`. Prompt-learning variants need `PeftModel.forward` to run first (to inject
+ # virtual tokens), then it delegates into the patched inner forward.
+ target = model.get_base_model() if is_peft_model(model) else model
+ # The chunked path reads the output projection weight directly, which would silently drop the
+ # adapter delta (and starve its parameters of gradients) if the head itself is a PEFT tuner layer.
+ if is_peft_model(model):
+ from peft.tuners.tuners_utils import BaseTunerLayer
+
+ if isinstance(target.get_output_embeddings(), BaseTunerLayer):
+ raise ValueError(
+ "`loss_type='chunked_nll'` is not supported when `lm_head` is wrapped by a PEFT adapter "
+ "(e.g. `target_modules='all-linear'` or explicitly including `'lm_head'`). Either remove "
+ "`lm_head` from `target_modules`, or switch to `loss_type='nll'`. If this is a real use "
+ "case for you, please open an issue at https://github.com/huggingface/trl/issues."
+ )
+ _patch_chunked_ce_lm_head(target, chunk_size=_CHUNKED_LM_HEAD_CHUNK_SIZE, is_vlm=self._is_vlm)
+ else:
+ raise ValueError(
+ f"Invalid `loss_type` {args.loss_type} passed. Supported values are 'nll', 'dft', and "
+ "'chunked_nll'."
+ )
+ elif args.loss_type == "chunked_nll":
+ raise ValueError("`loss_type='chunked_nll'` is not compatible with `use_liger_kernel=True`.")
+
+ # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was
+ # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream
+ # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we
+ # default to the recommended non-reentrant behavior here, while preserving any user-provided value.
+ if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"):
+ args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {}
+ args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False)
+
+ super().__init__(
+ model=model,
+ args=args,
+ data_collator=data_collator,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=processing_class,
+ compute_loss_func=compute_loss_func,
+ compute_metrics=compute_metrics,
+ callbacks=callbacks,
+ optimizers=optimizers,
+ optimizer_cls_and_kwargs=optimizer_cls_and_kwargs,
+ preprocess_logits_for_metrics=preprocess_logits_for_metrics,
+ )
+
+ # Initialize activation offloading context
+ if self.args.activation_offloading:
+ self.maybe_activation_offload_context = get_act_offloading_ctx_manager(model=self.model)
+ else:
+ self.maybe_activation_offload_context = contextlib.nullcontext()
+
+ # MoE load-balancing auxiliary loss, applied to Mixture-of-Experts models (no effect otherwise)
+ text_config = model.config.get_text_config()
+ is_moe = getattr(text_config, "output_router_logits", None) is not None
+ self.aux_loss_enabled = is_moe and self.args.router_aux_loss_coef != 0.0
+ if is_moe:
+ # The native and chunked forwards add the aux loss from the model config, so keep the config in sync with
+ # the coef: enable it (and propagate the coef) when non-zero, disable it otherwise. This overrides any
+ # `output_router_logits` the model was loaded with, so `router_aux_loss_coef=0.0` reliably turns it off.
+ text_config.output_router_logits = self.aux_loss_enabled
+ text_config.router_aux_loss_coef = self.args.router_aux_loss_coef
+
+ # Initialize the metrics
+ self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)}
+ self._total_train_tokens = 0
+
+ # Add tags to the model
+ self.model.add_model_tags(self._tag_names)
+
+ def _tokenize(
+ self,
+ processing_class: PreTrainedTokenizerBase | ProcessorMixin,
+ input: str | list,
+ **kwargs,
+ ) -> dict[str, list]:
+ """Tokenize a single example for dataset preprocessing.
+
+ Dispatches to `apply_chat_template` for conversational input (list of message dicts) and to `__call__` for
+ non-conversational input (str). For VLMs, normalizes the batch dimension that processors emit even for single
+ examples.
+
+ Args:
+ processing_class ([`~transformers.PreTrainedTokenizerBase`] or [`~transformers.ProcessorMixin`]):
+ The tokenizer or processor to use.
+ input (`str` or `list`):
+ A string for non-conversational input, or a list of message dicts for conversational input.
+ **kwargs:
+ Forwarded to `apply_chat_template` (e.g. `add_generation_prompt`, `return_assistant_tokens_mask`).
+
+ Returns:
+ `dict` with at least an `"input_ids"` key mapping to a flat `list[int]`.
+ """
+ if isinstance(input, list): # conversational: list of message dicts
+ if self._is_vlm:
+ input = prepare_multimodal_messages(input)
+ result = processing_class.apply_chat_template(
+ input, tokenize=True, return_dict=True, chat_template=self.chat_template, **kwargs
+ )
+ else: # non-conversational: plain text string
+ result = processing_class(text=input)
+ # VLMs emit a batch dimension even for single examples; unwrap it
+ if self._is_vlm:
+ return {k: v[0] for k, v in result.items()}
+ return result
+
+ def _prepare_dataset(
+ self,
+ dataset: Dataset | IterableDataset,
+ processing_class: PreTrainedTokenizerBase | ProcessorMixin,
+ args: SFTConfig,
+ packing: bool,
+ formatting_func: Callable[[dict], str] | None,
+ dataset_name: str,
+ ) -> Dataset | IterableDataset:
+ if isinstance(dataset, Dataset) and dataset.format["type"] == "custom":
+ raise ValueError(
+ "SFTTrainer cannot prepare a dataset that uses `Dataset.with_transform()`. The preparation pipeline "
+ "calls `Dataset.map()`, which reads through the transform and can bake a random or stateful transform "
+ "into the tokenized columns. Pass `dataset_kwargs={'skip_prepare_dataset': True}` and make the "
+ "transform return trainer-ready examples, including tokenized fields, or materialize deterministic "
+ "transforms with `Dataset.map()` before constructing the trainer."
+ )
+
+ # If the dataset is already preprocessed (tokenized), skip the processing steps.
+ column_names = get_dataset_column_names(dataset)
+ is_processed = "input_ids" in column_names
+
+ # Build the kwargs for the `map` function
+ map_kwargs = {}
+ if isinstance(dataset, Dataset): # IterableDataset does not support num_proc
+ map_kwargs["num_proc"] = args.dataset_num_proc
+
+ with PartialState().main_process_first():
+ # Apply the formatting function if any
+ if formatting_func is not None and is_processed:
+ logger.warning(
+ "You passed a dataset that is already processed (contains an `input_ids` field) together with a "
+ "formatting function. Therefore `formatting_func` will be ignored. Either remove the "
+ "`formatting_func` or pass a dataset that is not already processed.",
+ )
+
+ if formatting_func is not None and not is_processed:
+ if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc`
+ map_kwargs["desc"] = f"Applying formatting function to {dataset_name} dataset"
+
+ def _func(example):
+ return {"text": formatting_func(example)}
+
+ dataset = dataset.map(_func, batched=False, **map_kwargs)
+
+ if not is_processed:
+ # Convert the dataset to ChatML if needed
+ first_example = next(iter(dataset))
+ if is_conversational_from_value(first_example):
+ if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc`
+ map_kwargs["desc"] = f"Converting {dataset_name} dataset to ChatML"
+ column_names = get_dataset_column_names(dataset)
+ dataset = dataset.map(
+ maybe_convert_to_chatml,
+ remove_columns="conversations" if "conversations" in column_names else None,
+ **map_kwargs,
+ )
+
+ # Add EOS token if needed: non-conversational only
+ first_example = next(iter(dataset))
+ if not is_conversational(first_example):
+ if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc`
+ map_kwargs["desc"] = f"Adding EOS to {dataset_name} dataset"
+
+ def add_eos(example, eos_token):
+ if "text" in example and not example["text"].endswith(eos_token): # language modeling case
+ example["text"] = example["text"] + eos_token
+ elif "completion" in example and not example["completion"].endswith(eos_token):
+ example["completion"] = example["completion"] + eos_token
+ return example
+
+ dataset = dataset.map(
+ add_eos,
+ fn_kwargs={"eos_token": self._tokenizer.eos_token},
+ remove_columns="messages" if "messages" in column_names else None, # renamed to "text"
+ **map_kwargs,
+ )
+
+ # Tokenize the dataset
+ if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc`
+ map_kwargs["desc"] = f"Tokenizing {dataset_name} dataset"
+
+ def tokenize_fn(example, processing_class, dataset_text_field, assistant_only_loss):
+ tools = example.get("tools")
+ tools = json.loads(tools) if isinstance(tools, str) else tools
+ if "prompt" in example: # prompt-completion case
+ output = {}
+ if is_conversational(example):
+ prompt_ids = self._tokenize(
+ processing_class,
+ example["prompt"],
+ tools=tools,
+ add_generation_prompt=True,
+ **example.get("chat_template_kwargs", {}),
+ )["input_ids"]
+ prompt_completion_processed = self._tokenize(
+ processing_class,
+ example["prompt"] + example["completion"],
+ tools=tools,
+ return_assistant_tokens_mask=assistant_only_loss,
+ **example.get("chat_template_kwargs", {}),
+ )
+ prompt_completion_ids = prompt_completion_processed["input_ids"]
+ if "assistant_masks" in prompt_completion_processed:
+ output["assistant_masks"] = prompt_completion_processed["assistant_masks"]
+ else:
+ prompt_ids = self._tokenize(processing_class, example["prompt"])["input_ids"]
+ prompt_completion_ids = self._tokenize(
+ processing_class, example["prompt"] + example["completion"]
+ )["input_ids"]
+
+ # Check if the tokenized prompt starts with the tokenized prompt+completion
+ if not prompt_completion_ids[: len(prompt_ids)] == prompt_ids:
+ logger.warning(
+ "Mismatch between tokenized prompt and the start of tokenized prompt+completion. "
+ "This may be due to unexpected tokenizer behavior, whitespace issues, or special "
+ "token handling. Verify that the tokenizer is processing text consistently."
+ )
+
+ # Create completion mask
+ completion_mask = [0] * len(prompt_ids) + [1] * (len(prompt_completion_ids) - len(prompt_ids))
+ output["input_ids"] = prompt_completion_ids
+ output["completion_mask"] = completion_mask
+
+ else: # language modeling case
+ if is_conversational(example):
+ processed = self._tokenize(
+ processing_class,
+ example["messages"],
+ tools=tools,
+ return_assistant_tokens_mask=assistant_only_loss,
+ **example.get("chat_template_kwargs", {}),
+ )
+ output = {k: processed[k] for k in ("input_ids", "assistant_masks") if k in processed}
+ else:
+ output = {
+ "input_ids": self._tokenize(processing_class, example[dataset_text_field])["input_ids"]
+ }
+
+ if "assistant_masks" in output and 1 not in output["assistant_masks"]:
+ raise RuntimeError(
+ "You're using `assistant_only_loss=True`, but at least one example has no assistant "
+ "tokens. This usually means the tokenizer's chat template doesn't generate assistant "
+ "masks — it may be missing the `{% generation %}` keyword. Please check the template and "
+ "ensure it's correctly configured to support assistant masking."
+ )
+ return output
+
+ dataset = dataset.map(
+ tokenize_fn,
+ fn_kwargs={
+ "processing_class": processing_class,
+ "dataset_text_field": args.dataset_text_field,
+ "assistant_only_loss": args.assistant_only_loss,
+ },
+ **map_kwargs,
+ )
+
+ # Build a "labels" column, setting tokens that shouldn't contribute to the loss to -100 based on the
+ # available masks: "assistant_masks" always applies, "completion_mask" only when completion_only_loss
+ # is enabled. With no applicable mask, every token contributes (labels == input_ids). A dataset that
+ # already provides a "labels" column is left as is.
+ column_names = get_dataset_column_names(dataset)
+ if "labels" not in column_names:
+ mask_columns = []
+ if self.completion_only_loss and "completion_mask" in column_names:
+ mask_columns.append("completion_mask")
+ if "assistant_masks" in column_names:
+ mask_columns.append("assistant_masks")
+ if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc`
+ map_kwargs["desc"] = f"Building labels for {dataset_name} dataset"
+
+ def build_labels(example, mask_columns):
+ masks = [example[column] for column in mask_columns]
+ labels = [
+ token_id if all(bits) else -100
+ for token_id, *bits in zip(example["input_ids"], *masks, strict=False)
+ ]
+ return {"labels": labels}
+
+ dataset = dataset.map(build_labels, fn_kwargs={"mask_columns": mask_columns}, **map_kwargs)
+
+ # Pack
+ if packing:
+ if args.max_length is None:
+ raise ValueError("When packing is enabled, `max_length` can't be `None`.")
+ if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc`
+ map_kwargs["desc"] = f"Packing {dataset_name} dataset"
+
+ dataset = dataset.select_columns(["input_ids", "labels"])
+
+ # Shuffle the dataset before packing. When using wrapped packing, it's important to shuffle before
+ # packing as well to avoid correlations between sequences packed together.
+ if args.shuffle_dataset:
+ dataset = dataset.shuffle(seed=args.seed)
+
+ # Packing adds new column "seq_lengths" needed for document aware FlashAttention
+ dataset = pack_dataset(dataset, args.max_length, args.packing_strategy, map_kwargs)
+ # For Liger kernel, ensure only the essential columns
+ if args.use_liger_kernel:
+ collator_expected_keys = {"input_ids", "seq_lengths", "labels"}
+ column_names = get_dataset_column_names(dataset)
+ dataset = dataset.select_columns(collator_expected_keys.intersection(column_names))
+
+ if args.shuffle_dataset:
+ dataset = dataset.shuffle(seed=args.seed)
+
+ return dataset
+
+ def _set_signature_columns_if_needed(self):
+ # If `self.args.remove_unused_columns` is True, non-signature columns are removed.
+ # By default, this method sets `self._signature_columns` to the model's expected inputs (usually, "input_ids",
+ # "attention_mask" and "labels"). Dataset preparation also produces a "seq_lengths" column (for packing /
+ # padding-free), so we override the default signature columns to keep it alongside the model inputs.
+ if self._signature_columns is None:
+ if self._is_vision_dataset:
+ self._signature_columns = ["messages", "prompt", "completion", "image", "images"]
+ else:
+ self._signature_columns = ["input_ids", "labels", "seq_lengths"]
+
+ def _reject_skip_prepare_without_labels(self, datasets: dict[str, Dataset], data_collator) -> None:
+ # This guard may look defensive, but it covers a behavior change introduced when label building moved from
+ # the collator to dataset preparation: the collator used to consume the mask columns directly, so a
+ # skipped-preparation dataset carrying masks trained correctly. Now labels are built during preparation, which
+ # is skipped here, and the collator ignores the mask columns. Without a "labels" column, such a dataset would
+ # silently optimize the loss over the full sequence, so we fail loudly instead. Checked both at init and in
+ # `evaluate`, since a dataset passed directly to `evaluate` also skips preparation.
+ if not (
+ self._skip_prepare_dataset
+ and not self._is_vision_dataset
+ and isinstance(data_collator, DataCollatorForLanguageModeling)
+ ):
+ return
+ for name, dataset in datasets.items():
+ cols = get_dataset_column_names(dataset)
+ if "labels" not in cols and ("completion_mask" in cols or "assistant_masks" in cols):
+ raise ValueError(
+ f"The {name} dataset has mask columns but no 'labels', and `skip_prepare_dataset=True` skips "
+ "label building, so it would train on the full sequence. Add a 'labels' column (-100 for "
+ "non-loss tokens) or drop `skip_prepare_dataset`."
+ )
+
+ def evaluate(
+ self,
+ eval_dataset: Dataset | dict[str, Dataset] | None = None,
+ ignore_keys: list[str] | None = None,
+ metric_key_prefix: str = "eval",
+ ) -> dict[str, float]:
+ # When a dataset is passed directly to `evaluate` (e.g. a held-out test set), preprocess it the same way
+ # `__init__` does, so that `evaluate` accepts the same dataset types as the trainer (language modeling,
+ # prompt-completion, etc.). `_prepare_dataset` is idempotent: it skips datasets that are already tokenized. A
+ # `str` selects a dataset that was already prepared at init time, so it's left untouched.
+ if not self._skip_prepare_dataset and eval_dataset is not None and not isinstance(eval_dataset, str):
+ packing = self.args.packing if self.args.eval_packing is None else self.args.eval_packing
+ if isinstance(eval_dataset, dict):
+ eval_dataset = {
+ key: self._prepare_dataset(
+ dataset, self.processing_class, self.args, packing, self._formatting_func, key
+ )
+ for key, dataset in eval_dataset.items()
+ }
+ else:
+ eval_dataset = self._prepare_dataset(
+ eval_dataset, self.processing_class, self.args, packing, self._formatting_func, "eval"
+ )
+ eval_datasets = (
+ eval_dataset
+ if isinstance(eval_dataset, dict)
+ else {"eval": eval_dataset}
+ if eval_dataset is not None and not isinstance(eval_dataset, str)
+ else {}
+ )
+ self._reject_skip_prepare_without_labels(eval_datasets, self.data_collator)
+ return super().evaluate(
+ eval_dataset=eval_dataset, ignore_keys=ignore_keys, metric_key_prefix=metric_key_prefix
+ )
+
+ def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
+ mode = "train" if self.model.training else "eval"
+ prediction_loss_only = inputs.pop("_prediction_loss_only", None)
+
+ # Set aside labels as it will be dropped by super().compute_loss() if a custom `compute_loss_func` is used.
+ # This can be removed when this issue is fixed.
+ # When using CP or SP, labels are pre-shifted, we must use shift_labels instead.
+ labels = inputs["labels"] if "shift_labels" not in inputs else None
+
+ # If not set, defaults from model config and may warn since cache isn't compatible with gradient checkpointing
+ inputs["use_cache"] = False
+
+ # MoE models: request router logits so the model returns `outputs.aux_loss`. VLM wrappers honor this only
+ # as a forward kwarg (not from the model config), so it must be passed here.
+ if self.aux_loss_enabled:
+ inputs["output_router_logits"] = True
+
+ # Request token accuracy from Liger kernel and set token scaling if using DFT loss
+ if self.args.use_liger_kernel:
+ # Avoid materializing full logits during eval unless explicitly needed.
+ # By default, liger kernel only skips logits during training (self.training=True).
+ # When only loss is needed for eval (no compute_metrics), we can safely skip logits.
+ # prediction_step communicates whether logits are expected via `_prediction_loss_only`;
+ # this prevents skipping logits during `predict()` where outputs are requested.
+ # Keep logits when preprocess_logits_for_metrics is set, even if compute_metrics is None.
+ # to prevent massive vRAM spikes from the lm_head projection.
+ # See: https://github.com/huggingface/trl/issues/4679
+ inputs["skip_logits"] = (
+ self.model.training
+ or self.args.prediction_loss_only
+ or (
+ self.compute_metrics is None
+ and self.preprocess_logits_for_metrics is None
+ and prediction_loss_only is not False
+ )
+ )
+ inputs["return_token_accuracy"] = True
+ inputs["use_token_scaling"] = self.args.loss_type == "dft"
+
+ try:
+ (loss, outputs) = super().compute_loss(
+ model, inputs, return_outputs=True, num_items_in_batch=num_items_in_batch
+ )
+ except ValueError as e:
+ if "Image features and image tokens do not match" in str(e) and self.args.max_length is not None:
+ raise ValueError(
+ f"The current `max_length` ({self.args.max_length}) is too short and causes image placeholder "
+ f"tokens in `input_ids` to be truncated, while the corresponding image features remain intact. "
+ f"Please increase `max_length` or set it to `None` to disable truncation."
+ ) from e
+ raise
+
+ # Compute entropy
+ if self.args.loss_type == "chunked_nll":
+ # Use `num_valid_tokens` from the patched forward rather than recomputing from `labels`. Prompt-learning
+ # PEFT (PromptTuning, P-Tuning) prepends `-100`-padded virtual tokens before delegating into the patched
+ # forward, so the valid-token count over the padded labels can differ from the un-padded `labels[..., 1:]`
+ # count by up to one per sequence; using the patched output keeps numerator and denominator aligned.
+ num_valid = self.accelerator.gather_for_metrics(outputs.num_valid_tokens).sum()
+ entropy_sum = self.accelerator.gather_for_metrics(outputs.entropy_sum).sum()
+ entropy = (entropy_sum / num_valid).item() if num_valid > 0 else 0.0
+ self._metrics[mode]["entropy"].append(entropy)
+ elif not self.args.use_liger_kernel: # liger doesn't return logits
+ with torch.no_grad():
+ if "shift_labels" in inputs:
+ # When using CP or SP, labels are pre-shifted.
+ shift_logits = outputs.logits
+ shift_labels = inputs["shift_labels"]
+ else:
+ shift_logits = outputs.logits[..., :-1, :]
+ shift_labels = labels[..., 1:]
+
+ # Prompt Tuning and P-Tuning output logits for virtual tokens but Prefix-Tuning does not.
+ if (
+ self.num_virtual_tokens > 0
+ and model.peft_config[model.active_adapter].peft_type != PeftType.PREFIX_TUNING
+ ):
+ shift_logits = shift_logits[:, self.num_virtual_tokens :, :]
+
+ per_token_entropy = entropy_from_logits(shift_logits)
+ predictions = shift_logits.argmax(dim=-1)
+ mask = shift_labels != -100
+
+ entropy_sum = (per_token_entropy * mask).sum()
+ total_tokens = mask.sum()
+ correct_predictions = (predictions == shift_labels) & mask
+ correct_tokens = correct_predictions.sum()
+
+ # Gather counts across ranks and weight-average
+ entropy_sum = self.accelerator.gather_for_metrics(entropy_sum).sum()
+ total_tokens = self.accelerator.gather_for_metrics(total_tokens).sum()
+ correct_tokens = self.accelerator.gather_for_metrics(correct_tokens)
+ entropy = (entropy_sum / total_tokens).item() if total_tokens > 0 else 0.0
+
+ total_sum = total_tokens.sum()
+ accuracy = (correct_tokens.sum() / total_sum).item() if total_sum > 0 else 0.0
+ self._metrics[mode]["entropy"].append(entropy)
+ self._metrics[mode]["mean_token_accuracy"].append(accuracy)
+
+ if mode == "train":
+ # When using padding-free, the attention_mask is not present in the inputs, instead we have cu_seq_lens_q,
+ # cu_seq_lens_k, and max_length_k, max_length_q and position_ids.
+ if "attention_mask" in inputs:
+ num_tokens_in_batch = self.accelerator.gather_for_metrics(inputs["attention_mask"].sum()).sum().item()
+ elif "position_ids" in inputs:
+ local_num_tokens = torch.tensor(inputs["position_ids"].size(1), device=inputs["position_ids"].device)
+ num_tokens_in_batch = self.accelerator.gather_for_metrics(local_num_tokens).sum().item()
+ else:
+ raise ValueError("Expected 'attention_mask' or 'position_ids' in inputs.")
+ self._total_train_tokens += num_tokens_in_batch
+ self._metrics[mode]["num_tokens"] = [self._total_train_tokens]
+
+ if self.args.loss_type == "chunked_nll":
+ correct = self.accelerator.gather_for_metrics(outputs.num_correct_tokens).sum()
+ accuracy = (correct / num_valid).item() if num_valid > 0 else 0.0
+ self._metrics[mode]["mean_token_accuracy"].append(accuracy)
+ elif self.args.use_liger_kernel:
+ if hasattr(outputs, "token_accuracy") and outputs.token_accuracy is not None:
+ token_accuracy = self.accelerator.gather_for_metrics(outputs.token_accuracy).mean().item()
+ self._metrics[mode]["mean_token_accuracy"].append(token_accuracy)
+ else:
+ warnings.warn(
+ "liger-kernel did not return token_accuracy when requested. The mean_token_accuracy metric will "
+ "not be logged. This is unexpected; please report it to the liger-kernel repository.",
+ stacklevel=2,
+ )
+ # Log auxiliary loss if enabled (applies to both Liger and non-Liger)
+ if self.aux_loss_enabled:
+ aux_loss = outputs.aux_loss
+ aux_loss = self.accelerator.gather_for_metrics(aux_loss).mean().item()
+ self._metrics[mode]["aux_loss"].append(aux_loss)
+
+ return (loss, outputs) if return_outputs else loss
+
+ def prediction_step(self, model, inputs, prediction_loss_only, ignore_keys=None):
+ # Preserve the eval loop intent so compute_loss can decide whether logits are needed.
+ inputs["_prediction_loss_only"] = prediction_loss_only
+ return super().prediction_step(model, inputs, prediction_loss_only, ignore_keys=ignore_keys)
+
+ # Override training step to add activation offloading context.
+ def training_step(self, *args, **kwargs):
+ with self.maybe_activation_offload_context:
+ return super().training_step(*args, **kwargs)
+
+ def log(self, logs: dict[str, float], start_time: float | None = None) -> None:
+ mode = "train" if self.model.training else "eval"
+ metrics = {key: sum(val) / len(val) for key, val in self._metrics[mode].items()} # average the metrics
+
+ # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs`
+ # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format.
+ if mode == "eval":
+ metrics = {f"eval_{key}": val for key, val in metrics.items()}
+
+ logs.update(metrics)
+ super().log(logs, start_time)
+ self._metrics[mode].clear()
+
+ # Ensure the model card is saved along with the checkpoint
+ def _save_checkpoint(self, model, trial):
+ if self.args.hub_model_id is None:
+ model_name = Path(self.args.output_dir).name
+ else:
+ model_name = self.args.hub_model_id.split("/")[-1]
+ self.create_model_card(model_name=model_name)
+ super()._save_checkpoint(model, trial)
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/utils.py b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..0bee38de138c3fb9851e4fe276d4fa45f00ed696
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/trainer/utils.py
@@ -0,0 +1,1501 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import hashlib
+import importlib.resources as pkg_resources
+import os
+import random
+import socket
+import threading
+import types
+from collections.abc import Mapping, Sequence, Sized
+from contextlib import contextmanager
+from importlib.metadata import version
+from itertools import accumulate
+from typing import TypeVar
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn.functional as F
+import transformers
+from accelerate import PartialState
+from accelerate.logging import get_logger
+from huggingface_hub import ModelCard, ModelCardData
+from packaging.version import Version
+from torch.utils.data import Sampler
+from transformers import (
+ AutoConfig,
+ AutoModelForCausalLM,
+ AutoModelForImageTextToText,
+ BitsAndBytesConfig,
+ PretrainedConfig,
+ PreTrainedModel,
+ is_comet_available,
+ is_trackio_available,
+)
+from transformers.models.auto.auto_factory import _BaseAutoModelClass
+from transformers.utils import (
+ is_peft_available,
+ is_rich_available,
+ is_torch_xpu_available,
+)
+
+from ..trainer.model_config import ModelConfig
+
+
+if is_rich_available():
+ from rich.console import Console
+ from rich.panel import Panel
+ from rich.table import Table
+ from rich.text import Text
+
+if is_comet_available():
+ import comet_ml
+
+if is_peft_available():
+ from peft import LoraConfig, PeftConfig, PeftModel
+
+
+logger = get_logger(__name__)
+
+
+def _is_port_free(port: int, host: str = "127.0.0.1") -> bool:
+ try:
+ with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+ s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+ s.bind((host, port))
+ return True
+ except OSError:
+ return False
+
+
+def _find_free_port() -> int:
+ candidates = (29500, 23456, 12355, 12345)
+ for p in candidates:
+ if _is_port_free(p):
+ return p
+ with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+ s.bind(("", 0))
+ return s.getsockname()[1]
+
+
+def ensure_master_addr_port(addr: str | None = None, port: int | None = None) -> None:
+ """
+ Ensure `MASTER_ADDR`/`MASTER_PORT` are set safely.
+
+ - Respects existing environment variables.
+ - Defaults `MASTER_ADDR` to localhost if unset.
+ - Chooses a free TCP port if `MASTER_PORT` is unset to avoid collisions.
+ - If `MASTER_PORT` is set to `"0"` or `"auto"`, it is resolved to a free port.
+ """
+ os.environ["MASTER_ADDR"] = os.environ.get("MASTER_ADDR") or addr or "localhost"
+
+ env_port = os.environ.get("MASTER_PORT", "").strip().lower()
+ if port is None and env_port not in {"", "0", "auto"}:
+ try:
+ port = int(env_port)
+ except ValueError:
+ pass
+
+ os.environ["MASTER_PORT"] = str(_find_free_port() if port in (None, 0) else port)
+
+
+def pad(
+ tensors: list[torch.Tensor],
+ padding_value: int = 0,
+ padding_side: str = "right",
+ pad_to_multiple_of: int | None = None,
+) -> torch.Tensor:
+ """
+ Pads a list of tensors to the same shape along the first dimension.
+
+ Args:
+ tensors (`list[torch.Tensor]`):
+ List of input tensors to pad.
+ padding_value (`int`):
+ Value to use for padding. Default is 0.
+ padding_side (`str`):
+ Side on which to add padding. Must be 'left' or 'right'. Default is 'right'.
+ pad_to_multiple_of (`int`, *optional*):
+ If set will pad the sequence to a multiple of the provided value.
+
+ Returns:
+ `torch.Tensor`:
+ A single tensor containing the padded tensors.
+
+ Examples:
+ ```python
+ >>> import torch
+
+ >>> pad([torch.tensor([1, 2, 3]), torch.tensor([4, 5])])
+ tensor([[1, 2, 3],
+ [4, 5, 0]])
+
+ >>> pad([torch.tensor([[1, 2], [3, 4]]), torch.tensor([[5, 6]])])
+ tensor([[[1, 2],
+ [3, 4]],
+ [[5, 6],
+ [0, 0]]])
+ ```
+ """
+ # Determine the maximum shape for each dimension
+ output_shape = np.max([t.shape for t in tensors], 0).tolist()
+
+ # Apply pad_to_multiple_of to the first (sequence) dimension
+ if pad_to_multiple_of is not None:
+ remainder = output_shape[0] % pad_to_multiple_of
+ if remainder != 0:
+ output_shape[0] += pad_to_multiple_of - remainder
+
+ # Create an output tensor filled with the padding value
+ output = torch.full((len(tensors), *output_shape), padding_value, dtype=tensors[0].dtype, device=tensors[0].device)
+
+ for i, t in enumerate(tensors):
+ if padding_side == "left":
+ seq_start = output_shape[0] - t.shape[0]
+ elif padding_side == "right":
+ seq_start = 0
+ else:
+ raise ValueError("padding_side must be 'left' or 'right'")
+
+ # Define the slices
+ seq_slice = slice(seq_start, seq_start + t.shape[0])
+ slices = (seq_slice,) + tuple(slice(0, s) for s in t.shape[1:])
+ output[i][slices] = t
+
+ return output
+
+
+def disable_dropout_in_model(model: torch.nn.Module) -> None:
+ for module in model.modules():
+ if isinstance(module, torch.nn.Dropout):
+ module.p = 0
+
+
+def get_quantization_config(model_args: ModelConfig) -> BitsAndBytesConfig | None:
+ if model_args.load_in_4bit:
+ quantization_config = BitsAndBytesConfig(
+ load_in_4bit=True,
+ bnb_4bit_compute_dtype=model_args.dtype, # For consistency with model weights, we use the same value as `dtype`
+ bnb_4bit_quant_type=model_args.bnb_4bit_quant_type,
+ bnb_4bit_use_double_quant=model_args.use_bnb_nested_quant,
+ bnb_4bit_quant_storage=model_args.bnb_4bit_quant_storage,
+ )
+ elif model_args.load_in_8bit:
+ quantization_config = BitsAndBytesConfig(
+ load_in_8bit=True,
+ )
+ else:
+ quantization_config = None
+
+ return quantization_config
+
+
+def get_kbit_device_map() -> dict[str, int] | None:
+ if torch.cuda.is_available() or is_torch_xpu_available():
+ return {"": PartialState().local_process_index}
+ else:
+ return None
+
+
+def get_peft_config(model_args: ModelConfig) -> "PeftConfig | None":
+ if model_args.use_peft is False:
+ return None
+
+ if not is_peft_available():
+ raise ValueError(
+ "You need to have PEFT library installed in your environment, make sure to install `peft`. "
+ "Make sure to run `pip install -U peft`."
+ )
+
+ peft_config = LoraConfig(
+ task_type=model_args.lora_task_type,
+ r=model_args.lora_r,
+ target_modules=model_args.lora_target_modules,
+ target_parameters=model_args.lora_target_parameters,
+ lora_alpha=model_args.lora_alpha,
+ lora_dropout=model_args.lora_dropout,
+ bias="none",
+ use_rslora=model_args.use_rslora,
+ use_dora=model_args.use_dora,
+ modules_to_save=model_args.lora_modules_to_save,
+ )
+
+ return peft_config
+
+
+def generate_model_card(
+ base_model: str | None,
+ model_name: str,
+ hub_model_id: str,
+ dataset_name: str | None,
+ tags: list[str],
+ wandb_url: str | None,
+ trackio_url: str | None,
+ trainer_name: str,
+ trainer_citation: str | None = None,
+ template_file: str | None = None,
+ paper_title: str | None = None,
+ paper_id: str | None = None,
+ comet_url: str | None = None,
+) -> ModelCard:
+ """
+ Generate a [`~huggingface_hub.ModelCard`] from a template.
+
+ Args:
+ base_model (`str` or `None`):
+ Base model name.
+ model_name (`str`):
+ Model name.
+ hub_model_id (`str`):
+ Hub model ID as `username/model_id`.
+ dataset_name (`str` or `None`):
+ Dataset name.
+ tags (`list[str]`):
+ Tags.
+ wandb_url (`str` or `None`):
+ Weights & Biases run URL.
+ trackio_url (`str` or `None`):
+ Trackio Space URL.
+ comet_url (`str` or `None`):
+ Comet experiment URL.
+ trainer_name (`str`):
+ Trainer name.
+ trainer_citation (`str` or `None`, defaults to `None`):
+ Trainer citation as a BibTeX entry.
+ template_file (`str` *optional*):
+ Template file name located in the `trl/templates` directory. Defaults to `lm_model_card.md`.
+ paper_title (`str` or `None`, defaults to `None`):
+ Paper title.
+ paper_id (`str` or `None`, defaults to `None`):
+ ArXiv paper ID as `YYMM.NNNNN`.
+
+ Returns:
+ [`~huggingface_hub.ModelCard`]:
+ A ModelCard object.
+ """
+ card_data = ModelCardData(
+ base_model=base_model,
+ datasets=dataset_name,
+ library_name="transformers",
+ licence="license",
+ model_name=model_name,
+ tags=["generated_from_trainer", *tags],
+ )
+ template_file = template_file or "lm_model_card.md"
+ card = ModelCard.from_template(
+ card_data,
+ template_path=str(pkg_resources.files("trl").joinpath(f"templates/{template_file}")),
+ base_model=base_model,
+ model_name=model_name,
+ hub_model_id=hub_model_id,
+ dataset_name=dataset_name,
+ wandb_url=wandb_url,
+ trackio_url=trackio_url,
+ comet_url=comet_url,
+ trainer_name=trainer_name,
+ trainer_citation=trainer_citation,
+ paper_title=paper_title,
+ paper_id=paper_id,
+ trl_version=version("trl"),
+ transformers_version=version("transformers"),
+ pytorch_version=version("torch"),
+ datasets_version=version("datasets"),
+ tokenizers_version=version("tokenizers"),
+ )
+ return card
+
+
+def get_comet_experiment_url() -> str | None:
+ """
+ If Comet integration is enabled, return the URL of the current Comet experiment; otherwise, return `None`.
+ """
+ if not is_comet_available():
+ return None
+
+ if comet_ml.get_running_experiment() is not None:
+ return comet_ml.get_running_experiment().url
+
+ return None
+
+
+def get_trackio_space_url() -> str | None:
+ """
+ If Trackio integration is enabled, return the URL of the current Trackio Space; otherwise, return `None`.
+ """
+ if not is_trackio_available():
+ return None
+
+ from trackio import context_vars
+
+ run = context_vars.current_run.get()
+ if run is None:
+ return None
+ space_id = run._space_id
+ if space_id is None:
+ return None
+ space_id = space_id.replace("/", "-")
+ project = run.project
+ name = run.name
+ return f"https://{space_id}.hf.space?project={project}&runs={name}&sidebar=collapsed"
+
+
+def log_table_to_comet_experiment(name: str, table: pd.DataFrame) -> None:
+ """
+ If Comet integration is enabled logs a table to the Comet experiment if it is currently running.
+
+ Args:
+ name (`str`):
+ Table name.
+ table (`pandas.DataFrame`):
+ The Pandas DataFrame containing the table to log.
+ """
+ if not is_comet_available():
+ raise ModuleNotFoundError("The comet-ml is not installed. Please install it first: pip install comet-ml")
+
+ experiment = comet_ml.get_running_experiment()
+ if experiment is not None:
+ experiment.log_table(tabular_data=table, filename=name)
+
+
+def flush_left(mask: torch.Tensor, *tensors: torch.Tensor) -> torch.Tensor | tuple[torch.Tensor, ...]:
+ """
+ Shift non-zero elements in the mask and corresponding tensors to the left.
+
+ This function operates on a binary mask and any number of additional tensors with the same dimensions as the mask.
+ For each row, non-zero values are shifted to the leftmost positions. Then, columns that contain only zeros across
+ all rows are truncated from the mask and tensors. Visually, this operation can be represented as follows:
+
+ ```
+ [[0, 0, x, x, x, x], -> [[x, x, x, x],
+ [0, x, x, x, 0, 0]] [x, x, x, 0]]
+ ```
+
+ Args:
+ mask (`torch.Tensor`):
+ 2D tensor (binary mask) with shape `(N, M)`.
+ *tensors (`torch.Tensor`):
+ One or more 2D tensors with the same shape as `mask`. These tensors will be processed alongside `mask`,
+ with non-zero values shifted and excess zero columns truncated in the same manner.
+
+ Returns:
+ `torch.Tensor`:
+ Updated binary mask with non-zero values flushed to the left and trailing zero columns removed.
+ `*torch.Tensor`
+ Updated tensors, processed in the same way as the mask.
+
+ Example:
+ ```python
+ >>> mask = torch.tensor([[0, 0, 1, 1, 1], [0, 1, 1, 0, 0]])
+ >>> tensor = torch.tensor([[9, 9, 2, 3, 4], [9, 5, 6, 9, 9]])
+ >>> new_mask, new_tensor = flush_left(mask, tensor)
+ >>> print(new_mask)
+ tensor([[1, 1, 1],
+ [1, 1, 0]])
+
+ >>> print(new_tensor)
+ tensor([[2, 3, 4],
+ [5, 6, 0]])
+ ```
+ """
+ _, M = mask.shape
+
+ # Create copy of mask and tensors
+ mask_copy = mask.clone()
+ tensors = [t.clone() for t in tensors]
+
+ # Shift non-zero values to the left
+ first_non_zero = mask_copy.argmax(dim=1)
+ pos = torch.arange(M, device=mask_copy.device).unsqueeze(0)
+ idx_roll = (pos + first_non_zero.unsqueeze(1)) % M
+ mask_roll = mask_copy.gather(1, idx_roll)
+ rolled_tensors = [t.gather(1, idx_roll) for t in tensors]
+
+ # Truncate trailing columns that are all zeros in mask_roll
+ col_sums = mask_roll.sum(dim=0)
+ empty_cols = col_sums == 0
+ first_empty_col = int(empty_cols.to(torch.int8).argmax()) if empty_cols.any() else M
+ flushed_mask = mask_roll[:, :first_empty_col]
+ flushed_tensors = [t[:, :first_empty_col] for t in rolled_tensors]
+
+ if not flushed_tensors:
+ return flushed_mask
+ return flushed_mask, *flushed_tensors
+
+
+def selective_log_softmax(logits, index) -> torch.Tensor:
+ """
+ A memory-efficient implementation of the common `log_softmax -> gather` operation.
+
+ This function is equivalent to the following naive implementation:
+ ```python
+ # for index with shape (...):
+ logps = torch.gather(logits.log_softmax(-1), dim=-1, index=index.unsqueeze(-1)).squeeze(-1)
+ # for index with shape (..., K):
+ logps = torch.gather(logits.log_softmax(-1), dim=-1, index=index)
+ ```
+
+ Args:
+ logits (`torch.Tensor`):
+ Logits tensor of shape `(..., num_classes)`.
+ index (`torch.Tensor`):
+ Index tensor of shape `(..., K)` or `(...)`, specifying the positions to gather from the log-softmax
+ output. When the last case is used, `K` log-probabilities are gathered per position (e.g. for top-K)
+
+ Returns:
+ `torch.Tensor`:
+ Gathered log probabilities with the same shape as `index`.
+ """
+ squeeze = index.ndim == logits.ndim - 1
+ if squeeze:
+ index = index.unsqueeze(-1)
+
+ if logits.dtype in [torch.float32, torch.float64]:
+ selected_logits = torch.gather(logits, dim=-1, index=index)
+ # loop to reduce peak mem consumption
+ logsumexp_values = torch.stack([torch.logsumexp(lg, dim=-1) for lg in logits])
+ per_token_logps = selected_logits - logsumexp_values.unsqueeze(-1) # log_softmax(x_i) = x_i - logsumexp(x)
+ else:
+ # logsumexp approach is unstable with bfloat16, fall back to slightly less efficient approach
+ per_token_logps = []
+ for row_logits, row_labels in zip(logits, index, strict=True): # loop to reduce peak mem consumption
+ row_logps = F.log_softmax(row_logits, dim=-1)
+ row_per_token_logps = row_logps.gather(dim=-1, index=row_labels)
+ per_token_logps.append(row_per_token_logps)
+ per_token_logps = torch.stack(per_token_logps)
+
+ if squeeze:
+ per_token_logps = per_token_logps.squeeze(-1)
+
+ return per_token_logps
+
+
+def entropy_from_logits(logits: torch.Tensor, chunk_size: int = 128) -> torch.Tensor:
+ """
+ Compute the Shannon entropy (in nats) for each row of *logits* in a memory-efficient way.
+
+ Instead of materializing the full softmax for all rows at once, the logits are flattened to shape (N, num_classes),
+ where N is the product of all leading dimensions. Computation is then performed in chunks of size `chunk_size`
+ along this flattened dimension, reducing peak memory usage. The result is reshaped back to match the input's
+ leading dimensions.
+
+ Args:
+ logits (`torch.Tensor`):
+ Logits tensor of shape `(..., num_classes)`. Entropy is taken along the last axis; all leading dimensions
+ are preserved in the output.
+ chunk_size (`int`, *optional*, defaults to `128`):
+ Number of rows from the flattened logits to process per iteration. Smaller values reduce memory usage at
+ the cost of more iterations.
+
+ Returns:
+ `torch.Tensor`:
+ Entropy values with shape `logits.shape[:-1]`.
+ """
+ original_shape = logits.shape[:-1] # all dims except num_classes
+ num_classes = logits.shape[-1]
+
+ # Flatten all leading dimensions into one
+ flat_logits = logits.reshape(-1, num_classes)
+
+ entropies = []
+ for chunk in flat_logits.split(chunk_size, dim=0):
+ logps = F.log_softmax(chunk, dim=-1)
+ chunk_entropy = -(torch.exp(logps) * logps).sum(-1)
+ entropies.append(chunk_entropy)
+
+ entropies = torch.cat(entropies, dim=0)
+ return entropies.reshape(original_shape)
+
+
+def print_prompt_completions_sample(
+ prompts: list,
+ completions: list,
+ rewards: dict[str, list[float]],
+ advantages: list[float],
+ step: int,
+ num_samples: int = None,
+ extra: dict[str, list] | None = None,
+) -> None:
+ """
+ Print out a sample of model completions to the console with multiple reward metrics.
+
+ This function creates a nicely formatted table showing prompt-completion pairs, useful for monitoring model outputs
+ during training. It requires the `rich` library to be installed.
+
+ Args:
+ prompts (`list`):
+ List of prompts. Can be either strings or lists of messages.
+ completions (`list`):
+ List of completions corresponding to the prompts. Can be either strings or lists of messages.
+ rewards (`dict[str, list[float]]`):
+ Dictionary where keys are reward names and values are lists of rewards.
+ advantages (`list[float]`):
+ List of advantages corresponding to the prompts and completions.
+ step (`int`):
+ Current training step number, used in the output title.
+ num_samples (`int`, *optional*):
+ Number of random samples to display. If `None` (default), all items will be displayed.
+ extra (`dict[str, list]`, *optional*):
+ Additional columns to display after the advantage column. Keys are column names and values are lists of
+ per-completion data (strings or any value convertible to string). Typically populated via `log_extra` in
+ reward functions. If `None` (default), no extra columns are shown.
+
+ Example:
+ ```python
+ >>> from trl.trainer.utils import print_prompt_completions_sample
+
+ >>> prompts = ["The sky is", "The sun is"]
+ >>> completions = [" blue.", " in the sky."]
+ >>> rewards = {"Correctness": [0.123, 0.456], "Format": [0.789, 0.101]}
+ >>> advantages = [0.987, 0.654]
+ >>> extra = {"source": ["dataset_A", "dataset_B"]}
+ >>> print_prompt_completions_sample(prompts, completions, rewards, advantages, 42, extra=extra)
+ ╭────────────────────────────────── Step 42 ───────────────────────────────────╮
+ │ ┏━━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━┓ │
+ │ ┃ Prompt ┃ Completion ┃ Correctness ┃ Format ┃ Advantage ┃ source ┃ │
+ │ ┡━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━┩ │
+ │ │ The sky is │ blue. │ 0.12 │ 0.79 │ 0.99 │ dataset_A │ │
+ │ ├────────────┼──────────────┼─────────────┼────────┼───────────┼───────────┤ │
+ │ │ The sun is │ in the sky. │ 0.46 │ 0.10 │ 0.65 │ dataset_B │ │
+ │ └────────────┴──────────────┴─────────────┴────────┴───────────┴───────────┘ │
+ ╰──────────────────────────────────────────────────────────────────────────────╯
+ ```
+ """
+ if not is_rich_available():
+ raise ImportError(
+ "The function `print_prompt_completions_sample` requires the `rich` library. Please install it with "
+ "`pip install rich`."
+ )
+ console = Console()
+ table = Table(show_header=True, header_style="bold white", expand=True)
+
+ extra = extra or {}
+
+ # Add columns
+ table.add_column("Prompt", style="bright_yellow")
+ table.add_column("Completion", style="bright_green")
+ for reward_name in rewards.keys():
+ table.add_column(reward_name, style="bold cyan", justify="right")
+ table.add_column("Advantage", style="bold magenta", justify="right")
+ for extra_name in extra.keys():
+ table.add_column(extra_name, style="bright_white")
+
+ def format_entry(entry) -> Text:
+ t = Text()
+ if isinstance(entry, list) and all(isinstance(m, dict) for m in entry):
+ for j, msg in enumerate(entry):
+ role = msg.get("role", "")
+ if "content" in msg or "reasoning_content" in msg or "thinking" in msg:
+ # Chat message
+ t.append(f"{role.upper()}\n", style="bold red")
+ reasoning = msg.get("reasoning_content") or msg.get("thinking")
+ if reasoning:
+ t.append(reasoning, style="italic dim white")
+ t.append("\n")
+ if "content" in msg:
+ t.append(msg["content"])
+ elif "name" in msg and "args" in msg:
+ # Tool call
+ t.append(f"{role.upper()}\n", style="bold red")
+ t.append(f"{msg['name']}({msg['args']})")
+ else:
+ # Fallback
+ t.append(str(msg))
+ if j < len(entry) - 1:
+ t.append("\n\n")
+ else:
+ t.append(str(entry))
+ return t
+
+ # Some basic input validation
+ if num_samples is not None:
+ if num_samples >= len(prompts):
+ num_samples = None
+ elif num_samples <= 0:
+ return
+
+ # Subsample data if num_samples is specified
+ if num_samples is not None:
+ indices = random.sample(range(len(prompts)), num_samples)
+ prompts = [prompts[i] for i in indices]
+ completions = [completions[i] for i in indices]
+ rewards = {key: [val[i] for i in indices] for key, val in rewards.items()}
+ advantages = [advantages[i] for i in indices]
+ extra = {key: [val[i] for i in indices] for key, val in extra.items()}
+
+ for i in range(len(prompts)):
+ reward_values = [f"{rewards[key][i]:.2f}" for key in rewards.keys()] # 2 decimals
+ extra_values = [format_entry(extra[key][i]) for key in extra.keys()]
+ table.add_row(
+ format_entry(prompts[i]),
+ format_entry(completions[i]),
+ *reward_values,
+ f"{advantages[i]:.2f}",
+ *extra_values,
+ )
+ table.add_section() # Adds a separator between rows
+
+ panel = Panel(table, expand=False, title=f"Step {step}", border_style="bold white")
+ console.print(panel)
+
+
+class RepeatSampler(Sampler):
+ """
+ Sampler that repeats the indices of a dataset in a structured manner.
+
+ Args:
+ data_source (`Sized`):
+ Dataset to sample from.
+ mini_repeat_count (`int`):
+ Number of times to repeat each index per batch.
+ batch_size (`int`, *optional*, defaults to `1`):
+ Number of unique indices per batch.
+ repeat_count (`int`, *optional*, defaults to `1`):
+ Number of times to repeat the full sampling process.
+ shuffle (`bool`, *optional*, defaults to `True`):
+ Whether to shuffle the dataset.
+ seed (`int`, *optional*):
+ Random seed for reproducibility (only affects this sampler).
+
+ Example:
+ ```python
+ >>> sampler = RepeatSampler(["a", "b", "c", "d", "e", "f", "g"], mini_repeat_count=2, batch_size=3, repeat_count=4)
+ >>> list(sampler)
+ [4, 4, 3, 3, 0, 0,
+ 4, 4, 3, 3, 0, 0,
+ 4, 4, 3, 3, 0, 0,
+ 4, 4, 3, 3, 0, 0,
+ 1, 1, 2, 2, 6, 6,
+ 1, 1, 2, 2, 6, 6,
+ 1, 1, 2, 2, 6, 6,
+ 1, 1, 2, 2, 6, 6]
+ ```
+
+ ```txt
+ mini_repeat_count = 3
+ - - -
+ [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, |
+ 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, |
+ 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, |
+ repeat_count = 2
+ 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, |
+ 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, |
+ 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, ...] |
+ --------- --------- --------- ---------
+ --------- --------- --------- ---------
+ --------- --------- --------- ---------
+ batch_size = 12
+ ```
+ """
+
+ def __init__(
+ self,
+ data_source: Sized,
+ mini_repeat_count: int,
+ batch_size: int = 1,
+ repeat_count: int = 1,
+ shuffle: bool = True,
+ seed: int | None = None,
+ ):
+ self.data_source = data_source
+ self.mini_repeat_count = mini_repeat_count
+ self.batch_size = batch_size
+ self.repeat_count = repeat_count
+ self.num_samples = len(data_source)
+ self.shuffle = shuffle
+ self.seed = seed
+
+ if shuffle:
+ self.generator = torch.Generator() # Create a local random generator
+ if seed is not None:
+ self.generator.manual_seed(seed)
+
+ def __iter__(self):
+ if self.shuffle:
+ # E.g., [2, 4, 3, 1, 0, 6, 5] (num_samples = 7)
+ indexes = torch.randperm(self.num_samples, generator=self.generator).tolist()
+ else:
+ indexes = list(range(self.num_samples))
+
+ # [2, 4, 3, 1, 0, 6, 5]
+ # -> [[2, 4, 3], [1, 0, 6], [5]] (batch_size = 3)
+ indexes = [indexes[i : i + self.batch_size] for i in range(0, len(indexes), self.batch_size)]
+
+ # [[2, 4, 3], [1, 0, 6], [5]]
+ # -> [[2, 4, 3], [1, 0, 6]]
+ indexes = [chunk for chunk in indexes if len(chunk) == self.batch_size]
+
+ for chunk in indexes:
+ for _ in range(self.repeat_count):
+ for index in chunk:
+ for _ in range(self.mini_repeat_count):
+ yield index
+
+ def __len__(self) -> int:
+ return (self.num_samples // self.batch_size) * self.batch_size * self.mini_repeat_count * self.repeat_count
+
+
+# torch.nanstd doesn't exist, so we define it here
+def nanstd(tensor: torch.Tensor, dim: int | tuple[int, ...] | None = None, keepdim: bool = False) -> torch.Tensor:
+ """
+ Compute the standard deviation of a tensor, ignoring NaNs.
+
+ Args:
+ tensor (`torch.Tensor`):
+ Input tensor.
+ dim (`int` or `tuple[int, ...]`, *optional*):
+ Dimension(s) to reduce. Defaults to all dimensions.
+ keepdim (`bool`, *optional*, defaults to `False`):
+ Whether to keep reduced dimensions.
+
+ Returns:
+ `torch.Tensor`:
+ Standard deviation of the tensor, ignoring NaNs.
+ """
+ # Compute variance ignoring NaNs
+ mean = torch.nanmean(tensor, dim=dim, keepdim=True)
+ variance = torch.nanmean((tensor - mean) ** 2, dim=dim, keepdim=True)
+ count = torch.sum(~torch.isnan(tensor), dim=dim, keepdim=True) # count of non-NaN values
+ correction = count / (count - 1)
+ correction = torch.where(count > 1, correction, torch.full_like(correction, float("nan")))
+ variance *= correction # Bessel's correction
+ std = torch.sqrt(variance)
+ if keepdim:
+ return std
+ if dim is None:
+ return std.squeeze()
+ if isinstance(dim, int):
+ return std.squeeze(dim)
+ dims = [(d if d >= 0 else d + std.ndim) for d in dim]
+ for d in sorted(dims, reverse=True):
+ std = std.squeeze(d)
+ return std
+
+
+def split_tensor_dict(
+ tensor_dict: dict[str, torch.Tensor | None], num_chunks: int
+) -> list[dict[str, torch.Tensor | None]]:
+ """
+ Splits a dictionary of tensors along the first dimension into `num_chunks` equal parts.
+
+ Example:
+ ```python
+ >>> x = torch.arange(12).reshape(6, 2)
+ >>> y = torch.arange(6).reshape(6, 1)
+ >>> tensor_dict = {"x": x, "y": y}
+ >>> split_tensor_dict(tensor_dict, 3)
+ [
+ {"x": tensor([[0, 1], [2, 3]]), "y": tensor([[0], [1]])},
+ {"x": tensor([[4, 5], [6, 7]]), "y": tensor([[2], [3]])},
+ {"x": tensor([[ 8, 9], [10, 11]]), "y": tensor([[4], [5]])}
+ ]
+ ```
+ """
+ first_tensor = next(tensor for tensor in tensor_dict.values() if tensor is not None)
+ chunk_size = first_tensor.shape[0] // num_chunks
+ chunks = []
+ for i in range(num_chunks):
+ chunk_dict = {}
+ for key, tensor in tensor_dict.items():
+ if tensor is not None and (isinstance(tensor, list) or tensor.ndim > 0):
+ chunk_dict[key] = tensor[i * chunk_size : (i + 1) * chunk_size]
+ elif tensor is not None and tensor.ndim == 0:
+ chunk_dict[key] = tensor
+ else:
+ chunk_dict[key] = None
+ chunks.append(chunk_dict)
+ return chunks
+
+
+def shuffle_sequence_dict(seq_dict: dict[str, Sequence | None]) -> dict[str, Sequence | None]:
+ """
+ Shuffles all sequence-like values in a dictionary along the first dimension in unison.
+
+ Example:
+ ```python
+ >>> x = torch.arange(6).reshape(3, 2)
+ >>> y = ["a", "b", "c"]
+ >>> seq_dict = {"x": x, "y": y}
+ >>> shuffle_sequence_dict(seq_dict)
+ {'x': tensor([[2, 3],
+ [0, 1],
+ [4, 5]]),
+ 'y': ['b', 'a', 'c']}
+ ```
+ """
+ # Determine batch size from the first non-None sequence
+ batch_size = len(next(v for v in seq_dict.values() if v is not None))
+ permutation = torch.randperm(batch_size)
+
+ def permute(v: Sequence | None) -> Sequence | None:
+ if v is None:
+ return None
+ if isinstance(v, torch.Tensor) and v.ndim == 0:
+ return v
+ if isinstance(v, torch.Tensor) and v.ndim >= 1:
+ return v[permutation]
+ return [v[i] for i in permutation]
+
+ return {key: permute(val) for key, val in seq_dict.items()}
+
+
+def nanmin(tensor: torch.Tensor) -> torch.Tensor:
+ """
+ Compute the minimum value of a tensor, ignoring NaNs. This function only supports 1D tensors.
+
+ Args:
+ tensor (`torch.Tensor`): Input tensor of shape `(N,)`.
+
+ Returns:
+ `torch.Tensor`: Minimum value of the tensor, ignoring NaNs. Returns NaN if all values are NaN.
+ """
+ if torch.isnan(tensor).all():
+ return torch.tensor(float("nan"), dtype=tensor.dtype, device=tensor.device)
+ return torch.min(tensor[~torch.isnan(tensor)])
+
+
+def nanmax(tensor: torch.Tensor) -> torch.Tensor:
+ """
+ Compute the maximum value of a tensor, ignoring NaNs. This function only supports 1D tensors.
+
+ Args:
+ tensor (`torch.Tensor`): Input tensor of shape `(N,)`.
+
+ Returns:
+ `torch.Tensor`: Maximum value of the tensor, ignoring NaNs. Returns NaN if all values are NaN.
+ """
+ if torch.isnan(tensor).all():
+ return torch.tensor(float("nan"), dtype=tensor.dtype, device=tensor.device)
+ return torch.max(tensor[~torch.isnan(tensor)])
+
+
+def identity(x):
+ """Do we really need docs for this?"""
+ return x
+
+
+def split_pixel_values_by_grid(batch: dict[str, torch.Tensor]) -> dict[str, torch.Tensor | list[torch.Tensor]]:
+ """
+ Splits `batch["pixel_values"]` into a list of tensors, one per sample, based on `batch["num_images"]`.
+
+ For models with `image_grid_thw` (e.g. Qwen), the grid dimensions determine how many rows of `pixel_values` belong
+ to each image. For models with `image_position_ids` instead (e.g. Gemma), `pixel_values` is indexed directly by
+ image count.
+ """
+ if "pixel_values" not in batch or "num_images" not in batch:
+ return batch
+
+ num_images = batch["num_images"]
+ pixel_values = batch["pixel_values"] # [total, feature_dim]
+
+ if "image_grid_thw" in batch:
+ lengths = batch["image_grid_thw"].prod(-1).tolist() # [num_images]
+ if sum(lengths) != pixel_values.size(0):
+ raise ValueError(
+ f"Mismatch: sum(lengths) = {sum(lengths)} != pixel_values.size(0) = {pixel_values.size(0)}"
+ )
+
+ boundaries = [0, *accumulate(num_images)]
+ image_grid_thw = batch["image_grid_thw"] # [total, 3]
+ sections = [sum(lengths[boundaries[i] : boundaries[i + 1]]) for i in range(len(num_images))]
+ split_pixel_values = list(torch.split(pixel_values, sections, dim=0))
+ split_image_grid_thw = list(torch.split(image_grid_thw, num_images, dim=0))
+ return {**batch, "pixel_values": split_pixel_values, "image_grid_thw": split_image_grid_thw}
+
+ if "image_position_ids" in batch:
+ image_position_ids = batch["image_position_ids"] # [total]
+ split_pixel_values = list(torch.split(pixel_values, num_images, dim=0))
+ split_image_position_ids = list(torch.split(image_position_ids, num_images, dim=0))
+ return {**batch, "pixel_values": split_pixel_values, "image_position_ids": split_image_position_ids}
+
+ return batch
+
+
+def unsplit_pixel_values_by_grid(batch: dict[str, torch.Tensor | list[torch.Tensor]]) -> dict[str, torch.Tensor]:
+ """
+ Opposite of `split_pixel_values_by_grid`. Merges a list of tensors in `batch["pixel_values"]` back into a single
+ tensor along the first dimension.
+ """
+ pixel_values = batch.get("pixel_values")
+ if isinstance(pixel_values, list):
+ merged = torch.cat(pixel_values, dim=0)
+ batch = {**batch, "pixel_values": merged}
+
+ image_grid_thw = batch.get("image_grid_thw")
+ if isinstance(image_grid_thw, list):
+ merged = torch.cat(image_grid_thw, dim=0)
+ batch = {**batch, "image_grid_thw": merged}
+
+ image_position_ids = batch.get("image_position_ids")
+ if isinstance(image_position_ids, list):
+ merged = torch.cat(image_position_ids, dim=0)
+ batch = {**batch, "image_position_ids": merged}
+
+ return batch
+
+
+TListOrMapping = TypeVar("TListOrMapping", list, Mapping)
+
+
+# This function is intentionally not used internally. It is provided as a utility for users whose datasets contain
+# `None` values inserted by tabular backends (e.g., Arrow/Parquet) for missing keys in nested structures. This
+# situation arises when loading datasets created before `datasets` v4.7.0 (which introduced the Json dtype), or when
+# datasets created after that version were saved without using the Json feature. In both cases, users can apply this
+# function via `dataset = dataset.with_transform(remove_none_values)` before training to strip the spurious `None`
+# values. See the migration guide for more details.
+def remove_none_values(example: TListOrMapping) -> TListOrMapping:
+ """
+ Recursively removes entries with `None` values from a nested structure (list or dictionary).
+
+ Args:
+ example (`list` or `Mapping`):
+ Input nested structure (list or dictionary) from which to remove `None`.
+
+ Examples:
+ ```python
+ >>> dataset = dataset.with_transform(remove_none_values)
+ ```
+ ```python
+ >>> [
+ ... {
+ ... "a": {"aa": None, "ab": 1},
+ ... "b": "my_string",
+ ... }
+ ... ]
+ >>> remove_none_values(example)
+ [{'a': {'ab': 1}, 'b': 'my_string'}]
+ ```
+ """
+ if isinstance(example, list):
+ return [remove_none_values(value) if isinstance(value, (dict, list)) else value for value in example]
+ elif isinstance(example, Mapping):
+ return {
+ key: remove_none_values(value) if isinstance(value, (dict, list)) else value
+ for key, value in example.items()
+ if value is not None
+ }
+ else:
+ raise TypeError("Input must be a list or a dictionary.")
+
+
+def create_model_from_path(
+ model_id: str, architecture: _BaseAutoModelClass | None = None, **kwargs
+) -> PreTrainedModel:
+ """
+ Create a model from a given path using the specified initialization arguments.
+
+ Args:
+ model_id (`str`):
+ Path to the model. Can be either a local directory or a model identifier from the Hugging Face Hub.
+ architecture (`_BaseAutoModelClass` or `None`, *optional*):
+ Model architecture class to instantiate. The model is initialized using the `from_pretrained` method of
+ this class. If `None`, the architecture will be inferred from the model's configuration.
+ kwargs (`dict`):
+ Initialization keyword arguments to pass to the model's `from_pretrained` method. When `'dtype'` is
+ specified, it can be either a `torch.dtype` or one of the strings: `'bfloat16'`, `'float16'`, `'float32'`,
+ or `'auto'`. If not explicitly set, `dtype` defaults to `'float32'`.
+
+ Returns:
+ [`~transformers.PreTrainedModel`]:
+ The instantiated model.
+ """
+ dtype = kwargs.get("dtype", "float32")
+ if isinstance(dtype, torch.dtype) or dtype == "auto" or dtype is None:
+ pass # dtype is already a torch.dtype or "auto" or None
+ elif isinstance(dtype, str) and dtype in ["bfloat16", "float16", "float32"]:
+ kwargs["dtype"] = getattr(torch, dtype)
+ else:
+ raise ValueError(
+ "Invalid `dtype` passed to the config. Expected either 'auto' or a string representing "
+ f"a valid `torch.dtype` (e.g., 'float32'), but got {dtype}."
+ )
+ kwargs["device_map"] = kwargs.get("device_map", "auto")
+ if architecture is None:
+ # Best effort to infer architecture from config, but we fall back to AutoModelForCausalLM if we can't find it
+ config = AutoConfig.from_pretrained(model_id, trust_remote_code=kwargs.get("trust_remote_code", False))
+ architecture = getattr(transformers, config.architectures[0], None)
+ if architecture is None:
+ # Remote-code checkpoint: the architecture name lives in the dynamic module, not in
+ # `transformers`. Pick the most specific auto class declared in `config.auto_map`.
+ auto_map = config.auto_map or {}
+ for candidate in (AutoModelForImageTextToText, AutoModelForCausalLM):
+ if candidate.__name__ in auto_map:
+ architecture = candidate
+ break
+ else:
+ architecture = AutoModelForCausalLM
+ model = architecture.from_pretrained(model_id, **kwargs)
+ return model
+
+
+def hash_module(module: torch.nn.Module) -> str:
+ h = hashlib.sha256()
+ for _, tensor in sorted(module.state_dict().items()):
+ tensor = tensor.cpu()
+ h.update(str(tensor.dtype).encode())
+ if tensor.dtype in [torch.bfloat16, torch.float8_e4m3fn, torch.float8_e5m2]:
+ tensor = tensor.to(torch.float32)
+ h.update(tensor.numpy().tobytes())
+ return h.hexdigest()
+
+
+def get_config_model_id(config: PretrainedConfig) -> str:
+ """
+ Retrieve the model identifier from a given model configuration.
+
+ Args:
+ config ([`~transformers.PreTrainedConfig`]):
+ Configuration from which to extract the model identifier.
+
+ Returns:
+ `str`:
+ The model identifier associated with the model configuration.
+ """
+ return getattr(config, "_name_or_path", "")
+
+
+@contextmanager
+def use_adapter(model: "PeftModel", adapter_name: str | None):
+ """
+ Context manager to temporarily set and reset the active adapter in a PEFT model.
+
+ Args:
+ model ([`~peft.PeftModel`]):
+ PEFT model to manage.
+ adapter_name (`str` or `None`):
+ Name of the adapter to set as active. If `None`, the context manager will disable all adapters.
+
+ Example:
+ ```python
+ >>> from trl.trainer.utils import use_adapter
+ >>> from peft import AutoPeftModelForCausalLM
+ >>> import torch
+
+ >>> model = AutoPeftModelForCausalLM.from_pretrained("path/to/model")
+ >>> input_ids = torch.tensor([[1, 2, 3]])
+ >>> with use_adapter(model, "adapter_name"):
+ ... outputs = model(input_ids)
+ ```
+ """
+
+ if not is_peft_available():
+ raise ImportError(
+ "You're trying to use a PEFT adapter but PEFT is not installed. Please install it with `pip install peft`."
+ )
+ if adapter_name is None:
+ with model.disable_adapter():
+ yield
+ else:
+ previous_adapter = model.active_adapter
+ model.set_adapter(adapter_name)
+ try:
+ yield
+ finally:
+ model.set_adapter(previous_adapter)
+
+
+def start_event_loop_in_daemon(
+ name: str | None = None,
+) -> tuple[threading.Thread, asyncio.AbstractEventLoop, threading.Event]:
+ """
+ This function creates a new daemon thread that runs the provided event loop.
+
+ Args:
+ name (`str`, *optional*):
+ Name of the thread. If `None`, the default thread naming will be used.
+
+ Returns:
+ `threading.Thread`:
+ The thread running the event loop.
+ `asyncio.AbstractEventLoop`:
+ The event loop being run in the thread.
+ `threading.Event`:
+ An event that is set when the loop is ready.
+ """
+ loop = asyncio.new_event_loop()
+ loop_ready_event = threading.Event()
+
+ def run_loop():
+ asyncio.set_event_loop(loop)
+ loop_ready_event.set()
+ loop.run_forever()
+
+ thread = threading.Thread(target=run_loop, name=name, daemon=True)
+ thread.start()
+ return thread, loop, loop_ready_event
+
+
+def shutdown_event_loop_in_daemon(
+ thread: threading.Thread | None,
+ loop: asyncio.AbstractEventLoop | None,
+) -> None:
+ """
+ Shutdown an asyncio event loop running in a separate thread.
+
+ This function stops the event loop and waits for the associated thread to finish execution.
+
+ Args:
+ thread (`threading.Thread`):
+ The thread running the event loop.
+ loop (`asyncio.AbstractEventLoop`):
+ The asyncio event loop to shut down.
+ """
+ if loop is None or thread is None:
+ return
+ loop.call_soon_threadsafe(loop.stop)
+ thread.join(timeout=5)
+
+
+class _ChunkedLogProbFunction(torch.autograd.Function):
+ """Compute per-token log-probs and entropy without materializing [N, V] logits.
+
+ Processes the lm_head in chunks and uses online logsumexp
+ """
+
+ @staticmethod
+ def forward(
+ ctx,
+ last_hidden: torch.Tensor, # [N, H]
+ weight: torch.Tensor, # [V, H]
+ targets: torch.Tensor, # [N]
+ temperature: float,
+ chunk_size: int,
+ final_logit_softcapping: float | None = None,
+ logit_scale: float = 1.0,
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ device = last_hidden.device
+ N, _ = last_hidden.shape
+ vocab, _ = weight.shape
+ inv_t = 1 / temperature
+
+ # NOTE(@aminediro): always acc in fp32 for stability
+ max_old = torch.full((N,), float("-inf"), device=device, dtype=torch.float32)
+ sum_exp = torch.zeros((N,), device=device, dtype=torch.float32)
+ x_sum_exp = torch.zeros((N,), device=device, dtype=torch.float32)
+ target_logit = torch.zeros((N,), device=device, dtype=torch.float32)
+
+ # Pre-allocate reusable buffers to avoid per-chunk allocation
+ mm_buf = torch.empty((N, chunk_size), device=device, dtype=last_hidden.dtype)
+ logits_buf = torch.empty((N, chunk_size), device=device, dtype=torch.float32)
+
+ for start in range(0, vocab, chunk_size):
+ end = min(start + chunk_size, vocab)
+ C = end - start
+ # using fp16=True, the model's hidden states get cast to float16 by autocast, but the mm_buf is allocated
+ # with last_hidden.dtype (float16) while w_chunk (the lm_head weights) is not auto casted
+ w_chunk = weight[start:end].to(last_hidden.dtype) # [C, H]
+ torch.mm(last_hidden, w_chunk.t(), out=mm_buf[:, :C])
+ logits_chunk = logits_buf[:, :C]
+ logits_chunk.copy_(mm_buf[:, :C])
+
+ logits_chunk.mul_(logit_scale)
+ if final_logit_softcapping is not None:
+ logits_chunk.div_(final_logit_softcapping).tanh_().mul_(final_logit_softcapping)
+
+ logits_chunk.mul_(inv_t) # [N, C]
+
+ # Online logsumexp update
+ chunk_max = logits_chunk.amax(dim=-1) # [N]
+ max_new = torch.maximum(max_old, chunk_max)
+ rescale = torch.exp(max_old - max_new)
+ chunk_exp = torch.exp(logits_chunk - max_new.unsqueeze(-1)) # [N, C]
+
+ sum_exp = sum_exp * rescale + chunk_exp.sum(dim=-1)
+ x_sum_exp = x_sum_exp * rescale + (chunk_exp * logits_chunk).sum(dim=-1)
+ max_old = max_new
+
+ # Gather target logits for labels in this chunk
+ in_chunk_cond = (targets >= start) & (targets < end)
+ local_idx = torch.clamp(targets - start, 0, end - start - 1)
+ # take the new logit if target_idx is in this chunk bounds else 0
+ target_logit += logits_chunk[torch.arange(N, device=device), local_idx] * in_chunk_cond
+
+ log_z = max_old + torch.log(sum_exp)
+ logprobs = target_logit - log_z
+ entropy = log_z - x_sum_exp / sum_exp
+
+ ctx.save_for_backward(last_hidden, weight, targets, log_z)
+ ctx.temperature = temperature
+ ctx.chunk_size = chunk_size
+ ctx.logit_scale = logit_scale
+ ctx.final_logit_softcapping = final_logit_softcapping
+
+ return logprobs, entropy
+
+ @staticmethod
+ def backward(ctx, grad_logprobs: torch.Tensor, grad_entropy: torch.Tensor): # type: ignore
+ hidden, weight, labels, log_z = ctx.saved_tensors
+ temperature: float = ctx.temperature
+ chunk_size: int = ctx.chunk_size
+ logit_scale: float = ctx.logit_scale
+ final_logit_softcapping: float = ctx.final_logit_softcapping
+ inv_t = 1 / temperature
+
+ N, _ = hidden.shape
+ vocab = weight.shape[0]
+
+ # NOTE(@aminediro): always acc in fp32 even if input is not
+ grad_hidden = torch.zeros(hidden.shape, device=hidden.device, dtype=torch.float32)
+ grad_weight = torch.zeros(weight.shape, device=weight.device, dtype=torch.float32)
+
+ # Pre-allocate reusable buffers to avoid per-chunk allocation
+ mm_buf = torch.empty((N, chunk_size), device=hidden.device, dtype=hidden.dtype)
+ logits_buf = torch.empty((N, chunk_size), device=hidden.device, dtype=torch.float32)
+
+ g = grad_logprobs.to(torch.float32) # [N]
+ row_idx = torch.arange(N, device=hidden.device)
+
+ for start in range(0, vocab, chunk_size):
+ end = min(start + chunk_size, vocab)
+ C = end - start
+ w_chunk = weight[start:end] # [C, H]
+
+ torch.mm(hidden, w_chunk.t(), out=mm_buf[:, :C])
+ logits_chunk = logits_buf[:, :C]
+ logits_chunk.copy_(mm_buf[:, :C])
+
+ logits_chunk.mul_(logit_scale)
+ if final_logit_softcapping is not None:
+ tanh_scaled = torch.tanh(logits_chunk / final_logit_softcapping)
+ logits_chunk.copy_(tanh_scaled * final_logit_softcapping)
+
+ logits_chunk.mul_(inv_t) # [N, C]
+ probs = torch.exp(logits_chunk - log_z.unsqueeze(-1)) # [N, C]
+
+ # dL/d(logits) = g * (1_[label] - p)
+ grad_logits = (-g).unsqueeze(-1) * probs # [N, C]
+
+ in_chunk_cond = (labels >= start) & (labels < end)
+ local_idx = torch.clamp(labels - start, 0, end - start - 1)
+ # If label in chunk add g to grad else it stays the same
+ grad_logits[row_idx, local_idx] += g * in_chunk_cond
+
+ grad_logits = grad_logits * inv_t
+ if final_logit_softcapping is not None:
+ grad_logits.mul_(1 - tanh_scaled.pow(2))
+
+ grad_logits = grad_logits * logit_scale
+
+ grad_hidden.add_(grad_logits @ w_chunk.float())
+ grad_weight[start:end].add_(grad_logits.t() @ hidden.float())
+
+ return grad_hidden.to(hidden.dtype), grad_weight.to(weight.dtype), None, None, None, None, None
+
+
+def patch_chunked_lm_head(
+ model: torch.nn.Module, chunk_size: int, temperature: float, output_router_logits: bool = False
+) -> None:
+ final_logit_softcapping = getattr(model.config, "final_logit_softcapping", None)
+
+ def _chunked_forward(
+ self: torch.nn.Module,
+ input_ids: torch.Tensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ labels: torch.Tensor | None = None,
+ completion_mask: torch.Tensor | None = None,
+ use_cache: bool = False,
+ **kwargs,
+ ) -> dict[str, torch.Tensor]:
+ assert labels is not None, "requires labels to not be None for logprob computation"
+
+ decoder_kwargs = {"output_router_logits": True} if output_router_logits else {}
+ outputs = self.model(
+ input_ids=input_ids, attention_mask=attention_mask, use_cache=use_cache, **decoder_kwargs, **kwargs
+ )
+ # NOTE(@aminediro): supporting Cohere2 models
+ logit_scale = getattr(self.config, "logit_scale", 1.0)
+ hidden_states = outputs.last_hidden_state # [B, S+1, H]
+
+ # Shift: predict next token
+ hidden_states = hidden_states[:, :-1, :] # [B, S-1, H]
+ labels = labels[:, 1:] # [B, S-1]
+
+ b, s, h = hidden_states.shape
+ hidden_flat = hidden_states.reshape(b * s, h)
+ targets_flat = labels.reshape(b * s)
+
+ # Filter to completion tokens only to avoid expensive matmuls on prompt tokens and tool results
+ valid_mask = None
+ if completion_mask is not None:
+ completion_mask = completion_mask[:, 1:] # same shift as labels
+ valid_mask = completion_mask.bool().reshape(b * s)
+ hidden_flat = hidden_flat[valid_mask] # [N_valid, H]
+ targets_flat = targets_flat[valid_mask] # [N_valid]
+
+ logprobs_valid, entropy_valid = _ChunkedLogProbFunction.apply(
+ hidden_flat,
+ self.lm_head.weight,
+ targets_flat,
+ temperature,
+ chunk_size,
+ final_logit_softcapping,
+ logit_scale,
+ )
+
+ if valid_mask is not None:
+ logprobs = torch.zeros(b * s, device=logprobs_valid.device, dtype=logprobs_valid.dtype)
+ entropy = torch.zeros(b * s, device=entropy_valid.device, dtype=entropy_valid.dtype)
+ logprobs[valid_mask] = logprobs_valid
+ entropy[valid_mask] = entropy_valid
+ else:
+ logprobs = logprobs_valid
+ entropy = entropy_valid
+
+ aux_loss = None
+ if output_router_logits:
+ # Mirror the per-family MoE forward: add `router_aux_loss_coef * load_balancing_loss_func(...)` to
+ # the main loss. Mixtral is the source of truth — every MoE family (Qwen3Moe, GptOss, OLMoE,
+ # Qwen2Moe, DBRX, JetMoE, PhiMoE, …) pulls this function from mixtral via the modular system, so a
+ # single import keeps us in lockstep with upstream for every family we test.
+ from transformers.models.mixtral.modeling_mixtral import load_balancing_loss_func
+
+ if Version(transformers.__version__) < Version("5.0.0"):
+ num_experts = self.num_experts
+ num_experts_per_tok = self.num_experts_per_tok
+ else:
+ # Upstream bug AttributeError: 'GptOssConfig' object has no attribute 'num_experts'; see #5754
+ if self.config.model_type == "gpt_oss" and Version("5.0.0") <= Version(
+ transformers.__version__
+ ) < Version("5.6.0"):
+ num_experts = self.num_experts
+ else:
+ num_experts = self.config.num_experts
+ num_experts_per_tok = self.config.num_experts_per_tok
+ # Padding-free packs all real tokens into a single row, so `attention_mask` is None and every token counts.
+ aux_loss = load_balancing_loss_func(
+ outputs.router_logits, num_experts, num_experts_per_tok, attention_mask
+ )
+
+ return {
+ "log_probs": logprobs.reshape(b, s),
+ "entropy": entropy.reshape(b, s),
+ "aux_loss": aux_loss,
+ }
+
+ model.forward = types.MethodType(_chunked_forward, model)
+
+
+def compute_flops_per_token(config: PretrainedConfig, seq_len: int) -> int:
+ """
+ Estimate training FLOPs per token for a causal language model (forward + backward).
+
+ Supports dense and MoE architectures. Backward is assumed to cost 2× the forward pass, so total training FLOPs = 3
+ × forward FLOPs. The attention-score term uses the non-causal convention (every token attends to the full
+ `seq_len`, matching PaLM / Megatron / nanoGPT); pass the resulting MFU through [`adjusted_mfu`] for the Llama /
+ DeepSpeed Ulysses causal-corrected convention.
+
+ Args:
+ config ([`~transformers.PretrainedConfig`]):
+ The model configuration.
+ seq_len (`int`):
+ The sequence length used for training.
+
+ Returns:
+ `int`: Estimated training FLOPs per token.
+ """
+ h = config.hidden_size
+ L = config.num_hidden_layers
+ V = config.vocab_size
+ n_heads = config.num_attention_heads
+ n_kv_heads = config.num_key_value_heads
+ head_dim = config.head_dim
+
+ # Attention: Q/K/V/O projections + attention score (Q·Kᵀ and attn·V).
+ qkv_flops = 2 * h * (n_heads * head_dim + 2 * n_kv_heads * head_dim)
+ o_proj_flops = 2 * n_heads * head_dim * h
+ attn_score_flops = 2 * 2 * n_heads * head_dim * seq_len
+ attn_flops = qkv_flops + o_proj_flops + attn_score_flops
+
+ # MoE dispatch: `num_experts_per_tok` is the canonical MoE marker — present on Mixtral,
+ # Qwen3-MoE, DeepSeek-V2, etc.; absent on dense configs.
+ num_experts_per_tok = getattr(config, "num_experts_per_tok", None)
+ if num_experts_per_tok is None:
+ mlp_flops = 2 * 3 * h * config.intermediate_size
+ total_layer_flops = L * (attn_flops + mlp_flops)
+ else:
+ # Routed experts (gate + up + down, 3 matmuls each) + router.
+ if Version(transformers.__version__) >= Version("5.1.0"):
+ num_experts = config.num_local_experts
+ else:
+ num_experts = config.num_experts
+ moe_mlp_flops = num_experts_per_tok * 2 * 3 * h * config.moe_intermediate_size
+ moe_mlp_flops += 2 * h * num_experts
+ dense_mlp_flops = 2 * 3 * h * config.intermediate_size # interspersed dense layers
+ sparse_step = config.decoder_sparse_step
+ total_layer_flops = sum(
+ attn_flops + (moe_mlp_flops if layer_idx % sparse_step == 0 else dense_mlp_flops) for layer_idx in range(L)
+ )
+
+ embed_flops = 2 * V * h
+ lm_head_flops = 0 if config.tie_word_embeddings else 2 * V * h
+
+ forward_flops = total_layer_flops + embed_flops + lm_head_flops
+ return 3 * forward_flops
+
+
+def compute_mfu(
+ flops_per_token: int,
+ tokens_per_second: float,
+ world_size: int,
+ peak_flops_per_device: float = 989.5e12,
+) -> float:
+ """
+ Compute Model FLOPs Utilization (MFU) as a percentage.
+
+ The caller is responsible for correcting `tokens_per_second` for any parallelism dimension that causes the
+ trainer's token counter to over-count (e.g. context parallelism, sequence parallelism, tensor parallelism — every
+ rank in those dims sees the same input tokens).
+
+ Args:
+ flops_per_token (`int`):
+ Training FLOPs per token (from [`compute_flops_per_token`]).
+ tokens_per_second (`float`):
+ Aggregate tokens per second across all devices, after any parallelism corrections.
+ world_size (`int`):
+ Number of devices (GPUs).
+ peak_flops_per_device (`float`, *optional*, defaults to `989.5e12`):
+ Theoretical peak FLOPs per device in bf16. Defaults to H100 SXM5.
+
+ Returns:
+ `float`: MFU as a percentage (0-100).
+ """
+ return 100 * (flops_per_token * tokens_per_second) / (peak_flops_per_device * world_size)
+
+
+def adjusted_mfu(mfu: float, config: PretrainedConfig, seq_len: int) -> float:
+ """
+ Apply a causal-masking correction to an MFU computed with [`compute_flops_per_token`].
+
+ [`compute_flops_per_token`] uses the non-causal attention convention (every token treated as attending to the full
+ `seq_len`, matching PaLM / Megatron / nanoGPT). With causal masking, only half of the attention-score FLOPs (`Q·Kᵀ`
+ and `attn·V`) are actually performed. This function subtracts that half from the per-token total and rescales `mfu`
+ accordingly. Use it to compare against reports that follow the Llama 2/3 / DeepSpeed Ulysses convention.
+
+ Args:
+ mfu (`float`):
+ MFU as a percentage, computed via [`compute_mfu`] (i.e., using the non-causal [`compute_flops_per_token`]).
+ config ([`~transformers.PretrainedConfig`]):
+ The model configuration.
+ seq_len (`int`):
+ The sequence length used for training.
+
+ Returns:
+ `float`: Causal-corrected MFU as a percentage.
+ """
+ flops_full = compute_flops_per_token(config, seq_len)
+ # Half of the attention-score FLOPs (Q·Kᵀ and attn·V), per layer, ×3 for fwd+bwd.
+ half_attn_score = config.num_hidden_layers * 3 * 2 * config.num_attention_heads * config.head_dim * seq_len
+ return mfu * (flops_full - half_attn_score) / flops_full
diff --git a/tasks/tasksmith-03a6a091b12f/tests/test.sh b/tasks/tasksmith-03a6a091b12f/tests/test.sh
new file mode 100644
index 0000000000000000000000000000000000000000..426176b8bea79061cb126a143199bafd3c1d6a41
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/test.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+set -eu
+exec /usr/local/bin/python -I /tests/grade.py
diff --git a/tasks/tasksmith-03a6a091b12f/tests/test_driver.py b/tasks/tasksmith-03a6a091b12f/tests/test_driver.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d47bdfd18bf0d184d186cb919f64637213b6c60
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/test_driver.py
@@ -0,0 +1,38 @@
+"""Private pytest entry point with a bounded framework-tampering check.
+
+The host still owns reward parsing. This guard detects replacement or in-place
+editing of unittest assertions, a demonstrated attack against repository tests.
+It does not claim to isolate arbitrary test and solution code in one interpreter.
+"""
+
+from __future__ import annotations
+
+import sys
+import unittest
+
+
+def run(arguments: list[str]) -> int:
+ import pytest
+
+ # Capture before pytest imports any repository modules. Retain code objects
+ # too: an attacker can mutate function.__code__ without replacing a method.
+ original = {
+ name: (value, getattr(value, "__code__", None))
+ for name, value in vars(unittest.TestCase).items()
+ if name.startswith("assert") and callable(value)
+ }
+ case = unittest.TestCase
+ code = int(pytest.main(arguments))
+ changed = []
+ for name, (method, implementation) in original.items():
+ current = getattr(case, name, None)
+ if current is not method or getattr(current, "__code__", None) is not implementation:
+ changed.append(name)
+ if unittest.TestCase is not case or changed:
+ sys.stderr.write("Verifier framework was modified: " + ", ".join(changed) + "\n")
+ return 254
+ return code
+
+
+if __name__ == "__main__":
+ raise SystemExit(run(sys.argv[1:]))
diff --git a/tasks/tasksmith-03a6a091b12f/tests/test_results.py b/tasks/tasksmith-03a6a091b12f/tests/test_results.py
new file mode 100644
index 0000000000000000000000000000000000000000..05ce2c730e38e02bad44f2344e88e5f1cb02cb8d
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/test_results.py
@@ -0,0 +1,65 @@
+"""Strict test evidence used by repository recipes and their exported verifiers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+
+@dataclass(frozen=True)
+class TestResults:
+ __test__ = False
+ statuses: dict[str, str]
+ returncode: int
+
+ @property
+ def passed(self) -> set[str]:
+ return {name for name, status in self.statuses.items() if status == "passed"}
+
+
+def parse_junit(text: str, *, returncode: int) -> TestResults:
+ if " dict[str, list[str]]:
+ if healthy.returncode != 0 or not healthy.passed:
+ raise ValueError("Reference must execute successfully with passing tests")
+ if healthy.statuses.keys() != defective.statuses.keys():
+ raise ValueError("Mutation changed test collection; contrast is not comparable")
+ failing = sorted(
+ name for name in healthy.passed if defective.statuses[name] in {"failed", "error"}
+ )
+ if not failing or defective.returncode != 1:
+ raise ValueError("No intended fail-to-pass contrast")
+ return {"FAIL_TO_PASS": failing, "PASS_TO_PASS": sorted(healthy.passed - set(failing))}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/Dockerfile b/tasks/tasksmith-0d2d1e298e86/environment/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..4de85cca97c5f7b929f717091127002a41106930
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/Dockerfile
@@ -0,0 +1,8 @@
+FROM python:3.12-slim-bookworm
+WORKDIR /workspace
+RUN python -m pip install --no-cache-dir accelerate==1.15.0 anyio==4.15.1 certifi==2026.7.22 click==8.5.0 datasets==3.6.0 diffusers==0.40.0 dill==0.3.8 filelock==3.32.3 fsspec==2025.3.0 h11==0.16.0 hf-xet==1.6.0 httpcore==1.0.9 httpx==0.28.1 huggingface_hub==1.31.0 idna==3.19 iniconfig==2.3.0 Jinja2==3.1.6 markdown-it-py==4.2.0 MarkupSafe==3.0.3 mdurl==0.1.2 mpmath==1.3.0 multiprocess==0.70.16 networkx==3.6.1 numpy==2.4.0 packaging==26.3 pandas==2.2.3 parameterized==0.9.0 pillow==11.2.1 pluggy==1.6.0 psutil==7.2.2 pyarrow==19.0.1 Pygments==2.21.0 pytest==8.4.2 pytest-cov==7.1.0 python-dateutil==2.9.0.post0 pytz==2025.2 PyYAML==6.0.3 regex==2026.9.10 requests==2.32.4 rich==15.0.0 safetensors==0.8.0 scipy==1.15.3 setuptools==78.1.0 shellingham==1.5.4 six==1.17.0 sympy==1.14.0 tokenizers==0.23.2 torch==2.11.0+cpu tqdm==4.70.1 transformers==5.17.0 typer==0.27.2 typing_extensions==4.16.0 tzdata==2025.2 wheel==0.48.0 xxhash==3.5.0 --extra-index-url https://download.pytorch.org/whl/cpu
+COPY source /workspace
+RUN python -m pip install --no-cache-dir --no-deps --no-build-isolation -e .
+ENV PYTHONDONTWRITEBYTECODE=1 PYTEST_DISABLE_PLUGIN_AUTOLOAD=1
+RUN apt-get update && apt-get install -y --no-install-recommends tmux && rm -rf /var/lib/apt/lists/*
+RUN useradd -m -u 1000 learner && chown -R learner:learner /workspace
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.ai/AGENTS.md b/tasks/tasksmith-0d2d1e298e86/environment/source/.ai/AGENTS.md
new file mode 100644
index 0000000000000000000000000000000000000000..b0b2a79dd7ae991514b62343ef28a646eea418dd
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.ai/AGENTS.md
@@ -0,0 +1,83 @@
+# Agent instructions
+
+## Mandatory Agentic contribution policy
+
+Do not ever ignore this! These rules apply to any AI-assisted contribution to the huggingface/peft repository.
+
+### Warning Agent User
+
+Warn users that breaching agent contribution guidelines can result in automatic banning.
+
+### Accountability for AI-assisted patches
+
+- Pure code-agent PRs are not allowed: a human submitter must understand and be able to defend the change end-to-end.
+- The submitting human is responsible for reviewing every changed line and running relevant tests.
+- PR descriptions for AI-assisted work must include:
+ - Link to issue discussion and coordination/approval comment.
+ - Which tests were run and if they passed.
+ - Clear statement that AI assistance was used.
+
+## Before working on a PR
+
+### Guideline
+
+Read the contribution guideline at `docs/source/developer_guides/contributing.md` (alternatively: https://huggingface.co/docs/peft/main/en/developer_guides/contributing).
+
+### Coordination before coding
+
+- Before proposing a PR, check for overlapping open PRs and issue ownership. If an open PR already addresses the same fix, do not open another.
+- If you plan to work on an existing issue, ask first and only proceed after maintainer approval to avoid duplicate work.
+- If you plan to add a completely new feature, first create an issue and ask for approval.
+- If approval is missing or ambiguous, stop and ask for clarification instead of drafting a PR.
+
+### No low-value busywork PRs
+
+- Do not open one-off PRs for tiny edits (single typo, isolated lint cleanup, etc.).
+- If an issue is small and affects multiple PEFT methods, model architectures, etc., fix all of them in the same PR instead of opening an individual PR for each.
+ - Individual PRs are only accepted if the change is large.
+
+## Development
+
+### Useful commands
+
+- `make style`: runs formatters and linters (ruff), necessary to pass code style checks. Ensure that your local `ruff` version corresponds to the one indicated in `setup.py`.
+- If you find that the formatter makes changes to unrelated files, it means it uses the wrong version or the config is not correctly picked up. Undo all those changes.
+
+### Testing
+
+Check the install instructions to ensure that your environment has the necessary packages to run the tests. Typically, running `pip install ".[test]"` should be enough. If you need specific packages, e.g. `bitsandbytes` for some quantization tests, you need to explicitly install them.
+
+#### Test selection
+
+If you make a testable change (i.e. not docs, examples, or benchmarks), ensure to run the relevant unit tests. E.g. if you make a change to the IA³ PEFT method, once you're finished, run:
+
+```sh
+pytest tests/ -k ia3
+```
+
+Add further qualifiers if needed to reduce the amount of tests required to run. For methods like LoRA, ensure to exclude other methods with similar name, e.g.:
+
+```sh
+pytest tests/ -k "lora and not adalora and not randlora and not [...]"
+```
+
+Ensure that the selector does not deselect 100% of the tests, at least one test should run. If there are no corresponding tests, add them.
+
+#### Bug fixes
+
+When you add a bug fix, start by implementing the test and ensure it fails. Then implement the bugfix and ensure that the test passes.
+
+#### Test location
+
+PEFT follows a rigorous structure for the test location. Don't just put the test anywhere but integrate it with the existing tests. If the test requires GPUs to run, place it into `test_gpu_examples.py`.
+
+### Coding style
+
+- Follow the existing coding style. The changes should look consistent with existing code.
+- Avoid overly defensive code, e.g. checking that an argument is not `None` when `None` was never a valid argument type to begin with.
+
+### Backwards compatibility
+
+- Run `grep "python-version:\s\[" .github/workflows/tests.yml` to check which Python versions should be supported. Don't use defensive features required for older Python versions (e.g. `from __future__ import annotations`).
+- Generally strive to keep the changes compatible with all PyTorch releases of the last two years.
+- Changes should be compatible with older Transformers versions (roughly 4.33 upwards). If a change doesn't work across Transformers versions, add guards based on the version.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/ISSUE_TEMPLATE/bug-report.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/ISSUE_TEMPLATE/bug-report.yml
new file mode 100644
index 0000000000000000000000000000000000000000..82ad94acbca3dbeb54bf360c3b93462d75b22b82
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/ISSUE_TEMPLATE/bug-report.yml
@@ -0,0 +1,54 @@
+name: "\U0001F41B Bug Report"
+description: Submit a bug report to help us improve the library
+body:
+ - type: textarea
+ id: system-info
+ attributes:
+ label: System Info
+ description: Please share your relevant system information with us
+ placeholder: peft & accelerate & transformers version, platform, python version, ...
+ validations:
+ required: true
+
+ - type: textarea
+ id: who-can-help
+ attributes:
+ label: Who can help?
+ description: |
+ Your issue will be replied to more quickly if you can figure out the right person to tag with @.
+ If you know how to use git blame, that is the easiest way, otherwise, here is a rough guide of **who to tag**.
+
+ All issues are read by one of the core maintainers, so if you don't know who to tag, just leave this blank and
+ a core maintainer will ping the right person.
+
+ Please tag fewer than 3 people.
+
+ Library: @benjaminbossan @githubnemo
+
+ diffusers integration: @benjaminbossan @sayakpaul
+
+ Documentation: @stevhliu
+
+ placeholder: "@Username ..."
+
+ - type: textarea
+ id: reproduction
+ validations:
+ required: true
+ attributes:
+ label: Reproduction
+ description: |
+ Please provide a code sample that reproduces the problem you ran into. It can be a Colab link or just a code snippet.
+ Please provide the simplest reproducer as possible so that we can quickly fix the issue. When you paste
+ the error message, please include the full traceback.
+
+ placeholder: |
+ Reproducer:
+
+ - type: textarea
+ id: expected-behavior
+ validations:
+ required: true
+ attributes:
+ label: Expected behavior
+ description: "A clear and concise description of what you would expect to happen."
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/ISSUE_TEMPLATE/feature-request.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/ISSUE_TEMPLATE/feature-request.yml
new file mode 100644
index 0000000000000000000000000000000000000000..5e0b73e1f3afa9a865220346bc0ff2586c542ec8
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/ISSUE_TEMPLATE/feature-request.yml
@@ -0,0 +1,21 @@
+name: "\U0001F680 Feature request"
+description: Submit a proposal/request for a new feature
+labels: [ "feature" ]
+body:
+ - type: textarea
+ id: feature-request
+ validations:
+ required: true
+ attributes:
+ label: Feature request
+ description: |
+ A clear and concise description of the feature proposal. Please provide a link to the paper and code in case they exist.
+
+ - type: textarea
+ id: contribution
+ validations:
+ required: true
+ attributes:
+ label: Your contribution
+ description: |
+ Is there any way that you could help, e.g. by submitting a PR?
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/dependabot.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/dependabot.yml
new file mode 100644
index 0000000000000000000000000000000000000000..0501ce05b7350306050c78a6ef52a02a45acd181
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/dependabot.yml
@@ -0,0 +1,17 @@
+version: 2
+updates:
+ - package-ecosystem: "github-actions"
+ directory: "/"
+ schedule:
+ interval: "monthly"
+ cooldown:
+ default-days: 7
+ groups:
+ ci-actions:
+ patterns:
+ - "actions/*"
+ third-party-actions:
+ patterns:
+ - "*"
+ exclude-patterns:
+ - "actions/*"
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/build_docker_images.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/build_docker_images.yml
new file mode 100644
index 0000000000000000000000000000000000000000..45fa1f6253226bef13356605dc139f44c07d4ecd
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/build_docker_images.yml
@@ -0,0 +1,87 @@
+name: Build Docker images (scheduled)
+
+on:
+ workflow_dispatch:
+ workflow_call:
+ schedule:
+ - cron: "0 1 * * *"
+
+concurrency:
+ group: docker-image-builds
+ cancel-in-progress: false
+
+permissions: {}
+
+env:
+ CI_SLACK_CHANNEL: ${{ secrets.CI_DOCKER_CHANNEL }}
+
+jobs:
+ latest-cpu:
+ name: "Latest Peft CPU [dev]"
+ # GH Environment for extra protection: https://github.com/huggingface/peft/settings/environments
+ environment: branch-protection-main
+ runs-on:
+ group: aws-general-8-plus
+ steps:
+ - name: Set up Docker Buildx
+ uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
+ - name: Check out code
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ persist-credentials: false
+ - name: Login to DockerHub
+ uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+ with:
+ username: ${{ secrets.DOCKERHUB_USERNAME }}
+ password: ${{ secrets.DOCKERHUB_PASSWORD }}
+
+ - name: Build and Push CPU
+ uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
+ with:
+ context: ./docker/peft-cpu
+ push: true
+ tags: huggingface/peft-cpu
+
+ - name: Post to Slack
+ if: always()
+ uses: huggingface/hf-workflows/.github/actions/post-slack@3f88d63d3761558a32e8e46fc2a8536e04bb2aea # main from Feb 2025-02-24
+ with:
+ slack_channel: ${{ env.CI_SLACK_CHANNEL }}
+ title: 🤗 Results of the PEFT-CPU docker build
+ status: ${{ job.status }}
+ slack_token: ${{ secrets.SLACK_CIFEEDBACK_BOT_TOKEN }}
+
+ latest-cuda:
+ name: "Latest Peft GPU [dev]"
+ # GH Environment for extra protection: https://github.com/huggingface/peft/settings/environments
+ environment: branch-protection-main
+ runs-on:
+ group: aws-general-8-plus
+ steps:
+ - name: Set up Docker Buildx
+ uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
+ - name: Check out code
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ persist-credentials: false
+ - name: Login to DockerHub
+ uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+ with:
+ username: ${{ secrets.DOCKERHUB_USERNAME }}
+ password: ${{ secrets.DOCKERHUB_PASSWORD }}
+
+ - name: Build and Push GPU
+ uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
+ with:
+ context: ./docker/peft-gpu
+ push: true
+ tags: huggingface/peft-gpu
+
+ - name: Post to Slack
+ if: always()
+ uses: huggingface/hf-workflows/.github/actions/post-slack@3f88d63d3761558a32e8e46fc2a8536e04bb2aea # main from Feb 2025-02-24
+ with:
+ slack_channel: ${{ env.CI_SLACK_CHANNEL }}
+ title: 🤗 Results of the PEFT-GPU docker build
+ status: ${{ job.status }}
+ slack_token: ${{ secrets.SLACK_CIFEEDBACK_BOT_TOKEN }}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/build_documentation.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/build_documentation.yml
new file mode 100644
index 0000000000000000000000000000000000000000..03a542e2469bd966ad3d10cd47ba6c510f3d0856
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/build_documentation.yml
@@ -0,0 +1,22 @@
+name: Build documentation
+
+on:
+ push:
+ branches:
+ - main
+ - doc-builder*
+ - v*-release
+
+permissions: {}
+
+jobs:
+ build:
+ uses: huggingface/doc-builder/.github/workflows/build_main_documentation.yml@b0f9a6e3b6aa912656cbda9f74896eb721d29421 # main
+ with:
+ commit_sha: ${{ github.sha }}
+ package: peft
+ notebook_folder: peft_docs
+ custom_container: huggingface/transformers-doc-builder
+ secrets:
+ token: ${{ secrets.HUGGINGFACE_PUSH }}
+ hf_token: ${{ secrets.HF_DOC_BUILD_PUSH }}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/build_pr_documentation.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/build_pr_documentation.yml
new file mode 100644
index 0000000000000000000000000000000000000000..ea9a096f0b61924102a9e28c45f3fc1b5cbd931a
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/build_pr_documentation.yml
@@ -0,0 +1,19 @@
+name: Build PR Documentation
+
+on:
+ pull_request:
+
+concurrency:
+ group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+ cancel-in-progress: true
+
+permissions: {}
+
+jobs:
+ build:
+ uses: huggingface/doc-builder/.github/workflows/build_pr_documentation.yml@b0f9a6e3b6aa912656cbda9f74896eb721d29421 # main
+ with:
+ commit_sha: ${{ github.event.pull_request.head.sha }}
+ pr_number: ${{ github.event.number }}
+ package: peft
+ custom_container: huggingface/transformers-doc-builder
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/deploy_method_comparison_app.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/deploy_method_comparison_app.yml
new file mode 100644
index 0000000000000000000000000000000000000000..abe7ec7260f43dddb670af60db91c4ee885fbb81
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/deploy_method_comparison_app.yml
@@ -0,0 +1,61 @@
+name: Deploy "method_comparison" Gradio to Spaces
+
+on:
+ push:
+ branches: [ main ]
+ paths:
+ - "method_comparison/**"
+ # the method explorer (PEFT shop) app has its own Space and deploy workflow
+ - "!method_comparison/peft-shop/**"
+ workflow_dispatch:
+
+permissions: {}
+
+jobs:
+ deploy:
+ # GH Environment for extra protection: https://github.com/huggingface/peft/settings/environments
+ environment: branch-protection-main
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ fetch-depth: 0 # full history needed for subtree
+ persist-credentials: false
+
+ - name: Authenticate via ~/.netrc
+ env:
+ HF_TOKEN: ${{ secrets.PEFT_INTERNAL_REPO_READ_WRITE }}
+ run: |
+ # netrc needs BOTH login and password entries
+ printf "machine huggingface.co\nlogin hf\npassword ${HF_TOKEN}\n" >> ~/.netrc
+ chmod 600 ~/.netrc
+
+ - name: Deploy method_comparison app to HF Spaces
+ run: |
+ cd method_comparison
+ # the method explorer (PEFT shop) app is deployed to its own Space by its own workflow
+ rm -rf peft-shop
+ git init
+ # Spaces expect requirements.txt
+ mv requirements-app.txt requirements.txt
+ git config user.name "github-actions[bot]"
+ git config user.email "github-actions[bot]@users.noreply.github.com"
+ git remote add gradio-app https://huggingface.co/spaces/peft-internal-testing/PEFT-method-comparison
+ git add .
+ git commit -m "🚀 Deploy method comparison app from GH action"
+ git push -f gradio-app HEAD:main
+
+ - name: Deploy embeddable method_comparison app to HF Spaces (for docs)
+ run: |
+ cd method_comparison
+ rm -rf .git
+ git init
+ # requirements.txt is already present from the previous step
+ mv app_embed.py app.py
+ git config user.name "github-actions[bot]"
+ git config user.email "github-actions[bot]@users.noreply.github.com"
+ git remote add gradio-app https://huggingface.co/spaces/peft-internal-testing/PEFT-method-comparison-embed
+ git add .
+ git commit -m "🚀 Deploy method comparison app from GH action"
+ git push -f gradio-app HEAD:main
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/deploy_peft_shop_app.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/deploy_peft_shop_app.yml
new file mode 100644
index 0000000000000000000000000000000000000000..09097a03bdefa582dcae91b1e979d75172be97bb
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/deploy_peft_shop_app.yml
@@ -0,0 +1,78 @@
+name: Deploy "PEFT shop" Gradio app to Spaces
+
+on:
+ push:
+ branches: [ main ]
+ paths:
+ # the app itself, and the data sources baked into its data.json: benchmark results and the capability script
+ - "method_comparison/peft-shop/**"
+ - "method_comparison/*/results/**"
+ - "scripts/generate_method_capabilities.py"
+ schedule:
+ # monthly refresh so that newly added PEFT methods reach the Space without a manual dispatch
+ - cron: "0 3 1 * *"
+ workflow_dispatch:
+
+permissions: {}
+
+jobs:
+ deploy:
+ # GH Environment for extra protection: https://github.com/huggingface/peft/settings/environments
+ environment: branch-protection-main
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ persist-credentials: false
+
+ - name: Set up Python
+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+ with:
+ python-version: "3.12"
+
+ - name: Install PEFT and app dependencies
+ run: |
+ # CPU-only torch keeps the install small and fast; the capability probes run on CPU anyway
+ pip install torch --index-url https://download.pytorch.org/whl/cpu
+ pip install -e . gradio tqdm
+
+ - name: Build the app data
+ run: |
+ # data.json is generated at deploy time so that it always matches the deployed PEFT commit (see
+ # method_comparison/peft-shop/README.md); the app reads method_capabilities.json from the CWD and
+ # writes data.json into its own directory, where the deploy step below picks it up
+ python scripts/generate_method_capabilities.py --output method_capabilities.json
+ python method_comparison/peft-shop/app.py --rebuild --build-only
+
+ - name: Ensure Space exists
+ env:
+ HF_TOKEN: ${{ secrets.PEFT_INTERNAL_REPO_READ_WRITE }}
+ run: |
+ # pushing to a non-existent Space would fail, the Hub does not create repositories on git push
+ python -c "
+ from huggingface_hub import create_repo
+ create_repo('peft-internal-testing/PEFT-shop', repo_type='space', space_sdk='gradio', exist_ok=True)
+ "
+
+ - name: Authenticate via ~/.netrc
+ env:
+ HF_TOKEN: ${{ secrets.PEFT_INTERNAL_REPO_READ_WRITE }}
+ run: |
+ # netrc needs BOTH login and password entries
+ printf "machine huggingface.co\nlogin hf\npassword ${HF_TOKEN}\n" >> ~/.netrc
+ chmod 600 ~/.netrc
+
+ - name: Deploy PEFT shop app to HF Spaces
+ run: |
+ cd method_comparison/peft-shop
+ git init
+ git config user.name "github-actions[bot]"
+ git config user.email "github-actions[bot]@users.noreply.github.com"
+ git remote add gradio-app https://huggingface.co/spaces/peft-internal-testing/PEFT-shop
+ git add .
+ # data.json is gitignored (see .gitignore) so it doesn't get committed into the PEFT repo during local
+ # dev; force-add it here so the self-contained data file actually ships with the Space
+ git add -f data.json
+ git commit -m "🚀 Deploy PEFT shop app from GH action"
+ git push -f gradio-app HEAD:main
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/integrations_tests.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/integrations_tests.yml
new file mode 100644
index 0000000000000000000000000000000000000000..d82f4b8bd457e0e834f15b5126d0b587c4733c89
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/integrations_tests.yml
@@ -0,0 +1,86 @@
+name: integration tests
+
+on:
+ workflow_dispatch:
+ inputs:
+ branch:
+ description: 'Branch to test on'
+ required: true
+
+permissions: {}
+
+jobs:
+ run_transformers_integration_tests:
+ strategy:
+ fail-fast: false
+ matrix:
+ transformers-version: ['main', 'latest']
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ ref: ${{ github.event.inputs.branch }}
+ repository: ${{ github.event.pull_request.head.repo.full_name }}
+ persist-credentials: false
+ - name: Set up Python
+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+ with:
+ python-version: "3.10"
+ cache: "pip"
+ cache-dependency-path: "setup.py"
+ - name: print environment variables
+ run: |
+ echo "env.CI_BRANCH = ${CI_BRANCH}"
+ echo "env.CI_SHA = ${CI_SHA}"
+ - name: Install dependencies
+ run: |
+ python -m pip install --upgrade pip
+ python -m pip install .[test]
+ if [ "${{ matrix.transformers-version }}" == "main" ]; then
+ pip install -U git+https://github.com/huggingface/transformers.git
+ else
+ echo "Nothing to do as transformers latest already installed"
+ fi
+
+ - name: Test transformers integration
+ run: |
+ cd .. && git clone https://github.com/huggingface/transformers.git && cd transformers/ && git rev-parse HEAD
+ RUN_SLOW=1 pytest tests/peft_integration/test_peft_integration.py
+ run_diffusers_integration_tests:
+ strategy:
+ fail-fast: false
+ matrix:
+ # For now diffusers integration is not on PyPI
+ diffusers-version: ['main']
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ ref: ${{ github.event.inputs.branch }}
+ repository: ${{ github.event.pull_request.head.repo.full_name }}
+ persist-credentials: false
+ - name: Set up Python
+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+ with:
+ python-version: "3.10"
+ cache: "pip"
+ cache-dependency-path: "setup.py"
+ - name: print environment variables
+ run: |
+ echo "env.CI_BRANCH = ${CI_BRANCH}"
+ echo "env.CI_SHA = ${CI_SHA}"
+ - name: Install dependencies
+ run: |
+ python -m pip install --upgrade pip
+ python -m pip install .[test]
+
+ if [ "${{ matrix.diffusers-version }}" == "main" ]; then
+ pip install -U git+https://github.com/huggingface/diffusers.git
+ else
+ echo "Nothing to do as diffusers latest already installed"
+ fi
+
+ - name: Test diffusers integration
+ run: |
+ cd .. && git clone https://github.com/huggingface/diffusers.git && cd diffusers/ && git rev-parse HEAD
+ pytest tests/lora/test_lora_layers_peft.py
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/nightly.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/nightly.yml
new file mode 100644
index 0000000000000000000000000000000000000000..f6c2f2a901d3be50923e7491273fbdfd08d44938
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/nightly.yml
@@ -0,0 +1,152 @@
+name: Self-hosted runner with slow tests (scheduled)
+
+on:
+ workflow_dispatch:
+ schedule:
+ - cron: "0 2 * * *"
+
+env:
+ RUN_SLOW: "yes"
+ IS_GITHUB_CI: "1"
+ # To be able to run tests on CUDA 12.2
+ NVIDIA_DISABLE_REQUIRE: "1"
+ SLACK_API_TOKEN: ${{ secrets.SLACK_CIFEEDBACK_BOT_TOKEN }}
+
+permissions: {}
+
+jobs:
+ run_all_tests_single_gpu:
+ strategy:
+ fail-fast: false
+ runs-on:
+ group: aws-g6-4xlarge-plus
+ env:
+ CUDA_VISIBLE_DEVICES: "0"
+ TEST_TYPE: "single_gpu"
+ container:
+ image: huggingface/peft-gpu:latest
+ options: --gpus all --shm-size "16gb" -e NVIDIA_DISABLE_REQUIRE=true
+ defaults:
+ run:
+ shell: bash
+ steps:
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ persist-credentials: false
+ - name: Pip install
+ run: |
+ source activate peft
+ pip install -e . --no-deps
+ pip install pytest-reportlog
+
+ - name: Run common tests on single GPU
+ id: common_tests
+ continue-on-error: true
+ run: |
+ source activate peft
+ make tests_common_gpu
+
+ - name: Run examples on single GPU
+ id: examples
+ continue-on-error: true
+ run: |
+ source activate peft
+ make tests_examples_single_gpu
+
+ - name: Run core tests on single GPU
+ id: core_tests
+ continue-on-error: true
+ run: |
+ source activate peft
+ make tests_core_single_gpu
+
+ - name: Run regression tests on single GPU
+ id: regression
+ continue-on-error: true
+ run: |
+ source activate peft
+ make tests_regression
+
+ - name: Generate Report
+ if: always()
+ run: |
+ pip install slack_sdk tabulate
+ python scripts/log_reports.py >> $GITHUB_STEP_SUMMARY
+
+ - name: Check for test failures
+ if: |
+ steps.common_tests.outcome == 'failure' ||
+ steps.examples.outcome == 'failure' ||
+ steps.core_tests.outcome == 'failure' ||
+ steps.regression.outcome == 'failure'
+ run: |
+ echo "One or more test suites failed. Check the logs above."
+ exit 1
+
+ run_all_tests_multi_gpu:
+ strategy:
+ fail-fast: false
+ runs-on:
+ group: aws-g6-12xlarge-plus
+ env:
+ CUDA_VISIBLE_DEVICES: "0,1"
+ TEST_TYPE: "multi_gpu"
+ container:
+ image: huggingface/peft-gpu:latest
+ options: --gpus all --shm-size "16gb" -e NVIDIA_DISABLE_REQUIRE=true
+ defaults:
+ run:
+ shell: bash
+ steps:
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ persist-credentials: false
+ - name: Pip install
+ run: |
+ source activate peft
+ pip install -e . --no-deps
+ pip install pytest-reportlog
+
+ - name: Run common tests on multi GPU
+ id: common_tests
+ continue-on-error: true
+ run: |
+ source activate peft
+ make tests_common_gpu
+
+ - name: Run examples on multi GPU
+ id: examples
+ continue-on-error: true
+ run: |
+ source activate peft
+ make tests_examples_multi_gpu
+
+ - name: Run core tests on multi GPU
+ id: core_tests
+ continue-on-error: true
+ run: |
+ source activate peft
+ make tests_core_multi_gpu
+
+ - name: Run training on multi GPU
+ id: training
+ continue-on-error: true
+ run: |
+ source activate peft
+ make tests_training
+
+ - name: Generate Report
+ if: always()
+ run: |
+ pip install slack_sdk tabulate
+ python scripts/log_reports.py >> $GITHUB_STEP_SUMMARY
+
+ - name: Check for test failures
+ if: |
+ steps.common_tests.outcome == 'failure' ||
+ steps.examples.outcome == 'failure' ||
+ steps.core_tests.outcome == 'failure' ||
+ steps.training.outcome == 'failure'
+ run: |
+ echo "One or more test suites failed. Check the logs above."
+ exit 1
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/stale.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/stale.yml
new file mode 100644
index 0000000000000000000000000000000000000000..0b6117e0547c0a876a6adf8677ace98c838af140
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/stale.yml
@@ -0,0 +1,34 @@
+name: Stale Bot
+
+on:
+ schedule:
+ - cron: "0 15 * * *"
+
+permissions: {}
+
+jobs:
+ close_stale_issues:
+ name: Close Stale Issues
+ if: github.repository == 'huggingface/peft'
+ runs-on: ubuntu-latest
+ permissions:
+ issues: write
+ pull-requests: write
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ steps:
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ persist-credentials: false
+
+ - name: Setup Python
+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+ with:
+ python-version: 3.11
+
+ - name: Install requirements
+ run: |
+ pip install PyGithub
+ - name: Close stale issues
+ run: |
+ python scripts/stale.py
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/test-docker-build.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/test-docker-build.yml
new file mode 100644
index 0000000000000000000000000000000000000000..1349faaa81fa1ae67700bebdf6e1cfa1e82ea9ac
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/test-docker-build.yml
@@ -0,0 +1,66 @@
+name: Test Docker images (on PR)
+
+on:
+ pull_request:
+ paths:
+ # Run only when DockerFile files are modified
+ - "docker/*/Dockerfile"
+
+permissions: {}
+
+jobs:
+ get_changed_files:
+ name: "Build all modified docker images"
+ runs-on: ubuntu-latest
+ outputs:
+ matrix: ${{ steps.set-matrix.outputs.matrix }}
+ steps:
+ - name: Check out code
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ persist-credentials: false
+ - name: Get changed files
+ id: changed-files
+ uses: tj-actions/changed-files@9426d40962ed5378910ee2e21d5f8c6fcbf2dd96 # v47.0.6
+ with:
+ files: docker/*/Dockerfile
+ json: "true"
+ - name: Run step if only the files listed above change
+ if: steps.changed-files.outputs.any_changed == 'true'
+ id: set-matrix
+ env:
+ CHANGED_FILES: "${{ steps.changed-files.outputs.all_changed_files }}"
+ run: |
+ echo "matrix=$(echo ${CHANGED_FILES} | sed -e 's/\\\"/\"/g')" >> $GITHUB_OUTPUT
+ build_modified_files:
+ needs: get_changed_files
+ name: Build Docker images on modified files
+ runs-on: ubuntu-latest
+ if: ${{ needs.get_changed_files.outputs.matrix != '[]' }}
+ strategy:
+ fail-fast: false
+ matrix:
+ docker-file: ${{ fromJson(needs.get_changed_files.outputs.matrix) }}
+ steps:
+ - name: Cleanup disk
+ run: |
+ sudo ls -l /usr/local/lib/
+ sudo ls -l /usr/share/
+ sudo du -sh /usr/local/lib/
+ sudo du -sh /usr/share/
+ sudo rm -rf /usr/local/lib/android
+ sudo rm -rf /usr/share/dotnet
+ sudo du -sh /usr/local/lib/
+ sudo du -sh /usr/share/
+ - name: Set up Docker Buildx
+ uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
+ - name: Check out code
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ persist-credentials: false
+ - name: Build Docker image
+ uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
+ with:
+ file: ${{ matrix.docker-file }}
+ context: .
+ push: False
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/tests-main.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/tests-main.yml
new file mode 100644
index 0000000000000000000000000000000000000000..d646274c3d98a525eb5a46ee6d23d878c7a72ed7
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/tests-main.yml
@@ -0,0 +1,89 @@
+name: tests on transformers main
+
+on:
+ push:
+ branches: [main]
+ paths-ignore:
+ - 'docs/**'
+
+permissions: {}
+
+jobs:
+ tests:
+ # GH Environment for extra protection: https://github.com/huggingface/peft/settings/environments
+ environment: branch-protection-main
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ persist-credentials: false
+ - name: Make space for cache + models
+ # Ubuntu runner have less space free which is problematic since the model
+ # cache + dependencies fill up the disk, leaving no space for execution.
+ # So we remove some of the stuff we don't need (Java, .NET, etc.)
+ #
+ # Idea: https://dev.to/mathio/squeezing-disk-space-from-github-actions-runners-an-engineers-guide-3pjg
+ if: matrix.os != 'windows-latest'
+ run: |
+ df -h
+
+ # Remove Java (JDKs)
+ sudo rm -rf /usr/lib/jvm
+
+ # Remove .NET SDKs
+ sudo rm -rf /usr/share/dotnet
+
+ # Remove Swift toolchain
+ sudo rm -rf /usr/share/swift
+
+ # Remove Haskell (GHC)
+ sudo rm -rf /usr/local/.ghcup
+
+ # Remove Julia
+ sudo rm -rf /usr/local/julia*
+
+ # Remove Android SDKs
+ sudo rm -rf /usr/local/lib/android
+
+ # Remove Chromium (optional if not using for browser tests)
+ sudo rm -rf /usr/local/share/chromium
+
+ # Remove Microsoft/Edge and Google Chrome builds
+ sudo rm -rf /opt/microsoft /opt/google
+
+ # Remove Azure CLI
+ sudo rm -rf /opt/az
+
+ # Remove PowerShell
+ sudo rm -rf /usr/local/share/powershell
+
+ # Remove CodeQL and other toolcaches
+ sudo rm -rf /opt/hostedtoolcache
+
+ df -h
+ - name: Set up Python 3.11
+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+ with:
+ python-version: 3.11
+ cache: "pip"
+ cache-dependency-path: "setup.py"
+ - name: Install dependencies
+ run: |
+ python -m pip install --upgrade pip
+ # cpu version of pytorch
+ pip install -U git+https://github.com/huggingface/transformers.git
+ pip install -e .[test]
+ - name: Test with pytest
+ env:
+ TRANSFORMERS_IS_CI: 1
+ HF_TOKEN: ${{ secrets.HF_TOKEN }}
+ run: |
+ make test
+ - name: Post to Slack
+ if: always()
+ uses: huggingface/hf-workflows/.github/actions/post-slack@3f88d63d3761558a32e8e46fc2a8536e04bb2aea # main from Feb 2025-02-24
+ with:
+ slack_channel: ${{ secrets.SLACK_CHANNEL_ID }}
+ title: 🤗 Results of transformers main tests
+ status: ${{ job.status }}
+ slack_token: ${{ secrets.SLACK_CIFEEDBACK_BOT_TOKEN }}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/tests.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/tests.yml
new file mode 100644
index 0000000000000000000000000000000000000000..b997c433088f5785fe4be299ebbf60678408f600
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/tests.yml
@@ -0,0 +1,168 @@
+name: tests
+
+on:
+ push:
+ branches: [main]
+ paths-ignore:
+ - 'docs/**'
+ - 'method_comparison/**'
+ - '**.md'
+ pull_request:
+ paths-ignore:
+ - 'docs/**'
+ - 'method_comparison/**'
+ - '**.md'
+
+env:
+ HF_HOME: .cache/huggingface
+
+permissions: {}
+
+jobs:
+ check_code_quality:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ persist-credentials: false
+ - name: Set up Python
+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+ with:
+ python-version: "3.11"
+ cache: "pip"
+ cache-dependency-path: "setup.py"
+ - name: Install dependencies
+ run: |
+ python -m pip install --upgrade pip
+ pip install .[dev]
+ - name: Check quality
+ run: |
+ make quality
+
+ tests:
+ needs: check_code_quality
+ # dependabot updates (which don't require approval for CI to run) shouldn't trigger unit tests
+ if: ${{ !(github.event_name == 'pull_request' && github.event.pull_request.user.login == 'dependabot[bot]') }}
+ strategy:
+ fail-fast: false
+ matrix:
+ python-version: ["3.10", "3.11", "3.12", "3.13"]
+ os: ["ubuntu-latest", "windows-latest"]
+ runs-on: ${{ matrix.os }}
+ steps:
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ persist-credentials: false
+ - name: Make space for cache + models
+ # Ubuntu runner have less space free which is problematic since the model
+ # cache + dependencies fill up the disk, leaving no space for execution.
+ # So we remove some of the stuff we don't need (Java, .NET, etc.)
+ #
+ # Idea: https://dev.to/mathio/squeezing-disk-space-from-github-actions-runners-an-engineers-guide-3pjg
+ if: matrix.os != 'windows-latest'
+ run: |
+ df -h
+
+ # Remove Java (JDKs)
+ sudo rm -rf /usr/lib/jvm
+
+ # Remove .NET SDKs
+ sudo rm -rf /usr/share/dotnet
+
+ # Remove Swift toolchain
+ sudo rm -rf /usr/share/swift
+
+ # Remove Haskell (GHC)
+ sudo rm -rf /usr/local/.ghcup
+
+ # Remove Julia
+ sudo rm -rf /usr/local/julia*
+
+ # Remove Android SDKs
+ sudo rm -rf /usr/local/lib/android
+
+ # Remove Chromium (optional if not using for browser tests)
+ sudo rm -rf /usr/local/share/chromium
+
+ # Remove Microsoft/Edge and Google Chrome builds
+ sudo rm -rf /opt/microsoft /opt/google
+
+ # Remove Azure CLI
+ sudo rm -rf /opt/az
+
+ # Remove PowerShell
+ sudo rm -rf /usr/local/share/powershell
+
+ # Remove CodeQL and other toolcaches
+ sudo rm -rf /opt/hostedtoolcache
+
+ df -h
+ - name: Model cache
+ uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+ with:
+ # Avoid caching HF_HOME/modules and Python cache files to prevent interoperability
+ # issues and potential cache poisioning. We also avoid lock files to prevent runs
+ # avoiding re-download because they see a lock file.
+ path: |
+ ${{ env.HF_HOME }}/hub/**
+ !${{ env.HF_HOME }}/**/*.pyc
+ key: model-cache-${{ github.run_id }}
+ restore-keys: model-cache-
+ enableCrossOsArchive: true
+
+ - name: Dump cache content
+ # TODO: remove this step after 2025-02-15
+ if: matrix.os != 'windows-latest'
+ run: |
+ SHASUM=sha256sum
+ [ -f "$(which shasum)" ] && SHASUM=shasum
+ find "${{ env.HF_HOME }}/hub" -type f -exec "$SHASUM" {} \; > cache_content_initial || true
+ - name: Set up Python ${{ matrix.python-version }}
+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+ with:
+ python-version: ${{ matrix.python-version }}
+ cache: "pip"
+ cache-dependency-path: "setup.py"
+ - name: Install dependencies
+ run: |
+ python -m pip install --upgrade pip
+ pip install setuptools
+ # cpu version of pytorch
+ pip install -e .[test]
+ - name: Test with pytest
+ shell: bash
+ env:
+ HF_TOKEN: ${{ secrets.HF_TOKEN }}
+ TRANSFORMERS_IS_CI: 1
+ CI: 1
+ run: |
+ make test
+ # clean up all pytest temporary directories that are kept due to retention since space
+ # is a scarce resource on the runners and tasks like model cache creation (further below)
+ # fail if there's not enough space available.
+ (rm -r "/tmp/pytest-of-$(id -u -n)" || true)
+ - name: Dump cache content and diff
+ # This is just debug info so that we can monitor if the model cache diverges substantially
+ # over time and what the diverging model is.
+ # TODO: remove after 2025-02-15
+ if: matrix.os != 'windows-latest'
+ run: |
+ SHASUM=sha256sum
+ [ -f "$(which shasum)" ] && SHASUM=shasum
+ find "${{ env.HF_HOME }}/hub" -type f -exec "$SHASUM" {} \; > cache_content_after || true
+ diff -udp cache_content_initial cache_content_after || true
+ - name: Delete old model cache entries
+ run: |
+ # make sure that cache cleaning doesn't break the pipeline
+ python scripts/ci_clean_cache.py -d || true
+ - name: Update model cache
+ uses: actions/cache/save@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+ # Only let one runner (preferably the one that covers most tests) update the model cache
+ # after *every* run. This way we make sure that our cache is never outdated and we don't
+ # have to keep track of hashes.
+ if: always() && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.10'
+ with:
+ path: |
+ ${{ env.HF_HOME }}/hub/**
+ !${{ env.HF_HOME }}/**/*.pyc
+ key: model-cache-${{ github.run_id }}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/torch_compile_tests.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/torch_compile_tests.yml
new file mode 100644
index 0000000000000000000000000000000000000000..e8b85445d39a8d2f679501d14f5940c0009e3af5
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/torch_compile_tests.yml
@@ -0,0 +1,56 @@
+name: torch compile tests
+
+on:
+ workflow_dispatch:
+ inputs:
+ branch:
+ description: 'Branch to test on'
+ required: true
+ pytorch_nightly:
+ description: 'Whether to use PyTorch nightly (true/false)'
+ required: false
+ default: false
+
+env:
+ RUN_SLOW: "yes"
+ IS_GITHUB_CI: "1"
+ # To be able to run tests on CUDA 12.2
+ NVIDIA_DISABLE_REQUIRE: "1"
+
+permissions: {}
+
+jobs:
+ run_tests_with_compile:
+ runs-on:
+ group: aws-g6-4xlarge-plus
+ env:
+ PEFT_DEBUG_WITH_TORCH_COMPILE: 1
+ CUDA_VISIBLE_DEVICES: "0"
+ TEST_TYPE: "single_gpu_huggingface/peft-gpu:latest"
+ USE_PYTORCH_NIGHTLY: "${{ github.event.inputs.pytorch_nightly }}"
+ container:
+ image: "huggingface/peft-gpu:latest"
+ options: --gpus all --shm-size "16gb" --ipc host -v /mnt/cache/.cache/huggingface:/mnt/cache/
+ defaults:
+ run:
+ shell: bash
+ steps:
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ ref: ${{ github.event.inputs.branch }}
+ repository: ${{ github.event.pull_request.head.repo.full_name }}
+ persist-credentials: false
+ - name: Pip install
+ run: |
+ source activate peft
+ pip install -e . --no-deps
+ pip install pytest-cov pytest-reportlog parameterized datasets scipy einops
+ pip install "pytest>=7.2.0,<8.0.0" # see: https://github.com/huggingface/transformers/blob/ce4fff0be7f6464d713f7ac3e0bbaafbc6959ae5/setup.py#L148C6-L148C26
+ if [ "${USE_PYTORCH_NIGHTLY}" = "true" ]; then
+ python -m pip install --upgrade --pre torch --index-url https://download.pytorch.org/whl/nightly/cpu
+ fi
+ - name: Test compile with pytest
+ run: |
+ source activate peft
+ echo "PEFT_DEBUG_WITH_TORCH_COMPILE=$PEFT_DEBUG_WITH_TORCH_COMPILE"
+ make tests_torch_compile
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/trufflehog.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/trufflehog.yml
new file mode 100644
index 0000000000000000000000000000000000000000..f9d658e6e01a06052cc97216553a573538a1aed9
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/trufflehog.yml
@@ -0,0 +1,18 @@
+on:
+ push:
+
+name: Secret Leaks
+
+permissions: {}
+
+jobs:
+ trufflehog:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ fetch-depth: 0
+ persist-credentials: false
+ - name: Secret Scanning
+ uses: trufflesecurity/trufflehog@37b77001d0174ebec2fcca2bd83ff83a6d45a3ab # v3.95.3
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/upload_pr_documentation.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/upload_pr_documentation.yml
new file mode 100644
index 0000000000000000000000000000000000000000..860d191015c5318e8b0bfc51e27cf7de989a8547
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/upload_pr_documentation.yml
@@ -0,0 +1,18 @@
+name: Upload PR Documentation
+
+on:
+ workflow_run:
+ workflows: ["Build PR Documentation"]
+ types:
+ - completed
+
+permissions: {}
+
+jobs:
+ build:
+ uses: huggingface/doc-builder/.github/workflows/upload_pr_documentation.yml@b0f9a6e3b6aa912656cbda9f74896eb721d29421 # main
+ with:
+ package_name: peft
+ secrets:
+ hf_token: ${{ secrets.HF_DOC_BUILD_PUSH }}
+ comment_bot_token: ${{ secrets.COMMENT_BOT_TOKEN }}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/zizmor.yaml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/zizmor.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..bcc91302ae8b2176024b40161e005c9002b011ce
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/workflows/zizmor.yaml
@@ -0,0 +1,28 @@
+name: CI security linting
+
+on:
+ push:
+ branches: ["main"]
+ pull_request:
+ branches: ["*"]
+ paths:
+ - '.github/**'
+
+permissions: {}
+
+jobs:
+ zizmor:
+ name: zizmor latest via Cargo
+ runs-on: ubuntu-latest
+ permissions:
+ contents: read
+ security-events: write
+ steps:
+ - name: Checkout repository
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ persist-credentials: false
+ - name: Install zizmor
+ run: cargo install --locked zizmor
+ - name: Run zizmor
+ run: zizmor .github/workflows
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.github/zizmor.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/zizmor.yml
new file mode 100644
index 0000000000000000000000000000000000000000..1a45e4d79f25a8809a32d2dfac537c7d6b4b3cd8
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.github/zizmor.yml
@@ -0,0 +1,28 @@
+rules:
+ dangerous-triggers:
+ ignore:
+ # this workflow is only triggered after maintainer approval
+ - upload_pr_documentation.yml:3:1
+ cache-poisoning:
+ ignore:
+ # the docker buildx binary is cached and zizmor warns about a cache poisoning attack.
+ # OTOH this cache would make us more resilient against an intrusion on docker-buildx' side.
+ # There is no obvious benefit so we leave it as it is.
+ - build_docker_images.yml:39:9
+ - build_docker_images.yml:74:9
+ secrets-outside-env:
+ ignore:
+ # Zizmor warns about HF_TOKEN being used there but the token is not exposed to external users:
+ # > With the exception of GITHUB_TOKEN, secrets are not passed to the runner when a workflow is triggered from a forked repository.
+ # https://docs.github.com/en/actions/how-tos/write-workflows/choose-what-workflows-do/use-secrets#using-secrets-in-a-workflow
+ # Moreover, the workflow needs to be manually triggered by maintainers, who will review the code first
+ - tests.yml:131:25
+ unpinned-images:
+ ignore:
+ # We want to test these images with the latest version and we're not using them
+ # to deploy anything so we deem it safe to use those, even if they are unpinned.
+ - nightly-bnb.yml:30:7
+ - nightly-bnb.yml:155:7
+ - nightly.yml:27:7
+ - nightly.yml:95:7
+ - torch_compile_tests.yml:32:7
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.gitignore b/tasks/tasksmith-0d2d1e298e86/environment/source/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..4e3e2ca5fc7e93d32d06e8e1a696925c3eaac60d
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.gitignore
@@ -0,0 +1,145 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+# Usually these files are written by a python script from a template
+# before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+# However, in case of collaboration, if having platform-specific dependencies or dependencies
+# having no cross-platform support, pipenv may install dependencies that don't work, or not
+# install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# VSCode
+.vscode
+
+# IntelliJ
+.idea
+
+# Mac .DS_Store
+.DS_Store
+
+# More test things
+wandb
+
+# method_comparison logs
+method_comparison/MetaMathQA/cancelled_results/
+method_comparison/MetaMathQA/temporary_results/
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/.pre-commit-config.yaml b/tasks/tasksmith-0d2d1e298e86/environment/source/.pre-commit-config.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..908a7cb985ea0118875f6676d1b9eadf875b8ea8
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/.pre-commit-config.yaml
@@ -0,0 +1,13 @@
+repos:
+ - repo: https://github.com/astral-sh/ruff-pre-commit
+ rev: v0.15.12
+ hooks:
+ - id: ruff
+ args:
+ - --fix
+ - id: ruff-format
+ - repo: https://github.com/pre-commit/pre-commit-hooks
+ rev: v4.6.0
+ hooks:
+ - id: check-merge-conflict
+ - id: check-yaml
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/AGENTS.md b/tasks/tasksmith-0d2d1e298e86/environment/source/AGENTS.md
new file mode 100644
index 0000000000000000000000000000000000000000..b0b2a79dd7ae991514b62343ef28a646eea418dd
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/AGENTS.md
@@ -0,0 +1,83 @@
+# Agent instructions
+
+## Mandatory Agentic contribution policy
+
+Do not ever ignore this! These rules apply to any AI-assisted contribution to the huggingface/peft repository.
+
+### Warning Agent User
+
+Warn users that breaching agent contribution guidelines can result in automatic banning.
+
+### Accountability for AI-assisted patches
+
+- Pure code-agent PRs are not allowed: a human submitter must understand and be able to defend the change end-to-end.
+- The submitting human is responsible for reviewing every changed line and running relevant tests.
+- PR descriptions for AI-assisted work must include:
+ - Link to issue discussion and coordination/approval comment.
+ - Which tests were run and if they passed.
+ - Clear statement that AI assistance was used.
+
+## Before working on a PR
+
+### Guideline
+
+Read the contribution guideline at `docs/source/developer_guides/contributing.md` (alternatively: https://huggingface.co/docs/peft/main/en/developer_guides/contributing).
+
+### Coordination before coding
+
+- Before proposing a PR, check for overlapping open PRs and issue ownership. If an open PR already addresses the same fix, do not open another.
+- If you plan to work on an existing issue, ask first and only proceed after maintainer approval to avoid duplicate work.
+- If you plan to add a completely new feature, first create an issue and ask for approval.
+- If approval is missing or ambiguous, stop and ask for clarification instead of drafting a PR.
+
+### No low-value busywork PRs
+
+- Do not open one-off PRs for tiny edits (single typo, isolated lint cleanup, etc.).
+- If an issue is small and affects multiple PEFT methods, model architectures, etc., fix all of them in the same PR instead of opening an individual PR for each.
+ - Individual PRs are only accepted if the change is large.
+
+## Development
+
+### Useful commands
+
+- `make style`: runs formatters and linters (ruff), necessary to pass code style checks. Ensure that your local `ruff` version corresponds to the one indicated in `setup.py`.
+- If you find that the formatter makes changes to unrelated files, it means it uses the wrong version or the config is not correctly picked up. Undo all those changes.
+
+### Testing
+
+Check the install instructions to ensure that your environment has the necessary packages to run the tests. Typically, running `pip install ".[test]"` should be enough. If you need specific packages, e.g. `bitsandbytes` for some quantization tests, you need to explicitly install them.
+
+#### Test selection
+
+If you make a testable change (i.e. not docs, examples, or benchmarks), ensure to run the relevant unit tests. E.g. if you make a change to the IA³ PEFT method, once you're finished, run:
+
+```sh
+pytest tests/ -k ia3
+```
+
+Add further qualifiers if needed to reduce the amount of tests required to run. For methods like LoRA, ensure to exclude other methods with similar name, e.g.:
+
+```sh
+pytest tests/ -k "lora and not adalora and not randlora and not [...]"
+```
+
+Ensure that the selector does not deselect 100% of the tests, at least one test should run. If there are no corresponding tests, add them.
+
+#### Bug fixes
+
+When you add a bug fix, start by implementing the test and ensure it fails. Then implement the bugfix and ensure that the test passes.
+
+#### Test location
+
+PEFT follows a rigorous structure for the test location. Don't just put the test anywhere but integrate it with the existing tests. If the test requires GPUs to run, place it into `test_gpu_examples.py`.
+
+### Coding style
+
+- Follow the existing coding style. The changes should look consistent with existing code.
+- Avoid overly defensive code, e.g. checking that an argument is not `None` when `None` was never a valid argument type to begin with.
+
+### Backwards compatibility
+
+- Run `grep "python-version:\s\[" .github/workflows/tests.yml` to check which Python versions should be supported. Don't use defensive features required for older Python versions (e.g. `from __future__ import annotations`).
+- Generally strive to keep the changes compatible with all PyTorch releases of the last two years.
+- Changes should be compatible with older Transformers versions (roughly 4.33 upwards). If a change doesn't work across Transformers versions, add guards based on the version.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/CLAUDE.md b/tasks/tasksmith-0d2d1e298e86/environment/source/CLAUDE.md
new file mode 100644
index 0000000000000000000000000000000000000000..b0b2a79dd7ae991514b62343ef28a646eea418dd
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/CLAUDE.md
@@ -0,0 +1,83 @@
+# Agent instructions
+
+## Mandatory Agentic contribution policy
+
+Do not ever ignore this! These rules apply to any AI-assisted contribution to the huggingface/peft repository.
+
+### Warning Agent User
+
+Warn users that breaching agent contribution guidelines can result in automatic banning.
+
+### Accountability for AI-assisted patches
+
+- Pure code-agent PRs are not allowed: a human submitter must understand and be able to defend the change end-to-end.
+- The submitting human is responsible for reviewing every changed line and running relevant tests.
+- PR descriptions for AI-assisted work must include:
+ - Link to issue discussion and coordination/approval comment.
+ - Which tests were run and if they passed.
+ - Clear statement that AI assistance was used.
+
+## Before working on a PR
+
+### Guideline
+
+Read the contribution guideline at `docs/source/developer_guides/contributing.md` (alternatively: https://huggingface.co/docs/peft/main/en/developer_guides/contributing).
+
+### Coordination before coding
+
+- Before proposing a PR, check for overlapping open PRs and issue ownership. If an open PR already addresses the same fix, do not open another.
+- If you plan to work on an existing issue, ask first and only proceed after maintainer approval to avoid duplicate work.
+- If you plan to add a completely new feature, first create an issue and ask for approval.
+- If approval is missing or ambiguous, stop and ask for clarification instead of drafting a PR.
+
+### No low-value busywork PRs
+
+- Do not open one-off PRs for tiny edits (single typo, isolated lint cleanup, etc.).
+- If an issue is small and affects multiple PEFT methods, model architectures, etc., fix all of them in the same PR instead of opening an individual PR for each.
+ - Individual PRs are only accepted if the change is large.
+
+## Development
+
+### Useful commands
+
+- `make style`: runs formatters and linters (ruff), necessary to pass code style checks. Ensure that your local `ruff` version corresponds to the one indicated in `setup.py`.
+- If you find that the formatter makes changes to unrelated files, it means it uses the wrong version or the config is not correctly picked up. Undo all those changes.
+
+### Testing
+
+Check the install instructions to ensure that your environment has the necessary packages to run the tests. Typically, running `pip install ".[test]"` should be enough. If you need specific packages, e.g. `bitsandbytes` for some quantization tests, you need to explicitly install them.
+
+#### Test selection
+
+If you make a testable change (i.e. not docs, examples, or benchmarks), ensure to run the relevant unit tests. E.g. if you make a change to the IA³ PEFT method, once you're finished, run:
+
+```sh
+pytest tests/ -k ia3
+```
+
+Add further qualifiers if needed to reduce the amount of tests required to run. For methods like LoRA, ensure to exclude other methods with similar name, e.g.:
+
+```sh
+pytest tests/ -k "lora and not adalora and not randlora and not [...]"
+```
+
+Ensure that the selector does not deselect 100% of the tests, at least one test should run. If there are no corresponding tests, add them.
+
+#### Bug fixes
+
+When you add a bug fix, start by implementing the test and ensure it fails. Then implement the bugfix and ensure that the test passes.
+
+#### Test location
+
+PEFT follows a rigorous structure for the test location. Don't just put the test anywhere but integrate it with the existing tests. If the test requires GPUs to run, place it into `test_gpu_examples.py`.
+
+### Coding style
+
+- Follow the existing coding style. The changes should look consistent with existing code.
+- Avoid overly defensive code, e.g. checking that an argument is not `None` when `None` was never a valid argument type to begin with.
+
+### Backwards compatibility
+
+- Run `grep "python-version:\s\[" .github/workflows/tests.yml` to check which Python versions should be supported. Don't use defensive features required for older Python versions (e.g. `from __future__ import annotations`).
+- Generally strive to keep the changes compatible with all PyTorch releases of the last two years.
+- Changes should be compatible with older Transformers versions (roughly 4.33 upwards). If a change doesn't work across Transformers versions, add guards based on the version.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/CONTRIBUTING.md b/tasks/tasksmith-0d2d1e298e86/environment/source/CONTRIBUTING.md
new file mode 100644
index 0000000000000000000000000000000000000000..9831264b901d05875322c3450594152543d3a8cd
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/CONTRIBUTING.md
@@ -0,0 +1,123 @@
+
+
+# Contribute to PEFT
+
+We are happy to accept contributions to PEFT. If you plan to contribute, please read this to make the process as smooth as possible.
+
+## Installation
+
+For code contributions to PEFT, you should choose the ["source"](../install#source) installation method.
+
+If you are new to creating a pull request, follow the [Creating a pull request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request) guide by GitHub.
+
+## Tests and code quality checks
+
+Regardless of the contribution type (unless it’s only about the docs), you should run tests and code quality checks before creating a PR to ensure your contribution doesn’t break anything and follows the project standards.
+
+We provide a Makefile to execute the necessary tests. Run the code below for the unit test:
+
+```sh
+make test
+```
+
+Run one of the following to either only check or check and fix code quality and style:
+
+```sh
+make quality # just check
+make style # check and fix
+```
+
+You can also set up [`pre-commit`](https://pre-commit.com/) to run these fixes
+automatically as Git commit hooks.
+
+```bash
+$ pip install pre-commit
+$ pre-commit install
+```
+
+Running all the tests can take a while, so during development it can be more efficient to only [run tests specific to your change](https://docs.pytest.org/en/6.2.x/usage.html#specifying-tests-selecting-tests), e.g. via:
+
+```sh
+pytest tests/ -k
+```
+
+This should finish much quicker and allow for faster iteration.
+
+If your change is specific to a hardware setting (e.g., it requires CUDA), take a look at [`tests/test_gpu_examples.py`](https://github.com/huggingface/peft/blob/1c1c7fdaa6e6abaa53939b865dee1eded82ad032/tests/test_gpu_examples.py) and [`tests/test_common_gpu.py`](https://github.com/huggingface/peft/blob/1c1c7fdaa6e6abaa53939b865dee1eded82ad032/tests/test_common_gpu.py) to see if it makes sense to add tests there. If your change could have an effect on saving and loading models, please run the tests with the `--regression` flag to trigger regression tests.
+
+It can happen that while you’re working on your PR, the underlying code base changes due to other changes being merged. If that happens – especially when there is a merge conflict – please update your branch with the latest changes. This can be a merge or a rebase, and we'll squash and merge the PR once it’s ready. If possible, **avoid force pushes** to make reviews easier.
+
+## PR description
+
+When opening a PR, please provide a nice description of the change you're proposing. If it relates to other issues or PRs, please reference them. Providing a good description not only helps the reviewers review your code better and faster, it can also be used later (as a basis) for the commit message which helps with long term maintenance of the project.
+
+If your code makes some non-trivial changes, it may also be a good idea to add comments to the code to explain those changes. For example, if you had to iterate on your implementation multiple times because the most obvious way didn’t work, it’s a good indication that a code comment is needed.
+
+## Bugfixes
+
+Please give a description of the circumstances that led to the bug. If there is an existing issue, please link to it (e.g., “Resolves #12345”).
+
+Ideally when a bugfix is provided, it should be accompanied by a test for the bug. The test should fail with the current code and pass with the bugfix. Add a comment to the test that references the issue or PR. Without a test, it is more difficult to prevent regressions in the future.
+
+## Documentation improvements
+
+We are happy to have fixes for broken links and missing or unclear documentation. Taking care of examples, making sure that they are up-to-date and running fine in this fast moving environment is also highly appreciated.
+
+Please refrain from sending pull requests that *only* correct typing errors as these generally create more work than they safe. Such changes are better combined with more substantial fixes (such as fixing broken links or extending/updating documentation).
+
+## Add a new PEFT fine-tuning method
+
+New parameter-efficient fine-tuning methods are developed all the time. If you would like to add a new and promising method to PEFT, please follow these steps.
+
+1. If you're _not_ an author of the original paper, check for existing implementations and double check with the authors that they don't plan to submit a PR themselves.
+2. Start with the core integration work listed below.
+3. Check recent commits for new PEFT methods being added to take as inspiration.
+4. It can be useful to open a draft PR early once the method basically works and first tests pass, then ask for feedback.
+5. After working through reviewer feedback, ping the reviewer so that they know the PR is ready to review.
+
+### Core integration of a new PEFT method
+
+- [ ] Open a proposal issue on `huggingface/peft` before investing too much work.
+- [ ] Link the source of the method, usually the final paper or another stable primary reference. We want to avoid work that is still under review, as the implementation should be stable.
+- [ ] Add a new `PeftType` entry in `src/peft/utils/peft_types.py`.
+- [ ] Create a new tuner package under `src/peft/tuners/` with the files your method needs (typically: `config.py`, `model.py`, `layer.py`, and `__init__.py`).
+- [ ] Register the method in the tuner `__init__.py` with `register_peft_method(...)`.
+- [ ] Export the new config/model from `src/peft/tuners/__init__.py` and `src/peft/__init__.py`.
+- [ ] If the method needs default target modules for Transformers models, add the mapping in `src/peft/utils/constants.py`.
+- [ ] Add the method to the test matrix in `tests/test_custom_models.py` as these are the broadest and quickest tests. Check that the tests pass with `pytest tests/test_custom_models.py -k -v`, fix failures if any.
+- [ ] Run style/quality checks with `make style` before pushing.
+- [ ] In the PR description, explain the method, link the paper, summarize tradeoffs, and list what was added.
+
+### Full PR to add a new PEFT method
+
+- [ ] Ensure that the configuration arguments that are specific to the method are well named and explained, don't assume that the user knows the paper inside out.
+- [ ] Follow the naming and coding conventions of PEFT.
+- [ ] Ensure that you didn't accidentally check in unrelated changes, e.g. the code formatter changing unrelated files.
+- [ ] If some implementation choices are non-trivial, document them with a code comment.
+- [ ] Complete the full test suite (`test_config.py`, `test_decoder_models.py`, etc.) by adding the PEFT method to the test matrix. Ensure that the tests pass.
+- [ ] Add docs in `docs/source/package_reference/` with a short explanation, paper link, usage snippet, and autodoc blocks. Explain the pros and cons compared to other methods like LoRA. Register that doc page in `docs/source/_toctree.yml`.
+- [ ] Add a runnable example under `examples/` (can be a copy of an existing example), with a short `README.md`.
+- [ ] Check the benchmarks in `method_comparison/` and add experiment settings for your new method. This is a good place to sanity check that the PEFT method trains as expected. Include one or two reasonable benchmark configurations (one default, one optimized for the benchmark).
+- [ ] Recommended: Add generic quantization support. Instead of having to explicitly add quantization layer types for each quantization method, support generic quantization. As an example, check how it's implemented in [BOFT](https://github.com/huggingface/peft/tree/main/src/peft/tuners/boft). Extend https://github.com/huggingface/peft/blob/main/tests/test_quantization.py by adding your PEFT method there. Ask maintainers for help if needed.
+
+## Add other features
+
+It is best if you first open an issue on GitHub with a proposal to add the new feature. This way, you can discuss with the maintainers if it makes sense to add the feature before spending too much time on implementing it.
+
+New features should generally be accompanied by tests and documentation or examples. Without the latter, users will have a hard time discovering your cool new feature.
+
+Changes to the code should be implemented in a backward-compatible way. For example, existing code should continue to work the same way after the feature is merged.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/Dockerfile b/tasks/tasksmith-0d2d1e298e86/environment/source/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..3040daec63d42b1e17fe489106c78002021f3ca7
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/Dockerfile
@@ -0,0 +1,7 @@
+FROM python:3.12-slim-bookworm
+WORKDIR /workspace
+RUN python -m pip install --no-cache-dir accelerate==1.15.0 anyio==4.15.1 certifi==2026.7.22 click==8.5.0 datasets==3.6.0 diffusers==0.40.0 dill==0.3.8 filelock==3.32.3 fsspec==2025.3.0 h11==0.16.0 hf-xet==1.6.0 httpcore==1.0.9 httpx==0.28.1 huggingface_hub==1.31.0 idna==3.19 iniconfig==2.3.0 Jinja2==3.1.6 markdown-it-py==4.2.0 MarkupSafe==3.0.3 mdurl==0.1.2 mpmath==1.3.0 multiprocess==0.70.16 networkx==3.6.1 numpy==2.4.0 packaging==26.3 pandas==2.2.3 parameterized==0.9.0 pillow==11.2.1 pluggy==1.6.0 psutil==7.2.2 pyarrow==19.0.1 Pygments==2.21.0 pytest==8.4.2 pytest-cov==7.1.0 python-dateutil==2.9.0.post0 pytz==2025.2 PyYAML==6.0.3 regex==2026.9.10 requests==2.32.4 rich==15.0.0 safetensors==0.8.0 scipy==1.15.3 setuptools==78.1.0 shellingham==1.5.4 six==1.17.0 sympy==1.14.0 tokenizers==0.23.2 torch==2.11.0+cpu tqdm==4.70.1 transformers==5.17.0 typer==0.27.2 typing_extensions==4.16.0 tzdata==2025.2 wheel==0.48.0 xxhash==3.5.0 --extra-index-url https://download.pytorch.org/whl/cpu
+COPY . /workspace
+RUN python -m pip install --no-cache-dir --no-deps --no-build-isolation -e .
+RUN rm -rf /workspace/.git /root/.cache/pip
+ENV PYTHONDONTWRITEBYTECODE=1 PYTEST_DISABLE_PLUGIN_AUTOLOAD=1
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/LICENSE b/tasks/tasksmith-0d2d1e298e86/environment/source/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/LICENSE
@@ -0,0 +1,201 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/Makefile b/tasks/tasksmith-0d2d1e298e86/environment/source/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..f0d8f242399694025878c388cceca8b74638ce00
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/Makefile
@@ -0,0 +1,75 @@
+.PHONY: quality style test docs
+
+check_dirs := src tests examples docs scripts docker
+
+# Check that source code meets quality standards
+
+# this target runs checks on all files
+quality:
+ ruff check $(check_dirs)
+ ruff format --check $(check_dirs)
+ doc-builder style src/peft tests docs/source --max_len 119 --check_only
+
+# Format source code automatically and check is there are any problems left that need manual fixing
+style:
+ ruff check --fix $(check_dirs)
+ ruff format $(check_dirs)
+ doc-builder style src/peft tests docs/source --max_len 119
+
+test:
+ python -m pytest -n 3 tests/ $(if $(IS_GITHUB_CI),--report-log "ci_tests.log",)
+
+tests_examples_multi_gpu:
+ python -m pytest -m multi_gpu_tests tests/test_gpu_examples.py $(if $(IS_GITHUB_CI),--report-log "multi_gpu_examples.log",)
+
+tests_examples_single_gpu:
+ python -m pytest -m single_gpu_tests tests/test_gpu_examples.py $(if $(IS_GITHUB_CI),--report-log "single_gpu_examples.log",)
+
+tests_core_multi_gpu:
+ python -m pytest -m multi_gpu_tests tests/test_common_gpu.py $(if $(IS_GITHUB_CI),--report-log "core_multi_gpu.log",)
+
+tests_core_single_gpu:
+ python -m pytest -m single_gpu_tests tests/test_common_gpu.py $(if $(IS_GITHUB_CI),--report-log "core_single_gpu.log",)
+
+# exclude gemma tests, as generation fails with torch.compile, these failures
+# trigger side effects that make other tests fail with 'RuntimeError: Offset
+# increment outside graph capture encountered unexpectedly.'
+# TODO re-enable gemma once/if it is fixed
+tests_common_gpu:
+ python -m pytest tests/test_decoder_models.py -k "not gemma" $(if $(IS_GITHUB_CI),--report-log "common_decoder.log",)
+ python -m pytest tests/test_encoder_decoder_models.py $(if $(IS_GITHUB_CI),--report-log "common_encoder_decoder.log",)
+ python -m pytest tests/test_gptqmodel.py $(if $(IS_GITHUB_CI),--report-log "gptqmodel_gpu.log",)
+
+tests_examples_multi_gpu_bnb:
+ python -m pytest -m "multi_gpu_tests and bitsandbytes" tests/test_gpu_examples.py $(if $(IS_GITHUB_CI),--report-log "multi_gpu_bnb_examples.log",)
+
+tests_examples_single_gpu_bnb:
+ python -m pytest -m "single_gpu_tests and bitsandbytes" tests/test_gpu_examples.py $(if $(IS_GITHUB_CI),--report-log "single_gpu_bnb_examples.log",)
+
+tests_core_multi_gpu_bnb:
+ python -m pytest -m "multi_gpu_tests and bitsandbytes" tests/test_common_gpu.py $(if $(IS_GITHUB_CI),--report-log "core_multi_gpu_bnb.log",)
+
+tests_core_single_gpu_bnb:
+ python -m pytest -m "single_gpu_tests and bitsandbytes" tests/test_common_gpu.py $(if $(IS_GITHUB_CI),--report-log "core_single_gpu_bnb.log",)
+
+# For testing transformers tests for bnb runners
+transformers_tests:
+ RUN_SLOW=1 python -m pytest transformers-clone/tests/quantization/bnb $(if $(IS_GITHUB_CI),--report-log "transformers_tests.log",)
+
+tests_regression:
+ python -m pytest -s --regression tests/regression/ $(if $(IS_GITHUB_CI),--report-log "regression_tests.log",)
+
+tests_torch_compile:
+ python -m pytest tests/test_torch_compile.py $(if $(IS_GITHUB_CI),--report-log "compile_tests.log",)
+
+tests_training:
+ accelerate launch --config_file tests/training/deepspeed_config.yaml tests/training/training.py
+ accelerate launch --config_file tests/training/deepspeed_config.yaml tests/training/training.py --quant 4bit
+ accelerate launch --config_file tests/training/deepspeed_config.yaml tests/training/training.py --quant 8bit
+ accelerate launch --config_file tests/training/fsdp_config.yaml tests/training/training.py
+ accelerate launch --config_file tests/training/fsdp_config.yaml tests/training/training.py --quant 4bit
+ accelerate launch --config_file tests/training/fsdp2_config.yaml tests/training/training.py
+ accelerate launch --config_file tests/training/fsdp2_config.yaml tests/training/training.py --quant 4bit
+ accelerate launch --config_file tests/training/fsdp2_config.yaml tests/training/training.py --quant 4bit --target_modules q_proj --target_parameters v_proj.weight
+ accelerate launch --config_file tests/training/fsdp_config.yaml tests/training/adapters.py
+ accelerate launch --config_file tests/training/tp_config.yaml tests/training/lora_tp.py
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/README.md b/tasks/tasksmith-0d2d1e298e86/environment/source/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4c905902b9c70020546d64268629778cfaacd758
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/README.md
@@ -0,0 +1,189 @@
+
+
+
+
+
+Fine-tuning large pretrained models is often prohibitively costly due to their scale. Parameter-Efficient Fine-Tuning (PEFT) methods enable efficient adaptation of large pretrained models to various downstream applications by only fine-tuning a small number of (extra) model parameters instead of all the model's parameters. This significantly decreases the computational and storage costs. Recent state-of-the-art PEFT techniques achieve performance comparable to fully fine-tuned models.
+
+PEFT is integrated with Transformers for easy model training and inference, Diffusers for conveniently managing different adapters, and Accelerate for distributed training and inference for really big models.
+
+> [!TIP]
+> Visit the [PEFT](https://huggingface.co/PEFT) organization to read about the PEFT methods implemented in the library and to see notebooks demonstrating how to apply these methods to a variety of downstream tasks. Click the "Watch repos" button on the organization page to be notified of newly implemented methods and notebooks!
+
+Check the PEFT Adapters API Reference section for a list of supported PEFT methods, and read the [Adapters](https://huggingface.co/docs/peft/en/conceptual_guides/adapter), [Soft prompts](https://huggingface.co/docs/peft/en/conceptual_guides/prompting), and [IA3](https://huggingface.co/docs/peft/en/conceptual_guides/ia3) conceptual guides to learn more about how these methods work.
+
+## Quickstart
+
+Install PEFT from pip:
+
+```bash
+pip install peft
+```
+
+Prepare a model for training with a PEFT method such as LoRA by wrapping the base model and PEFT configuration with `get_peft_model`. For the bigscience/mt0-large model, you're only training 0.19% of the parameters!
+
+```python
+from transformers import AutoModelForCausalLM
+from peft import LoraConfig, TaskType, get_peft_model
+
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+model_id = "Qwen/Qwen2.5-3B-Instruct"
+model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device)
+peft_config = LoraConfig(
+ r=16,
+ lora_alpha=32,
+ task_type=TaskType.CAUSAL_LM,
+ # target_modules=["q_proj", "v_proj", ...] # optionally indicate target modules
+)
+model = get_peft_model(model, peft_config)
+model.print_trainable_parameters()
+# prints: trainable params: 3,686,400 || all params: 3,089,625,088 || trainable%: 0.1193
+
+# now perform training on your dataset, e.g. using transformers Trainer, then save the model
+model.save_pretrained("qwen2.5-3b-lora")
+```
+
+To load a PEFT model for inference:
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import PeftModel
+
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+model_id = "Qwen/Qwen2.5-3B-Instruct"
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device)
+model = PeftModel.from_pretrained(model, "qwen2.5-3b-lora")
+
+inputs = tokenizer("Preheat the oven to 350 degrees and place the cookie dough", return_tensors="pt")
+outputs = model.generate(**inputs.to(device), max_new_tokens=50)
+print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+
+# prints something like: Preheat the oven to 350 degrees and place the cookie dough in a baking dish [...]
+```
+
+## Why you should use PEFT
+
+There are many benefits of using PEFT but the main one is the huge savings in compute and storage, making PEFT applicable to many different use cases.
+
+### High performance on consumer hardware
+
+Consider the memory requirements for training the following models on the [ought/raft/twitter_complaints](https://huggingface.co/datasets/ought/raft/viewer/twitter_complaints) dataset with an A100 80GB GPU with more than 64GB of CPU RAM.
+
+| Model | Full Finetuning | PEFT-LoRA PyTorch | PEFT-LoRA DeepSpeed with CPU Offloading |
+| --------- | ---- | ---- | ---- |
+| bigscience/T0_3B (3B params) | 47.14GB GPU / 2.96GB CPU | 14.4GB GPU / 2.96GB CPU | 9.8GB GPU / 17.8GB CPU |
+| bigscience/mt0-xxl (12B params) | OOM GPU | 56GB GPU / 3GB CPU | 22GB GPU / 52GB CPU |
+| bigscience/bloomz-7b1 (7B params) | OOM GPU | 32GB GPU / 3.8GB CPU | 18.1GB GPU / 35GB CPU |
+
+With LoRA you can fully finetune a 12B parameter model that would've otherwise run out of memory on the 80GB GPU, and comfortably fit and train a 3B parameter model. When you look at the 3B parameter model's performance, it is comparable to a fully finetuned model at a fraction of the GPU memory.
+
+| Submission Name | Accuracy |
+| --------- | ---- |
+| Human baseline (crowdsourced) | 0.897 |
+| Flan-T5 | 0.892 |
+| lora-t0-3b | 0.863 |
+
+> [!TIP]
+> The bigscience/T0_3B model performance isn't optimized in the table above. You can squeeze even more performance out of it by playing around with the input instruction templates, LoRA hyperparameters, and other training related hyperparameters. The final checkpoint size of this model is just 19MB compared to 11GB of the full bigscience/T0_3B model. Learn more about the advantages of finetuning with PEFT in this [blog post](https://www.philschmid.de/fine-tune-flan-t5-peft).
+
+### Quantization
+
+Quantization is another method for reducing the memory requirements of a model by representing the data in a lower precision. It can be combined with PEFT methods to make it even easier to train and load LLMs for inference.
+
+* Learn how to finetune [meta-llama/Llama-2-7b-hf](https://huggingface.co/meta-llama/Llama-2-7b-hf) with QLoRA and the [TRL](https://huggingface.co/docs/trl/index) library on a 16GB GPU in the [Finetune LLMs on your own consumer hardware using tools from PyTorch and Hugging Face ecosystem](https://pytorch.org/blog/finetune-llms/) blog post.
+* Learn how to finetune a [openai/whisper-large-v2](https://huggingface.co/openai/whisper-large-v2) model for multilingual automatic speech recognition with LoRA and 8-bit quantization in this [notebook](https://colab.research.google.com/drive/1DOkD_5OUjFa0r5Ik3SgywJLJtEo2qLxO?usp=sharing) (see this [notebook](https://colab.research.google.com/drive/1vhF8yueFqha3Y3CpTHN6q9EVcII9EYzs?usp=sharing) instead for an example of streaming a dataset).
+
+### Save compute and storage
+
+PEFT can help you save storage by avoiding full finetuning of models on each of downstream task or dataset. In many cases, you're only finetuning a very small fraction of a model's parameters and each checkpoint is only a few MBs in size (instead of GBs). These smaller PEFT adapters demonstrate performance comparable to a fully finetuned model. If you have many datasets, you can save a lot of storage with a PEFT model and not have to worry about catastrophic forgetting or overfitting the backbone or base model.
+
+## PEFT integrations
+
+PEFT is widely supported across the Hugging Face ecosystem because of the massive efficiency it brings to training and inference.
+
+### Diffusers
+
+The iterative diffusion process consumes a lot of memory which can make it difficult to train. PEFT can help reduce the memory requirements and reduce the storage size of the final model checkpoint. For example, consider the memory required for training a Stable Diffusion model with LoRA on an A100 80GB GPU with more than 64GB of CPU RAM. The final model checkpoint size is only 8.8MB!
+
+| Model | Full Finetuning | PEFT-LoRA | PEFT-LoRA with Gradient Checkpointing |
+| --------- | ---- | ---- | ---- |
+| CompVis/stable-diffusion-v1-4 | 27.5GB GPU / 3.97GB CPU | 15.5GB GPU / 3.84GB CPU | 8.12GB GPU / 3.77GB CPU |
+
+> [!TIP]
+> Take a look at the [examples/lora_dreambooth/train_dreambooth.py](examples/lora_dreambooth/train_dreambooth.py) training script to try training your own Stable Diffusion model with LoRA, and play around with the [smangrul/peft-lora-sd-dreambooth](https://huggingface.co/spaces/smangrul/peft-lora-sd-dreambooth) Space which is running on a T4 instance. Learn more about the PEFT integration in Diffusers in this [tutorial](https://huggingface.co/docs/peft/main/en/tutorial/peft_integrations#diffusers).
+
+### Transformers
+
+PEFT is directly integrated with [Transformers](https://huggingface.co/docs/transformers/main/en/peft). After loading a model, call `add_adapter` to add a new PEFT adapter to the model:
+
+```python
+from peft import LoraConfig
+model = ... # transformers model
+peft_config = LoraConfig(...)
+model.add_adapter(lora_config, adapter_name="lora_1")
+```
+
+To load a trained PEFT adapter, call `load_adapter`:
+
+```python
+model = ... # transformers model
+model.load_adapter(, adapter_name="lora_1")
+```
+
+And to switch between different adapters, call `set_adapter`:
+
+```python
+model.set_adapter("lora_2")
+```
+
+The Transformers integration doesn't include all the functionalities offered in PEFT, such as methods for merging the adapter into the base model.
+
+### Accelerate
+
+[Accelerate](https://huggingface.co/docs/accelerate/index) is a library for distributed training and inference on various training setups and hardware (GPUs, TPUs, Apple Silicon, etc.). PEFT models work with Accelerate out of the box, making it really convenient to train really large models or use them for inference on consumer hardware with limited resources.
+
+### TRL
+
+PEFT can also be applied to training LLMs with RLHF components such as the ranker and policy. Get started by reading:
+
+* [Fine-tune a Mistral-7b model with Direct Preference Optimization](https://towardsdatascience.com/fine-tune-a-mistral-7b-model-with-direct-preference-optimization-708042745aac) with PEFT and the [TRL](https://huggingface.co/docs/trl/index) library to learn more about the Direct Preference Optimization (DPO) method and how to apply it to a LLM.
+* [Fine-tuning 20B LLMs with RLHF on a 24GB consumer GPU](https://huggingface.co/blog/trl-peft) with PEFT and the [TRL](https://huggingface.co/docs/trl/index) library, and then try out the [gpt2-sentiment_peft.ipynb](https://github.com/huggingface/trl/blob/main/examples/notebooks/gpt2-sentiment.ipynb) notebook to optimize GPT2 to generate positive movie reviews.
+* [StackLLaMA: A hands-on guide to train LLaMA with RLHF](https://huggingface.co/blog/stackllama) with PEFT, and then try out the [stack_llama/scripts](https://github.com/huggingface/trl/tree/main/examples/research_projects/stack_llama/scripts) for supervised finetuning, reward modeling, and RL finetuning.
+
+## Model support
+
+Use this [Space](https://stevhliu-peft-methods.hf.space) or check out the [docs](https://huggingface.co/docs/peft/main/en/index) to find which models officially support a PEFT method out of the box. Even if you don't see a model listed below, you can manually configure the model config to enable PEFT for a model. Read the [New transformers architecture](https://huggingface.co/docs/peft/main/en/developer_guides/custom_models#new-transformers-architectures) guide to learn how.
+
+## Contribute
+
+If you would like to contribute to PEFT, please check out our [contribution guide](https://huggingface.co/docs/peft/developer_guides/contributing).
+
+## Citing 🤗 PEFT
+
+To use 🤗 PEFT in your publication, please cite it by using the following BibTeX entry.
+
+```bibtex
+@Misc{peft,
+ title = {{PEFT}: State-of-the-art Parameter-Efficient Fine-Tuning methods},
+ author = {Sourab Mangrulkar and Sylvain Gugger and Lysandre Debut and Younes Belkada and Sayak Paul and Benjamin Bossan and Marian Tietz},
+ howpublished = {\url{https://github.com/huggingface/peft}},
+ year = {2022}
+}
+```
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docker/README.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docker/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..02250eef44ece60f6b88f246985d5d5f7725f81e
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docker/README.md
@@ -0,0 +1,6 @@
+# PEFT Docker images
+
+Here we store all PEFT Docker images used in our testing infrastructure. We use python 3.11 for now on all our images.
+
+- `peft-cpu`: PEFT compiled on CPU with all other HF libraries installed on main branch
+- `peft-gpu`: PEFT complied for NVIDIA GPUs with all other HF libraries installed on main branch
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docker/peft-cpu/Dockerfile b/tasks/tasksmith-0d2d1e298e86/environment/source/docker/peft-cpu/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..ebc2a1b38800e5422c53321de89ca10a91425650
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docker/peft-cpu/Dockerfile
@@ -0,0 +1,46 @@
+# Builds GPU docker image of PyTorch
+# Uses multi-staged approach to reduce size
+# Stage 1
+# Use base conda image to reduce time
+FROM continuumio/miniconda3:latest AS compile-image
+# Specify py version
+ENV PYTHON_VERSION=3.11
+# Install apt libs - copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile
+RUN apt-get update && \
+ apt-get install -y curl git wget git-lfs ffmpeg libsndfile1-dev && \
+ apt-get clean && \
+ rm -rf /var/lib/apt/lists*
+
+RUN git lfs install
+
+# Create our conda env - copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile
+RUN conda create --name peft python=${PYTHON_VERSION} ipython jupyter pip
+RUN python3 -m pip install --no-cache-dir --upgrade pip
+
+# Below is copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile
+# We don't install pytorch here yet since CUDA isn't available
+# instead we use the direct torch wheel
+ENV PATH=/opt/conda/envs/peft/bin:$PATH
+# Activate our bash shell
+RUN chsh -s /bin/bash
+SHELL ["/bin/bash", "-c"]
+# Activate the conda env and install transformers + accelerate from source
+RUN source activate peft && \
+ python3 -m pip install --no-cache-dir \
+ librosa \
+ "soundfile>=0.12.1" \
+ scipy \
+ git+https://github.com/huggingface/transformers \
+ git+https://github.com/huggingface/accelerate \
+ peft[test]@git+https://github.com/huggingface/peft
+
+# Install apt libs
+RUN apt-get update && \
+ apt-get install -y curl git wget && \
+ apt-get clean && \
+ rm -rf /var/lib/apt/lists*
+
+RUN echo "source activate peft" >> ~/.profile
+
+# Activate the virtualenv
+CMD ["/bin/bash"]
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docker/peft-gpu/Dockerfile b/tasks/tasksmith-0d2d1e298e86/environment/source/docker/peft-gpu/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..0fa69997f71fa84bddd9970659d72a819ec06c58
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docker/peft-gpu/Dockerfile
@@ -0,0 +1,85 @@
+# Builds GPU docker image of PyTorch
+# Uses multi-staged approach to reduce size
+# Stage 1
+# Use base conda image to reduce time
+FROM continuumio/miniconda3:latest AS compile-image
+# Specify py version
+ENV PYTHON_VERSION=3.11
+# Install apt libs - copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile
+# Install audio-related libraries
+RUN apt-get update && \
+ apt-get install -y curl git wget git-lfs ffmpeg libsndfile1-dev && \
+ apt-get clean && \
+ rm -rf /var/lib/apt/lists*
+
+RUN git lfs install
+
+# Create our conda env - copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile
+RUN conda create --name peft python=${PYTHON_VERSION} ipython jupyter pip
+
+# Below is copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile
+# We don't install pytorch here yet since CUDA isn't available
+# instead we use the direct torch wheel
+ENV PATH=/opt/conda/envs/peft/bin:$PATH
+# Activate our bash shell
+RUN chsh -s /bin/bash
+SHELL ["/bin/bash", "-c"]
+
+# Stage 2
+FROM nvidia/cuda:13.2.1-cudnn-devel-ubuntu24.04 AS build-image
+COPY --from=compile-image /opt/conda /opt/conda
+ENV PATH=/opt/conda/bin:$PATH
+
+# Install apt libs
+RUN apt-get update && \
+ apt-get install -y curl git wget && \
+ apt-get clean && \
+ rm -rf /var/lib/apt/lists*
+
+RUN chsh -s /bin/bash
+SHELL ["/bin/bash", "-c"]
+
+RUN conda run -n peft pip install --no-cache-dir bitsandbytes optimum
+
+# Note: we are hard-coding CUDA_ARCH_LIST here since `gptqmodel` requires either nvidia-smi
+# or CUDA_ARCH_LIST for compute capability information. Since the docker build is unlikely
+# to have compute hardware available we use the information from the CI runner (which hosts
+# a NVIDIA L4). So we fix the compute capability to 8.9. In the future we might extend this
+# to a list of compute capabilities (separated by ;).
+# TODO pcre, which is used by gptqmodel, is resulting in a core dump, remove once it's resolved
+# RUN CUDA_ARCH_LIST=8.9 conda run -n peft pip install "gptqmodel>=7.0.0"
+
+RUN \
+ # Add eetq for quantization testing; needs to run without build isolation since the setup
+ # script directly imports torch from the environment which would fail with isolation.
+ # Ninja should speed up build time.
+ conda run -n peft pip install ninja kernels && conda run -n peft pip install --no-build-isolation git+https://github.com/NetEase-FuXi/EETQ.git
+
+# TODO: Importing TE results in: undefined symbol: cublasLtGroupedMatrixLayoutInit_internal, version libcublasLt.so.13
+# Reinstate TE when the issue is resolved (probably this one: https://github.com/NVIDIA/TransformerEngine/issues/2504)
+# RUN NVTE_BUILD_USE_NVIDIA_WHEELS=1 \
+# CPATH="/usr/local/cuda/include:${CPATH}" \
+# conda run -n peft pip install --no-build-isolation "transformer_engine[pytorch]"
+
+# Activate the conda env and install transformers + accelerate from source
+RUN conda run -n peft pip install -U --no-cache-dir \
+ librosa \
+ "soundfile>=0.12.1" \
+ scipy \
+ torchao \
+ "fbgemm-gpu-genai>=1.2.0" \
+ git+https://github.com/huggingface/transformers \
+ git+https://github.com/huggingface/accelerate \
+ peft[test]@git+https://github.com/huggingface/peft \
+ # Add aqlm for quantization testing
+ aqlm[gpu]>=1.0.2 \
+ # Add HQQ for quantization testing
+ hqq \
+ deepspeed
+
+RUN conda run -n peft pip freeze | grep transformers
+
+RUN echo "source activate peft" >> ~/.profile
+
+# Activate the virtualenv
+CMD ["/bin/bash"]
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/Makefile b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..8879933e6cda150267451c9e7d07dd22b7b0d3f1
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/Makefile
@@ -0,0 +1,19 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS =
+SPHINXBUILD = sphinx-build
+SOURCEDIR = source
+BUILDDIR = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+ @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+ @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/README.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..0b76173a66db251756401a35e1dfef5ae69794bb
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/README.md
@@ -0,0 +1,267 @@
+
+
+# Generating the documentation
+
+To generate the documentation, you first have to build it. Several packages are necessary to build the doc,
+you can install them with the following command, at the root of the code repository:
+
+```bash
+pip install -e ".[docs]"
+```
+
+Then you need to install our special tool that builds the documentation:
+
+```bash
+pip install git+https://github.com/huggingface/doc-builder
+```
+
+---
+**NOTE**
+
+You only need to generate the documentation to inspect it locally (if you're planning changes and want to
+check how they look before committing for instance). You don't have to commit to the built documentation.
+
+---
+
+## Building the documentation
+
+Once you have setup the `doc-builder` and additional packages, you can generate the documentation by
+typing the following command:
+
+```bash
+doc-builder build peft docs/source/ --build_dir ~/tmp/test-build
+```
+
+You can adapt the `--build_dir` to set any temporary folder you prefer. This command will create it and generate
+the MDX files that will be rendered as the documentation on the main website. You can inspect them in your favorite
+Markdown editor.
+
+## Previewing the documentation
+
+To preview the docs, first install the `watchdog` module with:
+
+```bash
+pip install watchdog
+```
+
+Then run the following command:
+
+```bash
+doc-builder preview {package_name} {path_to_docs}
+```
+
+For example:
+
+```bash
+doc-builder preview peft docs/source
+```
+
+The docs will be viewable at [http://localhost:3000](http://localhost:3000). You can also preview the docs once you have opened a PR. You will see a bot add a comment to a link where the documentation with your changes lives.
+
+---
+**NOTE**
+
+The `preview` command only works with existing doc files. When you add a completely new file, you need to update `_toctree.yml` & restart `preview` command (`ctrl-c` to stop it & call `doc-builder preview ...` again).
+
+---
+
+## Adding a new element to the navigation bar
+
+Accepted files are Markdown (.md or .mdx).
+
+Create a file with its extension and put it in the source directory. You can then link it to the toc-tree by putting
+the filename without the extension in the [`_toctree.yml`](https://github.com/huggingface/peft/blob/main/docs/source/_toctree.yml) file.
+
+## Renaming section headers and moving sections
+
+It helps to keep the old links working when renaming the section header and/or moving sections from one document to another. This is because the old links are likely to be used in Issues, Forums, and Social media and it'd make for a much more superior user experience if users reading those months later could still easily navigate to the originally intended information.
+
+Therefore, we simply keep a little map of moved sections at the end of the document where the original section was. The key is to preserve the original anchor.
+
+So if you renamed a section from: "Section A" to "Section B", then you can add at the end of the file:
+
+```
+Sections that were moved:
+
+[ Section A ]
+```
+and of course, if you moved it to another file, then:
+
+```
+Sections that were moved:
+
+[ Section A ]
+```
+
+Use the relative style to link to the new file so that the versioned docs continue to work.
+
+
+## Writing Documentation - Specification
+
+The `huggingface/peft` documentation follows the
+[Google documentation](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html) style for docstrings,
+although we can write them directly in Markdown.
+
+### Adding a new tutorial
+
+Adding a new tutorial or section is done in two steps:
+
+- Add a new file under `./source`. This file can either be ReStructuredText (.rst) or Markdown (.md).
+- Link that file in `./source/_toctree.yml` on the correct toc-tree.
+
+Make sure to put your new file under the proper section. It's unlikely to go in the first section (*Get Started*), so
+depending on the intended targets (beginners, more advanced users, or researchers) it should go into sections two, three, or
+four.
+
+### Writing source documentation
+
+Values that should be put in `code` should either be surrounded by backticks: \`like so\`. Note that argument names
+and objects like True, None, or any strings should usually be put in `code`.
+
+When mentioning a class, function, or method, it is recommended to use our syntax for internal links so that our tool
+adds a link to its documentation with this syntax: \[\`XXXClass\`\] or \[\`function\`\]. This requires the class or
+function to be in the main package.
+
+If you want to create a link to some internal class or function, you need to
+provide its path. For instance: \[\`utils.gather\`\]. This will be converted into a link with
+`utils.gather` in the description. To get rid of the path and only keep the name of the object you are
+linking to in the description, add a ~: \[\`~utils.gather\`\] will generate a link with `gather` in the description.
+
+The same works for methods so you can either use \[\`XXXClass.method\`\] or \[~\`XXXClass.method\`\].
+
+#### Defining arguments in a method
+
+Arguments should be defined with the `Args:` (or `Arguments:` or `Parameters:`) prefix, followed by a line return and
+an indentation. The argument should be followed by its type, with its shape if it is a tensor, a colon, and its
+description:
+
+```
+ Args:
+ n_layers (`int`): The number of layers of the model.
+```
+
+If the description is too long to fit in one line (more than 119 characters in total), another indentation is necessary
+before writing the description after the argument.
+
+Finally, to maintain uniformity if any *one* description is too long to fit on one line, the
+rest of the parameters should follow suit and have an indention before their description.
+
+Here's an example showcasing everything so far:
+
+```
+ Args:
+ gradient_accumulation_steps (`int`, *optional*, default to 1):
+ The number of steps that should pass before gradients are accumulated. A number > 1 should be combined with `Accelerator.accumulate`.
+ cpu (`bool`, *optional*):
+ Whether or not to force the script to execute on CPU. Will ignore GPU available if set to `True` and force the execution on one process only.
+```
+
+For optional arguments or arguments with defaults we follow the following syntax: imagine we have a function with the
+following signature:
+
+```
+def my_function(x: str = None, a: float = 1):
+```
+
+then its documentation should look like this:
+
+```
+ Args:
+ x (`str`, *optional*):
+ This argument controls ... and has a description longer than 119 chars.
+ a (`float`, *optional*, defaults to 1):
+ This argument is used to ... and has a description longer than 119 chars.
+```
+
+Note that we always omit the "defaults to \`None\`" when None is the default for any argument. Also note that even
+if the first line describing your argument type and its default gets long, you can't break it into several lines. You can
+however write as many lines as you want in the indented description (see the example above with `input_ids`).
+
+#### Writing a multi-line code block
+
+Multi-line code blocks can be useful for displaying examples. They are done between two lines of three backticks as usual in Markdown:
+
+
+````
+```python
+# first line of code
+# second line
+# etc
+```
+````
+
+#### Writing a return block
+
+The return block should be introduced with the `Returns:` prefix, followed by a line return and an indentation.
+The first line should be the type of the return, followed by a line return. No need to indent further for the elements
+building the return.
+
+Here's an example of a single value return:
+
+```
+ Returns:
+ `List[int]`: A list of integers in the range [0, 1] --- 1 for a special token, 0 for a sequence token.
+```
+
+Here's an example of a tuple return, comprising several objects:
+
+```
+ Returns:
+ `tuple(torch.FloatTensor)` comprising various elements depending on the configuration ([`BertConfig`]) and inputs:
+ - ** loss** (*optional*, returned when `masked_lm_labels` is provided) `torch.FloatTensor` of shape `(1,)` --
+ Total loss is the sum of the masked language modeling loss and the next sequence prediction (classification) loss.
+ - **prediction_scores** (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`) --
+ Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
+```
+
+## Styling the docstring
+
+We have an automatic script running with the `make style` comment that will make sure that:
+- the docstrings fully take advantage of the line width
+- all code examples are formatted using black, like the code of the Transformers library
+
+This script may have some weird failures if you make a syntax mistake or if you uncover a bug. Therefore, it's
+recommended to commit your changes before running `make style`, so you can revert the changes done by that script
+easily.
+
+## Writing documentation examples
+
+The syntax, for example, docstrings can look as follows:
+
+```
+ Example:
+
+ ```python
+ >>> import time
+ >>> from accelerate import Accelerator
+ >>> accelerator = Accelerator()
+ >>> if accelerator.is_main_process:
+ ... time.sleep(2)
+ >>> else:
+ ... print("I'm waiting for the main process to finish its sleep...")
+ >>> accelerator.wait_for_everyone()
+ >>> # Should print on every process at the same time
+ >>> print("Everyone is here")
+ ```
+```
+
+The docstring should give a minimal, clear example of how the respective function
+is to be used in inference and also include the expected (ideally sensible)
+output.
+Often, readers will try out the example before even going through the function
+or class definitions. Therefore, it is of utmost importance that the example
+works as expected.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/_config.py b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..2974756ce8d5964a46caf9190b6cd0a207cc2fa0
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/_config.py
@@ -0,0 +1,7 @@
+# docstyle-ignore
+INSTALL_CONTENT = """
+# PEFT installation
+! pip install peft accelerate transformers
+# To install from source instead of the last release, comment the command above and uncomment the following one.
+# ! pip install git+https://github.com/huggingface/peft.git
+"""
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/_redirects.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/_redirects.yml
new file mode 100644
index 0000000000000000000000000000000000000000..7408cd064fd022c251d972d6accd42eaf97043cc
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/_redirects.yml
@@ -0,0 +1,3 @@
+conceptual_guides/adapter: package_reference/lora
+conceptual_guides/ia3: package_reference/ia3
+developer_guides/lora: package_reference/lora
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/_toctree.yml b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/_toctree.yml
new file mode 100644
index 0000000000000000000000000000000000000000..1f43caf09c7216de0bc5a56112ea197c581a2ddc
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/_toctree.yml
@@ -0,0 +1,264 @@
+- title: Get started
+ sections:
+ - local: index
+ title: 🤗 PEFT
+ - local: quicktour
+ title: Quicktour
+ - local: install
+ title: Installation
+
+- title: Guides
+ sections:
+ - local: guides/peft_model_config
+ title: Configurations and models
+ - local: guides/peft_integrations
+ title: Integrations
+ - sections:
+ - local: accelerate/deepspeed
+ title: DeepSpeed
+ - local: accelerate/fsdp
+ title: Fully Sharded Data Parallel
+ title: Distributed Training
+ - local: developer_guides/memory_efficient_training
+ title: Memory Efficient Training
+ - local: developer_guides/model_merging
+ title: Model merging
+ - local: developer_guides/quantization
+ title: Quantization
+ - local: developer_guides/custom_models
+ title: Custom models
+ - local: developer_guides/low_level_api
+ title: Adapter injection
+ - local: developer_guides/mixed_models
+ title: Mixing PEFT methods
+ - local: developer_guides/torch_compile
+ title: torch.compile
+ - local: developer_guides/contributing
+ title: Contribute to PEFT
+ - local: developer_guides/troubleshooting
+ title: Troubleshooting
+ - local: developer_guides/checkpoint
+ title: PEFT checkpoint format
+
+- title: Methods
+ sections:
+ - local: methods/overview
+ title: Overview
+ - sections:
+ - local: package_reference/cartridges
+ title: Cartridges
+ - local: package_reference/cpt
+ title: CPT
+ - local: package_reference/llama_adapter
+ title: Llama-Adapter
+ - local: package_reference/p_tuning
+ title: P-Tuning
+ - local: package_reference/prefix_tuning
+ title: Prefix tuning
+ - local: package_reference/prompt_tuning
+ title: Prompt tuning
+ title: Soft Prompting
+ - sections:
+ - local: package_reference/beft
+ title: BEFT
+ - local: package_reference/layernorm_tuning
+ title: LayerNorm Tuning
+ - local: package_reference/trainable_tokens
+ title: Trainable Tokens
+ title: Layer Tuning
+ - sections:
+ - local: package_reference/adalora
+ title: AdaLoRA
+ - local: package_reference/adamss
+ title: AdaMSS
+ - local: package_reference/boft
+ title: BOFT
+ - local: package_reference/c3a
+ title: C3A
+ - local: package_reference/delora
+ title: DeLoRA
+ - local: package_reference/fourierft
+ title: FourierFT
+ - local: package_reference/gralora
+ title: GraLoRA
+ - local: package_reference/hira
+ title: HiRA
+ - local: package_reference/hra
+ title: HRA
+ - local: package_reference/ia3
+ title: IA3
+ - local: package_reference/lily
+ title: Lily
+ - local: package_reference/loha
+ title: LoHa
+ - local: package_reference/lokr
+ title: LoKr
+ - sections:
+ - local: package_reference/lora
+ title: LoRA
+ - local: package_reference/lora_variant_bdlora
+ title: "Variant: BD-LoRA"
+ - local: package_reference/lora_variant_dora
+ title: "Variant: DoRA"
+ - local: package_reference/lora_variant_monteclora
+ title: "Variant: MonteCLoRA"
+ - local: package_reference/lora_variant_velora
+ title: "Variant: VeLoRA"
+ title: LoRA
+ - local: package_reference/miss
+ title: MiSS
+ - local: package_reference/oft
+ title: OFT
+ - local: package_reference/osf
+ title: OSF
+ - local: package_reference/peanut
+ title: PEANuT
+ - local: package_reference/poly
+ title: Polytropon
+ - local: package_reference/psoft
+ title: PSOFT
+ - local: package_reference/pvera
+ title: PVeRA
+ - local: package_reference/randlora
+ title: RandLora
+ - local: package_reference/road
+ title: RoAd
+ - local: package_reference/shira
+ title: SHiRA
+ - local: package_reference/tinylora
+ title: TinyLoRA
+ - local: package_reference/vblora
+ title: VB-LoRA
+ - local: package_reference/vera
+ title: VeRA
+ - local: package_reference/waveft
+ title: WaveFT
+ - local: package_reference/xlora
+ title: X-LoRA
+ title: Adapters
+
+- isExpanded: false
+ sections:
+ - sections:
+ - local: package_reference/auto_class
+ title: AutoPeftModel
+ - local: package_reference/peft_model
+ title: PEFT model
+ - local: package_reference/peft_types
+ title: PEFT types
+ - local: package_reference/config
+ title: Configuration
+ - local: package_reference/tuners
+ title: Tuner
+ title: Main classes
+ - sections:
+ - local: package_reference/adalora
+ title: AdaLoRA
+ - local: package_reference/adamss
+ title: AdaMSS
+ - local: package_reference/beft
+ title: BEFT
+ - local: package_reference/boft
+ title: BOFT
+ - local: package_reference/c3a
+ title: C3A
+ - local: package_reference/cartridges
+ title: Cartridges
+ - local: package_reference/cpt
+ title: CPT
+ - local: package_reference/delora
+ title: DeLoRA
+ - local: package_reference/fourierft
+ title: FourierFT
+ - local: package_reference/gralora
+ title: GraLoRA
+ - local: package_reference/hira
+ title: HiRA
+ - local: package_reference/hra
+ title: HRA
+ - local: package_reference/ia3
+ title: IA3
+ - local: package_reference/layernorm_tuning
+ title: Layernorm tuning
+ - local: package_reference/lily
+ title: Lily
+ - local: package_reference/llama_adapter
+ title: Llama-Adapter
+ - local: package_reference/loha
+ title: LoHa
+ - local: package_reference/lokr
+ title: LoKr
+ - local: package_reference/lora
+ title: LoRA
+ - local: package_reference/adapter_utils
+ title: LyCORIS
+ - local: package_reference/miss
+ title: MiSS
+ - local: package_reference/multitask_prompt_tuning
+ title: Multitask Prompt Tuning
+ - local: package_reference/oft
+ title: OFT
+ - local: package_reference/osf
+ title: OSF
+ - local: package_reference/p_tuning
+ title: P-tuning
+ - local: package_reference/peanut
+ title: PEANuT
+ - local: package_reference/poly
+ title: Polytropon
+ - local: package_reference/prefix_tuning
+ title: Prefix tuning
+ - local: package_reference/prompt_tuning
+ title: Prompt tuning
+ - local: package_reference/psoft
+ title: PSOFT
+ - local: package_reference/pvera
+ title: PVeRA
+ - local: package_reference/fourierft
+ title: FourierFT
+ - local: package_reference/frod
+ title: FRoD
+ - local: package_reference/gralora
+ title: GraLoRA
+ - local: package_reference/vblora
+ title: VB-LoRA
+ - local: package_reference/hira
+ title: HiRA
+ - local: package_reference/hra
+ title: HRA
+ - local: package_reference/cpt
+ title: CPT
+ - local: package_reference/trainable_tokens
+ title: Trainable Tokens
+ - local: package_reference/randlora
+ title: RandLora
+ - local: package_reference/road
+ title: RoAd
+ - local: package_reference/shira
+ title: SHiRA
+ - local: package_reference/tinylora
+ title: TinyLoRA
+ - local: package_reference/trainable_tokens
+ title: Trainable Tokens
+ - local: package_reference/vblora
+ title: VB-LoRA
+ - local: package_reference/vera
+ title: VeRA
+ - local: package_reference/waveft
+ title: WaveFT
+ - local: package_reference/xlora
+ title: X-LoRA
+ title: Tuners
+ - sections:
+ - local: package_reference/merge_utils
+ title: Model merge
+ - local: package_reference/helpers
+ title: Helpers
+ - local: package_reference/hotswap
+ title: Hotswapping adapters
+ - local: package_reference/functional
+ title: Functions for PEFT integration
+ - local: package_reference/lora_conversion
+ title: Converting non-LoRA adapters to LoRA
+ title: Utilities
+ title: API reference
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/accelerate/deepspeed.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/accelerate/deepspeed.md
new file mode 100644
index 0000000000000000000000000000000000000000..40c7e435cc7c0bd02601e89bafaeb2dd46b5ccf5
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/accelerate/deepspeed.md
@@ -0,0 +1,449 @@
+
+
+# DeepSpeed
+
+[DeepSpeed](https://www.deepspeed.ai/) is a library designed for speed and scale for distributed training of large models with billions of parameters. At its core is the Zero Redundancy Optimizer (ZeRO) that shards optimizer states (ZeRO-1), gradients (ZeRO-2), and parameters (ZeRO-3) across data parallel processes. This drastically reduces memory usage, allowing you to scale your training to billion parameter models. To unlock even more memory efficiency, ZeRO-Offload reduces GPU compute and memory by leveraging CPU resources during optimization.
+
+Both of these features are supported in 🤗 Accelerate, and you can use them with 🤗 PEFT.
+
+## Compatibility with `bitsandbytes` quantization + LoRA
+
+Below is a table that summarizes the compatibility between PEFT's LoRA, [`bitsandbytes`](https://github.com/TimDettmers/bitsandbytes) library and DeepSpeed Zero stages with respect to fine-tuning. DeepSpeed Zero-1 and 2 will have no effect at inference as stage 1 shards the optimizer states and stage 2 shards the optimizer states and gradients:
+
+| DeepSpeed stage | Is compatible? |
+|---|---|
+| Zero-1 | 🟢 |
+| Zero-2 | 🟢 |
+| Zero-3 | 🟢 |
+
+For DeepSpeed Stage 3 + QLoRA, please refer to the section [Use PEFT QLoRA and DeepSpeed with ZeRO3 for finetuning large models on multiple GPUs](#use-peft-qlora-and-deepspeed-with-zero3-for-finetuning-large-models-on-multiple-gpus) below.
+
+For confirming these observations, we ran the SFT (Supervised Fine-tuning) [official example scripts](https://github.com/huggingface/trl/tree/main/examples) of the [Transformers Reinforcement Learning (TRL) library](https://github.com/huggingface/trl) using QLoRA + PEFT and the accelerate configs available [here](https://github.com/huggingface/trl/tree/main/examples/accelerate_configs). We ran these experiments on a 2x NVIDIA T4 GPU.
+
+# Use PEFT and DeepSpeed with ZeRO3 for finetuning large models on multiple devices and multiple nodes
+
+This section of guide will help you learn how to use our DeepSpeed [training script](https://github.com/huggingface/peft/blob/main/examples/sft/train.py) for performing SFT. You'll configure the script to do SFT (supervised fine-tuning) of Llama-70B model with LoRA and ZeRO-3 on 8xH100 80GB GPUs on a single machine. You can configure it to scale to multiple machines by changing the accelerate config.
+
+## Configuration
+
+Start by running the following command to [create a DeepSpeed configuration file](https://huggingface.co/docs/accelerate/quicktour#launching-your-distributed-script) with 🤗 Accelerate. The `--config_file` flag allows you to save the configuration file to a specific location, otherwise it is saved as a `default_config.yaml` file in the 🤗 Accelerate cache.
+
+The configuration file is used to set the default options when you launch the training script.
+
+```bash
+accelerate config --config_file deepspeed_config.yaml
+```
+
+You'll be asked a few questions about your setup, and configure the following arguments. In this example, you'll use ZeRO-3 so make sure you pick those options.
+
+```bash
+`zero_stage`: [0] Disabled, [1] optimizer state partitioning, [2] optimizer+gradient state partitioning and [3] optimizer+gradient+parameter partitioning
+`gradient_accumulation_steps`: Number of training steps to accumulate gradients before averaging and applying them. Pass the same value as you would pass via cmd argument else you will encounter mismatch error.
+`gradient_clipping`: Enable gradient clipping with value. Don't set this as you will be passing it via cmd arguments.
+`offload_optimizer_device`: [none] Disable optimizer offloading, [cpu] offload optimizer to CPU, [nvme] offload optimizer to NVMe SSD. Only applicable with ZeRO >= Stage-2. Set this as `none` as don't want to enable offloading.
+`offload_param_device`: [none] Disable parameter offloading, [cpu] offload parameters to CPU, [nvme] offload parameters to NVMe SSD. Only applicable with ZeRO Stage-3. Set this as `none` as don't want to enable offloading.
+`zero3_init_flag`: Decides whether to enable `deepspeed.zero.Init` for constructing massive models. Only applicable with ZeRO Stage-3. Set this to `True`.
+`zero3_save_16bit_model`: Decides whether to save 16-bit model weights when using ZeRO Stage-3. Set this to `True`.
+`mixed_precision`: `no` for FP32 training, `fp16` for FP16 mixed-precision training and `bf16` for BF16 mixed-precision training. Set this to `True`.
+```
+
+Once this is done, the corresponding config should look like below and you can find it in config folder at [deepspeed_config.yaml](https://github.com/huggingface/peft/blob/main/examples/sft/configs/deepspeed_config.yaml):
+
+```yml
+compute_environment: LOCAL_MACHINE
+debug: false
+deepspeed_config:
+ deepspeed_multinode_launcher: standard
+ gradient_accumulation_steps: 4
+ offload_optimizer_device: none
+ offload_param_device: none
+ zero3_init_flag: true
+ zero3_save_16bit_model: true
+ zero_stage: 3
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 8
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
+```
+
+## Launch command
+
+The launch command is available at [run_peft_deepspeed.sh](https://github.com/huggingface/peft/blob/main/examples/sft/run_peft_deepspeed.sh) and it is also shown below:
+```bash
+accelerate launch --config_file "configs/deepspeed_config.yaml" train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_seq_len 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "llama-sft-lora-deepspeed" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 4 \
+--gradient_checkpointing True \
+--use_reentrant False \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization False
+```
+
+Notice that we are using LoRA with rank=8, alpha=16 and targeting all linear layers. We are passing the deepspeed config file and finetuning 70B Llama model on a subset of the ultrachat dataset.
+
+## The important parts
+
+Let's dive a little deeper into the script so you can see what's going on, and understand how it works.
+
+The first thing to know is that the script uses DeepSpeed for distributed training as the DeepSpeed config has been passed. The [`~trl.SFTTrainer`] class handles all the heavy lifting of creating the PEFT model using the peft config that is passed. After that, when you call `trainer.train()`, [`~trl.SFTTrainer`] internally uses 🤗 Accelerate to prepare the model, optimizer and trainer using the DeepSpeed config to create DeepSpeed engine which is then trained. The main code snippet is below:
+
+```python
+# trainer
+trainer = SFTTrainer(
+ model=model,
+ processing_class=tokenizer,
+ args=training_args,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ peft_config=peft_config,
+)
+trainer.accelerator.print(f"{trainer.model}")
+
+# train
+checkpoint = None
+if training_args.resume_from_checkpoint is not None:
+ checkpoint = training_args.resume_from_checkpoint
+trainer.train(resume_from_checkpoint=checkpoint)
+
+# saving final model
+trainer.save_model()
+```
+
+## Memory usage
+
+In the above example, the memory consumed per GPU is 64 GB (80%) as seen in the screenshot below:
+
+
+
+
+GPU memory usage for the training run
+
+## More resources
+You can also refer this blog post [Falcon 180B Finetuning using 🤗 PEFT and DeepSpeed](https://medium.com/@sourabmangrulkar/falcon-180b-finetuning-using-peft-and-deepspeed-b92643091d99) on how to finetune 180B Falcon model on 16 A100 GPUs on 2 machines.
+
+
+# Use PEFT QLoRA and DeepSpeed with ZeRO3 for finetuning large models on multiple GPUs
+
+In this section, we will look at how to use QLoRA and DeepSpeed Stage-3 for finetuning 70B llama model on 2X40GB GPUs.
+For this, we first need `bitsandbytes>=0.43.3`, `accelerate>=1.0.1`, `transformers>4.44.2`, `trl>0.11.4` and `peft>0.13.0`. We need to set `zero3_init_flag` to true when using Accelerate config. Below is the config which can be found at [deepspeed_config_z3_qlora.yaml](https://github.com/huggingface/peft/blob/main/examples/sft/configs/deepspeed_config_z3_qlora.yaml):
+
+```yml
+compute_environment: LOCAL_MACHINE
+debug: false
+deepspeed_config:
+ deepspeed_multinode_launcher: standard
+ offload_optimizer_device: none
+ offload_param_device: none
+ zero3_init_flag: true
+ zero3_save_16bit_model: true
+ zero_stage: 3
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 2
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
+```
+
+Launch command is given below which is available at [run_peft_qlora_deepspeed_stage3.sh](https://github.com/huggingface/peft/blob/main/examples/sft/run_peft_qlora_deepspeed_stage3.sh):
+```
+accelerate launch --config_file "configs/deepspeed_config_z3_qlora.yaml" train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_seq_len 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "llama-sft-qlora-dsz3" \
+--per_device_train_batch_size 2 \
+--per_device_eval_batch_size 2 \
+--gradient_accumulation_steps 2 \
+--gradient_checkpointing True \
+--use_reentrant True \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--bnb_4bit_quant_storage_dtype "bfloat16"
+```
+
+Notice the new argument being passed `bnb_4bit_quant_storage_dtype` which denotes the data type for packing the 4-bit parameters. For example, when it is set to `bfloat16`, **32/4 = 8** 4-bit params are packed together post quantization.
+
+In terms of training code, the important code changes are:
+
+```diff
+...
+
+bnb_config = BitsAndBytesConfig(
+ load_in_4bit=args.use_4bit_quantization,
+ bnb_4bit_quant_type=args.bnb_4bit_quant_type,
+ bnb_4bit_compute_dtype=compute_dtype,
+ bnb_4bit_use_double_quant=args.use_nested_quant,
++ bnb_4bit_quant_storage=quant_storage_dtype,
+)
+
+...
+
+model = AutoModelForCausalLM.from_pretrained(
+ args.model_name_or_path,
+ quantization_config=bnb_config,
+ trust_remote_code=True,
+ attn_implementation="flash_attention_2" if args.use_flash_attn else "eager",
++ dtype=quant_storage_dtype or torch.float32,
+)
+```
+
+Notice that `dtype` for `AutoModelForCausalLM` is same as the `bnb_4bit_quant_storage` data type. That's it. Everything else is handled by Trainer and TRL.
+
+## Memory usage
+
+In the above example, the memory consumed per GPU is **36.6 GB**. Therefore, what took 8X80GB GPUs with DeepSpeed Stage 3+LoRA and a couple of 80GB GPUs with DDP+QLoRA now requires 2X40GB GPUs. This makes finetuning of large models more accessible.
+
+# Use PEFT and DeepSpeed with ZeRO3 and CPU Offloading for finetuning large models on a single GPU
+This section of guide will help you learn how to use our DeepSpeed [training script](https://github.com/huggingface/peft/blob/main/examples/conditional_generation/peft_lora_seq2seq_accelerate_ds_zero3_offload.py). You'll configure the script to train a large model for conditional generation with ZeRO-3 and CPU Offload.
+
+> [!TIP]
+> 💡 To help you get started, check out our example training scripts for [causal language modeling](https://github.com/huggingface/peft/blob/main/examples/causal_language_modeling/peft_lora_clm_accelerate_ds_zero3_offload.py) and [conditional generation](https://github.com/huggingface/peft/blob/main/examples/conditional_generation/peft_lora_seq2seq_accelerate_ds_zero3_offload.py). You can adapt these scripts for your own applications or even use them out of the box if your task is similar to the one in the scripts.
+
+## Configuration
+
+Start by running the following command to [create a DeepSpeed configuration file](https://huggingface.co/docs/accelerate/quicktour#launching-your-distributed-script) with 🤗 Accelerate. The `--config_file` flag allows you to save the configuration file to a specific location, otherwise it is saved as a `default_config.yaml` file in the 🤗 Accelerate cache.
+
+The configuration file is used to set the default options when you launch the training script.
+
+```bash
+accelerate config --config_file ds_zero3_cpu.yaml
+```
+
+You'll be asked a few questions about your setup, and configure the following arguments. In this example, you'll use ZeRO-3 along with CPU-Offload so make sure you pick those options.
+
+```bash
+`zero_stage`: [0] Disabled, [1] optimizer state partitioning, [2] optimizer+gradient state partitioning and [3] optimizer+gradient+parameter partitioning
+`gradient_accumulation_steps`: Number of training steps to accumulate gradients before averaging and applying them.
+`gradient_clipping`: Enable gradient clipping with value.
+`offload_optimizer_device`: [none] Disable optimizer offloading, [cpu] offload optimizer to CPU, [nvme] offload optimizer to NVMe SSD. Only applicable with ZeRO >= Stage-2.
+`offload_param_device`: [none] Disable parameter offloading, [cpu] offload parameters to CPU, [nvme] offload parameters to NVMe SSD. Only applicable with ZeRO Stage-3.
+`zero3_init_flag`: Decides whether to enable `deepspeed.zero.Init` for constructing massive models. Only applicable with ZeRO Stage-3.
+`zero3_save_16bit_model`: Decides whether to save 16-bit model weights when using ZeRO Stage-3.
+`mixed_precision`: `no` for FP32 training, `fp16` for FP16 mixed-precision training and `bf16` for BF16 mixed-precision training.
+```
+
+An example [configuration file](https://github.com/huggingface/peft/blob/main/examples/conditional_generation/accelerate_ds_zero3_cpu_offload_config.yaml) might look like the following. The most important thing to notice is that `zero_stage` is set to `3`, and `offload_optimizer_device` and `offload_param_device` are set to the `cpu`.
+
+```yml
+compute_environment: LOCAL_MACHINE
+deepspeed_config:
+ gradient_accumulation_steps: 1
+ gradient_clipping: 1.0
+ offload_optimizer_device: cpu
+ offload_param_device: cpu
+ zero3_init_flag: true
+ zero3_save_16bit_model: true
+ zero_stage: 3
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+dynamo_backend: 'NO'
+fsdp_config: {}
+machine_rank: 0
+main_training_function: main
+megatron_lm_config: {}
+mixed_precision: 'no'
+num_machines: 1
+num_processes: 1
+rdzv_backend: static
+same_network: true
+use_cpu: false
+```
+
+## The important parts
+
+Let's dive a little deeper into the script so you can see what's going on, and understand how it works.
+
+Within the [`main`](https://github.com/huggingface/peft/blob/2822398fbe896f25d4dac5e468624dc5fd65a51b/examples/conditional_generation/peft_lora_seq2seq_accelerate_ds_zero3_offload.py#L103) function, the script creates an [`~accelerate.Accelerator`] class to initialize all the necessary requirements for distributed training.
+
+> [!TIP]
+> 💡 Feel free to change the model and dataset inside the `main` function. If your dataset format is different from the one in the script, you may also need to write your own preprocessing function.
+
+The script also creates a configuration for the 🤗 PEFT method you're using, which in this case, is LoRA. The [`LoraConfig`] specifies the task type and important parameters such as the dimension of the low-rank matrices, the matrices scaling factor, and the dropout probability of the LoRA layers. If you want to use a different 🤗 PEFT method, make sure you replace `LoraConfig` with the appropriate [class](../package_reference/tuners).
+
+```diff
+ def main():
++ accelerator = Accelerator()
+ model_name_or_path = "facebook/bart-large"
+ dataset_name = "twitter_complaints"
++ peft_config = LoraConfig(
+ task_type=TaskType.SEQ_2_SEQ_LM, inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1
+ )
+```
+
+Throughout the script, you'll see the [`~accelerate.Accelerator.main_process_first`] and [`~accelerate.Accelerator.wait_for_everyone`] functions which help control and synchronize when processes are executed.
+
+The [`get_peft_model`] function takes a base model and the [`peft_config`] you prepared earlier to create a [`PeftModel`]:
+
+```diff
+ model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
++ model = get_peft_model(model, peft_config)
+```
+
+Pass all the relevant training objects to 🤗 Accelerate's [`~accelerate.Accelerator.prepare`] which makes sure everything is ready for training:
+
+```py
+model, train_dataloader, eval_dataloader, test_dataloader, optimizer, lr_scheduler = accelerator.prepare(
+ model, train_dataloader, eval_dataloader, test_dataloader, optimizer, lr_scheduler
+)
+```
+
+The next bit of code checks whether the DeepSpeed plugin is used in the `Accelerator`, and if the plugin exists, then we check if we are using ZeRO-3. This conditional flag is used when calling `generate` function call during inference for syncing GPUs when the model parameters are sharded:
+
+```py
+is_ds_zero_3 = False
+if getattr(accelerator.state, "deepspeed_plugin", None):
+ is_ds_zero_3 = accelerator.state.deepspeed_plugin.zero_stage == 3
+```
+
+Inside the training loop, the usual `loss.backward()` is replaced by 🤗 Accelerate's [`~accelerate.Accelerator.backward`] which uses the correct `backward()` method based on your configuration:
+
+```diff
+ for epoch in range(num_epochs):
+ with TorchTracemalloc() as tracemalloc:
+ model.train()
+ total_loss = 0
+ for step, batch in enumerate(tqdm(train_dataloader)):
+ outputs = model(**batch)
+ loss = outputs.loss
+ total_loss += loss.detach().float()
++ accelerator.backward(loss)
+ optimizer.step()
+ lr_scheduler.step()
+ optimizer.zero_grad()
+```
+
+That is all! The rest of the script handles the training loop, evaluation, and even pushes it to the Hub for you.
+
+## Train
+
+Run the following command to launch the training script. Earlier, you saved the configuration file to `ds_zero3_cpu.yaml`, so you'll need to pass the path to the launcher with the `--config_file` argument like this:
+
+```bash
+accelerate launch --config_file ds_zero3_cpu.yaml examples/peft_lora_seq2seq_accelerate_ds_zero3_offload.py
+```
+
+You'll see some output logs that track memory usage during training, and once it's completed, the script returns the accuracy and compares the predictions to the labels:
+
+```bash
+GPU Memory before entering the train : 1916
+GPU Memory consumed at the end of the train (end-begin): 66
+GPU Peak Memory consumed during the train (max-begin): 7488
+GPU Total Peak Memory consumed during the train (max): 9404
+CPU Memory before entering the train : 19411
+CPU Memory consumed at the end of the train (end-begin): 0
+CPU Peak Memory consumed during the train (max-begin): 0
+CPU Total Peak Memory consumed during the train (max): 19411
+epoch=4: train_ppl=tensor(1.0705, device='cuda:0') train_epoch_loss=tensor(0.0681, device='cuda:0')
+100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:27<00:00, 3.92s/it]
+GPU Memory before entering the eval : 1982
+GPU Memory consumed at the end of the eval (end-begin): -66
+GPU Peak Memory consumed during the eval (max-begin): 672
+GPU Total Peak Memory consumed during the eval (max): 2654
+CPU Memory before entering the eval : 19411
+CPU Memory consumed at the end of the eval (end-begin): 0
+CPU Peak Memory consumed during the eval (max-begin): 0
+CPU Total Peak Memory consumed during the eval (max): 19411
+accuracy=100.0
+eval_preds[:10]=['no complaint', 'no complaint', 'complaint', 'complaint', 'no complaint', 'no complaint', 'no complaint', 'complaint', 'complaint', 'no complaint']
+dataset['train'][label_column][:10]=['no complaint', 'no complaint', 'complaint', 'complaint', 'no complaint', 'no complaint', 'no complaint', 'complaint', 'complaint', 'no complaint']
+```
+
+# Caveats
+1. Merging when using PEFT and DeepSpeed is currently unsupported and will raise error.
+2. When using CPU offloading, the major gains from using PEFT to shrink the optimizer states and gradients to that of the adapter weights would be realized on CPU RAM and there won't be savings with respect to GPU memory.
+3. DeepSpeed Stage 3 and qlora when used with CPU offloading leads to more GPU memory usage when compared to disabling CPU offloading.
+
+> [!TIP]
+> 💡 When you have code that requires merging (and unmerging) of weights, try to manually collect the parameters with DeepSpeed Zero-3 beforehand:
+>
+> ```python
+> import deepspeed
+>
+> is_ds_zero_3 = ... # check if Zero-3
+>
+> with deepspeed.zero.GatheredParameters(list(model.parameters()), enabled= is_ds_zero_3):
+> model.merge_adapter()
+> # do whatever is needed, then unmerge in the same context if unmerging is required
+> ...
+> model.unmerge_adapter()
+> ```
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/accelerate/fsdp.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/accelerate/fsdp.md
new file mode 100644
index 0000000000000000000000000000000000000000..a209bc0d145e685af7a519b73da296b5c6553fc4
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/accelerate/fsdp.md
@@ -0,0 +1,285 @@
+
+
+# Fully Sharded Data Parallel
+
+[Fully sharded data parallel](https://pytorch.org/docs/stable/fsdp.html) (FSDP) is developed for distributed training of large pretrained models up to 1T parameters. FSDP achieves this by sharding the model parameters, gradients, and optimizer states across data parallel processes and it can also offload sharded model parameters to a CPU. The memory efficiency afforded by FSDP allows you to scale training to larger batch or model sizes.
+
+Both of these features are supported in 🤗 Accelerate, and you can use them with 🤗 PEFT.
+
+# Use PEFT and FSDP
+This section of guide will help you learn how to use our DeepSpeed [training script](https://github.com/huggingface/peft/blob/main/examples/sft/train.py) for performing SFT. You'll configure the script to do SFT (supervised fine-tuning) of Llama-70B model with LoRA and FSDP on 8xH100 80GB GPUs on a single machine. You can configure it to scale to multiple machines by changing the accelerate config.
+
+## Configuration
+
+Start by running the following command to [create a FSDP configuration file](https://huggingface.co/docs/accelerate/quicktour#launching-your-distributed-script) with 🤗 Accelerate. The `--config_file` flag allows you to save the configuration file to a specific location, otherwise it is saved as a `default_config.yaml` file in the 🤗 Accelerate cache.
+
+The configuration file is used to set the default options when you launch the training script.
+
+```bash
+accelerate config --config_file fsdp_config.yaml
+```
+
+You'll be asked a few questions about your setup, and configure the following arguments. In this example, you'll answer the questionnaire as shown in the image below.
+
+
+
+Creating Accelerate's config to use FSDP
+
+Once this is done, the corresponding config should look like below and you can find it in config folder at [fsdp_config.yaml](https://github.com/huggingface/peft/blob/main/examples/sft/configs/fsdp_config.yaml):
+
+```yml
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: FSDP
+downcast_bf16: 'no'
+fsdp_config:
+ fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
+ fsdp_backward_prefetch: BACKWARD_PRE
+ fsdp_cpu_ram_efficient_loading: true
+ fsdp_forward_prefetch: false
+ fsdp_offload_params: false
+ fsdp_sharding_strategy: FULL_SHARD
+ fsdp_state_dict_type: SHARDED_STATE_DICT
+ fsdp_sync_module_states: true
+ fsdp_use_orig_params: false
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 8
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
+```
+
+## Launch command
+
+The launch command is available at [run_peft_fsdp.sh](https://github.com/huggingface/peft/blob/main/examples/sft/run_peft_fsdp.sh) and it is also shown below:
+```bash
+accelerate launch --config_file "configs/fsdp_config.yaml" train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_seq_len 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "llama-sft-lora-fsdp" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 4 \
+--gradient_checkpointing True \
+--use_reentrant False \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization False
+```
+
+Notice that we are using LoRA with rank=8, alpha=16 and targeting all linear layers. We are passing the FSDP config file and finetuning the 70B Llama model on a subset of the [ultrachat dataset](https://huggingface.co/datasets/HuggingFaceH4/ultrachat_200k).
+
+## The important parts
+
+Let's dive a little deeper into the script so you can see what's going on, and understand how it works.
+
+The first thing to know is that the script uses FSDP for distributed training as the FSDP config has been passed. The [`~trl.SFTTrainer`] class handles all the heavy lifting of creating PEFT model using the peft config that is passed. After that when you call `trainer.train()`, Trainer internally uses 🤗 Accelerate to prepare model, optimizer and trainer using the FSDP config to create FSDP wrapped model which is then trained. The main code snippet is below:
+
+```python
+# trainer
+trainer = SFTTrainer(
+ model=model,
+ processing_class=tokenizer,
+ args=training_args,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ peft_config=peft_config,
+)
+trainer.accelerator.print(f"{trainer.model}")
+if model_args.use_peft_lora:
+ # handle PEFT+FSDP case
+ trainer.model.print_trainable_parameters()
+ if getattr(trainer.accelerator.state, "fsdp_plugin", None):
+ from peft.utils.other import fsdp_auto_wrap_policy
+
+ fsdp_plugin = trainer.accelerator.state.fsdp_plugin
+ fsdp_plugin.auto_wrap_policy = fsdp_auto_wrap_policy(trainer.model)
+
+# train
+checkpoint = None
+if training_args.resume_from_checkpoint is not None:
+ checkpoint = training_args.resume_from_checkpoint
+trainer.train(resume_from_checkpoint=checkpoint)
+
+# saving final model
+if trainer.is_fsdp_enabled:
+ trainer.accelerator.state.fsdp_plugin.set_state_dict_type("FULL_STATE_DICT")
+trainer.save_model()
+```
+
+
+Here, one main thing to note currently when using FSDP with PEFT is that `use_orig_params` needs to be `False` to realize GPU memory savings. Due to `use_orig_params=False`, the auto wrap policy for FSDP needs to change so that trainable and non-trainable parameters are wrapped separately. This is done by the code snippt below which uses the util function `fsdp_auto_wrap_policy` from PEFT:
+
+```
+if getattr(trainer.accelerator.state, "fsdp_plugin", None):
+ from peft.utils.other import fsdp_auto_wrap_policy
+
+ fsdp_plugin = trainer.accelerator.state.fsdp_plugin
+ fsdp_plugin.auto_wrap_policy = fsdp_auto_wrap_policy(trainer.model)
+```
+
+## Memory usage
+
+In the above example, the memory consumed per GPU is 72-80 GB (90-98%) as seen in the screenshot below. The slight increase in GPU memory at the end is when saving the model using `FULL_STATE_DICT` state dict type instead of the `SHARDED_STATE_DICT` so that the model has adapter weights that can be loaded normally with `from_pretrained` method during inference:
+
+
+
+
+GPU memory usage for the training run
+
+# Use PEFT QLoRA and FSDP for finetuning large models on multiple GPUs
+
+In this section, we will look at how to use QLoRA and FSDP for finetuning 70B llama model on 2X24GB GPUs. [Answer.AI](https://www.answer.ai/) in collaboration with bitsandbytes and Hugging Face 🤗 open sourced code enabling the usage of FSDP+QLoRA and explained the whole process in their insightful blogpost [You can now train a 70b language model at home](https://www.answer.ai/posts/2024-03-06-fsdp-qlora.html). This is now integrated in Hugging Face ecosystem.
+
+For this, we first need `bitsandbytes>=0.43.3`, `accelerate>=1.0.1`, `transformers>4.44.2`, `trl>0.11.4` and `peft>0.13.0`. We need to set `fsdp_cpu_ram_efficient_loading=true`, `fsdp_use_orig_params=false` and `fsdp_offload_params=true`(cpu offloading) when using Accelerate config. When not using accelerate launcher, you can alternately set the environment variable `export FSDP_CPU_RAM_EFFICIENT_LOADING=true`. Here, we will be using accelerate config and below is the config which can be found at [fsdp_config_qlora.yaml](https://github.com/huggingface/peft/blob/main/examples/sft/configs/fsdp_config_qlora.yaml):
+
+```yml
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: FSDP
+downcast_bf16: 'no'
+fsdp_config:
+ fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
+ fsdp_backward_prefetch: BACKWARD_PRE
+ fsdp_cpu_ram_efficient_loading: true
+ fsdp_forward_prefetch: false
+ fsdp_offload_params: true
+ fsdp_sharding_strategy: FULL_SHARD
+ fsdp_state_dict_type: SHARDED_STATE_DICT
+ fsdp_sync_module_states: true
+ fsdp_use_orig_params: false
+machine_rank: 0
+main_training_function: main
+mixed_precision: 'no'
+num_machines: 1
+num_processes: 2
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
+```
+
+Launch command is given below which is available at [run_peft_qlora_fsdp.sh](https://github.com/huggingface/peft/blob/main/examples/sft/run_peft_qlora_fsdp.sh):
+```
+accelerate launch --config_file "configs/fsdp_config_qlora.yaml" train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_seq_len 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "llama-sft-qlora-fsdp" \
+--per_device_train_batch_size 2 \
+--per_device_eval_batch_size 2 \
+--gradient_accumulation_steps 2 \
+--gradient_checkpointing True \
+--use_reentrant True \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--bnb_4bit_quant_storage_dtype "bfloat16"
+```
+
+Notice the new argument being passed, `bnb_4bit_quant_storage_dtype`, which denotes the data type for packing the 4-bit parameters. For example, when it is set to `bfloat16`, **16/4 = 4** 4-bit params are packed together post quantization. When using mixed precision training with `bfloat16`, `bnb_4bit_quant_storage_dtype` can be either `bfloat16` for pure `bfloat16` finetuning, or `float32` for automatic mixed precision (this consumes more GPU memory). When using mixed precision training with `float16`, `bnb_4bit_quant_storage_dtype` should be set to `float32` for stable automatic mixed precision training.
+
+In terms of training code, the important code changes are:
+
+```diff
+...
+
+bnb_config = BitsAndBytesConfig(
+ load_in_4bit=args.use_4bit_quantization,
+ bnb_4bit_quant_type=args.bnb_4bit_quant_type,
+ bnb_4bit_compute_dtype=compute_dtype,
+ bnb_4bit_use_double_quant=args.use_nested_quant,
++ bnb_4bit_quant_storage=quant_storage_dtype,
+)
+
+...
+
+model = AutoModelForCausalLM.from_pretrained(
+ args.model_name_or_path,
+ quantization_config=bnb_config,
+ trust_remote_code=True,
+ attn_implementation="flash_attention_2" if args.use_flash_attn else "eager",
++ dtype=quant_storage_dtype or torch.float32,
+)
+```
+
+Notice that `dtype` for `AutoModelForCausalLM` is same as the `bnb_4bit_quant_storage` data type. That's it. Everything else is handled by Trainer and TRL.
+
+## Memory usage
+
+In the above example, the memory consumed per GPU is **19.6 GB** while CPU RAM usage is around **107 GB**. When disabling CPU offloading, the GPU memory usage is **35.6 GB/ GPU**. Therefore, what took 16X80GB GPUs for full finetuning, 8X80GB GPUs with FSDP+LoRA, and a couple of 80GB GPUs with DDP+QLoRA, now requires 2X24GB GPUs. This makes finetuning of large models more accessible.
+
+## More resources
+You can also refer the [llama-recipes](https://github.com/facebookresearch/llama-recipes/?tab=readme-ov-file#fine-tuning) repo and [Getting started with Llama](https://llama.meta.com/get-started/#fine-tuning) guide on how to finetune using FSDP and PEFT.
+
+## Caveats
+1. Merging when using PEFT and FSDP is currently unsupported and will raise error.
+2. Passing `modules_to_save` config parameter to is untested at present.
+3. GPU Memory saving when using CPU Offloading is untested at present.
+4. When using FSDP+QLoRA, `paged_adamw_8bit` currently results in an error when saving a checkpoint.
+5. DoRA training with FSDP should work (albeit at lower speed than LoRA). If combined with bitsandbytes (QDoRA), 4-bit quantization should also work, but 8-bit quantization has known issues and is not recommended.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/checkpoint.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/checkpoint.md
new file mode 100644
index 0000000000000000000000000000000000000000..ea05731e56f0ad3582ab4831584ea7fe1204c422
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/checkpoint.md
@@ -0,0 +1,244 @@
+
+
+# PEFT checkpoint format
+
+This document describes how PEFT's checkpoint files are structured and how to convert between the PEFT format and other formats.
+
+## PEFT files
+
+PEFT (parameter-efficient fine-tuning) methods only update a small subset of a model's parameters rather than all of them. This is nice because checkpoint files can generally be much smaller than the original model files and are easier to store and share. However, this also means that to load a PEFT model, you need to have the original model available as well.
+
+When you call [`~PeftModel.save_pretrained`] on a PEFT model, the PEFT model saves three files, described below:
+
+1. `adapter_model.safetensors` or `adapter_model.bin`
+
+By default, the model is saved in the `safetensors` format, a secure alternative to the `bin` format, which is known to be susceptible to [security vulnerabilities](https://huggingface.co/docs/hub/security-pickle) because it uses the pickle utility under the hood. Both formats store the same `state_dict` though, and are interchangeable.
+
+The `state_dict` only contains the parameters of the adapter module, not the base model. To illustrate the difference in size, a normal BERT model requires ~420MB of disk space, whereas an IA³ adapter on top of this BERT model only requires ~260KB.
+
+2. `adapter_config.json`
+
+The `adapter_config.json` file contains the configuration of the adapter module, which is necessary to load the model. Below is an example of an `adapter_config.json` for an IA³ adapter with standard settings applied to a BERT model:
+
+```json
+{
+ "auto_mapping": {
+ "base_model_class": "BertModel",
+ "parent_library": "transformers.models.bert.modeling_bert"
+ },
+ "base_model_name_or_path": "bert-base-uncased",
+ "fan_in_fan_out": false,
+ "feedforward_modules": [
+ "output.dense"
+ ],
+ "inference_mode": true,
+ "init_ia3_weights": true,
+ "modules_to_save": null,
+ "peft_type": "IA3",
+ "revision": null,
+ "target_modules": [
+ "key",
+ "value",
+ "output.dense"
+ ],
+ "task_type": null
+}
+```
+
+The configuration file contains:
+
+- the adapter module type stored, `"peft_type": "IA3"`
+- information about the base model like `"base_model_name_or_path": "bert-base-uncased"`
+- the revision of the model (if any), `"revision": null`
+
+If the base model is not a pretrained Transformers model, the latter two entries will be `null`. Other than that, the settings are all related to the specific IA³ adapter that was used to fine-tune the model.
+
+3. `README.md`
+
+The generated `README.md` is the model card of a PEFT model and contains a few pre-filled entries. The intent of this is to make it easier to share the model with others and to provide some basic information about the model. This file is not needed to load the model.
+
+## Convert to PEFT format
+
+When converting from another format to the PEFT format, we require both the `adapter_model.safetensors` (or `adapter_model.bin`) file and the `adapter_config.json` file.
+
+### adapter_model
+
+For the model weights, it is important to use the correct mapping from parameter name to value for PEFT to load the file. Getting this mapping right is an exercise in checking the implementation details, as there is no generally agreed upon format for PEFT adapters.
+
+Fortunately, figuring out this mapping is not overly complicated for common base cases. Let's look at a concrete example, the [`LoraLayer`](https://github.com/huggingface/peft/blob/main/src/peft/tuners/lora/layer.py):
+
+```python
+# showing only part of the code
+
+class LoraLayer(BaseTunerLayer):
+ # All names of layers that may contain (trainable) adapter weights
+ adapter_layer_names = ("lora_A", "lora_B", "lora_embedding_A", "lora_embedding_B")
+ # All names of other parameters that may contain adapter-related parameters
+ other_param_names = ("r", "lora_alpha", "scaling", "lora_dropout")
+
+ def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+ self.base_layer = base_layer
+ self.r = {}
+ self.lora_alpha = {}
+ self.scaling = {}
+ self.lora_dropout = nn.ModuleDict({})
+ self.lora_A = nn.ModuleDict({})
+ self.lora_B = nn.ModuleDict({})
+ # For Embedding layer
+ self.lora_embedding_A = nn.ParameterDict({})
+ self.lora_embedding_B = nn.ParameterDict({})
+ # Mark the weight as unmerged
+ self._disable_adapters = False
+ self.merged_adapters = []
+ self.use_dora: dict[str, bool] = {}
+ self.lora_magnitude_vector: Optional[torch.nn.ParameterDict] = None # for DoRA
+ self._caches: dict[str, Any] = {}
+ self.kwargs = kwargs
+```
+
+In the `__init__` code used by all `LoraLayer` classes in PEFT, there are a bunch of parameters used to initialize the model, but only a few are relevant for the checkpoint file: `lora_A`, `lora_B`, `lora_embedding_A`, and `lora_embedding_B`. These parameters are listed in the class attribute `adapter_layer_names` and contain the learnable parameters, so they must be included in the checkpoint file. All the other parameters, like the rank `r`, are derived from the `adapter_config.json` and must be included there (unless the default value is used).
+
+Let's check the `state_dict` of a PEFT LoRA model applied to BERT. When printing the first five keys using the default LoRA settings (the remaining keys are the same, just with different layer numbers), we get:
+
+- `base_model.model.encoder.layer.0.attention.self.query.lora_A.weight`
+- `base_model.model.encoder.layer.0.attention.self.query.lora_B.weight`
+- `base_model.model.encoder.layer.0.attention.self.value.lora_A.weight`
+- `base_model.model.encoder.layer.0.attention.self.value.lora_B.weight`
+- `base_model.model.encoder.layer.1.attention.self.query.lora_A.weight`
+- etc.
+
+Let's break this down:
+
+- By default, for BERT models, LoRA is applied to the `query` and `value` layers of the attention module. This is why you see `attention.self.query` and `attention.self.value` in the key names for each layer.
+- LoRA decomposes the weights into two low-rank matrices, `lora_A` and `lora_B`. This is where `lora_A` and `lora_B` come from in the key names.
+- These LoRA matrices are implemented as `nn.Linear` layers, so the parameters are stored in the `.weight` attribute (`lora_A.weight`, `lora_B.weight`).
+- By default, LoRA isn't applied to BERT's embedding layer, so there are _no entries_ for `lora_A_embedding` and `lora_B_embedding`.
+- The keys of the `state_dict` always start with `"base_model.model."`. The reason is that, in PEFT, we wrap the base model inside a tuner-specific model (`LoraModel` in this case), which itself is wrapped in a general PEFT model (`PeftModel`). For this reason, these two prefixes are added to the keys. When converting to the PEFT format, it is required to add these prefixes.
+
+> [!TIP]
+> This last point is not true for prefix tuning techniques like prompt tuning. There, the extra embeddings are directly stored in the `state_dict` without any prefixes added to the keys.
+
+When inspecting the parameter names in the loaded model, you might be surprised to find that they look a bit different, e.g. `base_model.model.encoder.layer.0.attention.self.query.lora_A.default.weight`. The difference is the *`.default`* part in the second to last segment. This part exists because PEFT generally allows the addition of multiple adapters at once (using an `nn.ModuleDict` or `nn.ParameterDict` to store them). For example, if you add another adapter called "other", the key for that adapter would be `base_model.model.encoder.layer.0.attention.self.query.lora_A.other.weight`.
+
+When you call [`~PeftModel.save_pretrained`], the adapter name is stripped from the keys. The reason is that the adapter name is not an important part of the model architecture; it is just an arbitrary name. When loading the adapter, you could choose a totally different name, and the model would still work the same way. This is why the adapter name is not stored in the checkpoint file.
+
+> [!TIP]
+> If you call `save_pretrained("some/path")` and the adapter name is not `"default"`, the adapter is stored in a sub-directory with the same name as the adapter. So if the name is "other", it would be stored inside of `some/path/other`.
+
+In some circumstances, deciding which values to add to the checkpoint file can become a bit more complicated. For example, in PEFT, DoRA is implemented as a special case of LoRA. If you want to convert a DoRA model to PEFT, you should create a LoRA checkpoint with extra entries for DoRA. You can see this in the `__init__` of the previous `LoraLayer` code:
+
+```python
+self.lora_magnitude_vector: Optional[torch.nn.ParameterDict] = None # for DoRA
+```
+
+This indicates that there is an optional extra parameter per layer for DoRA.
+
+### adapter_config
+
+All the other information needed to load a PEFT model is contained in the `adapter_config.json` file. Let's check this file for a LoRA model applied to BERT:
+
+```json
+{
+ "alpha_pattern": {},
+ "auto_mapping": {
+ "base_model_class": "BertModel",
+ "parent_library": "transformers.models.bert.modeling_bert"
+ },
+ "base_model_name_or_path": "bert-base-uncased",
+ "bias": "none",
+ "fan_in_fan_out": false,
+ "inference_mode": true,
+ "init_lora_weights": true,
+ "layer_replication": null,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "loftq_config": {},
+ "lora_alpha": 8,
+ "lora_dropout": 0.0,
+ "megatron_config": null,
+ "megatron_core": "megatron.core",
+ "modules_to_save": null,
+ "peft_type": "LORA",
+ "r": 8,
+ "rank_pattern": {},
+ "revision": null,
+ "target_modules": [
+ "query",
+ "value"
+ ],
+ "task_type": null,
+ "use_dora": false,
+ "use_rslora": false
+}
+```
+
+This contains a lot of entries, and at first glance, it could feel overwhelming to figure out all the right values to put in there. However, most of the entries are not necessary to load the model. This is either because they use the default values and don't need to be added or because they only affect the initialization of the LoRA weights, which is irrelevant when it comes to loading the model. If you find that you don't know what a specific parameter does, e.g., `"use_rslora",` don't add it, and you should be fine. Also note that as more options are added, this file will get more entries in the future, but it should be backward compatible.
+
+At the minimum, you should include the following entries:
+
+```json
+{
+ "target_modules": ["query", "value"],
+ "peft_type": "LORA"
+}
+```
+
+However, adding as many entries as possible, like the rank `r` or the `base_model_name_or_path` (if it's a Transformers model) is recommended. This information can help others understand the model better and share it more easily. To check which keys and values are expected, check out the [config.py](https://github.com/huggingface/peft/blob/main/src/peft/tuners/lora/config.py) file (as an example, this is the config file for LoRA) in the PEFT source code.
+
+## Model storage
+
+In some circumstances, you might want to store the whole PEFT model, including the base weights. This can be necessary if, for instance, the base model is not available to the users trying to load the PEFT model. You can merge the weights first or convert it into a Transformer model.
+
+### Merge the weights
+
+The most straightforward way to store the whole PEFT model is to merge the adapter weights into the base weights:
+
+```python
+merged_model = model.merge_and_unload()
+merged_model.save_pretrained(...)
+```
+
+There are some disadvantages to this approach, though:
+
+- Once [`~LoraModel.merge_and_unload`] is called, you get a basic model without any PEFT-specific functionality. This means you can't use any of the PEFT-specific methods anymore.
+- You cannot unmerge the weights, load multiple adapters at once, disable the adapter, etc.
+- Not all PEFT methods support merging weights.
+- Some PEFT methods may generally allow merging, but not with specific settings (e.g. when using certain quantization techniques).
+- The whole model will be much larger than the PEFT model, as it will contain all the base weights as well.
+
+But inference with a merged model should be a bit faster.
+
+### Convert to a Transformers model
+
+Another way to save the whole model, assuming the base model is a Transformers model, is to use this hacky approach to directly insert the PEFT weights into the base model and save it, which only works if you "trick" Transformers into believing the PEFT model is not a PEFT model. This only works with LoRA because other adapters are not implemented in Transformers.
+
+```python
+model = ... # the PEFT model
+...
+# after you finish training the model, save it in a temporary location
+model.save_pretrained()
+# now load this model directly into a transformers model, without the PEFT wrapper
+# the PEFT weights are directly injected into the base model
+model_loaded = AutoModel.from_pretrained()
+# now make the loaded model believe that it is _not_ a PEFT model
+model_loaded._hf_peft_config_loaded = False
+# now when we save it, it will save the whole model
+model_loaded.save_pretrained()
+# or upload to Hugging Face Hub
+model_loaded.push_to_hub()
+```
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/contributing.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/contributing.md
new file mode 100644
index 0000000000000000000000000000000000000000..9831264b901d05875322c3450594152543d3a8cd
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/contributing.md
@@ -0,0 +1,123 @@
+
+
+# Contribute to PEFT
+
+We are happy to accept contributions to PEFT. If you plan to contribute, please read this to make the process as smooth as possible.
+
+## Installation
+
+For code contributions to PEFT, you should choose the ["source"](../install#source) installation method.
+
+If you are new to creating a pull request, follow the [Creating a pull request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request) guide by GitHub.
+
+## Tests and code quality checks
+
+Regardless of the contribution type (unless it’s only about the docs), you should run tests and code quality checks before creating a PR to ensure your contribution doesn’t break anything and follows the project standards.
+
+We provide a Makefile to execute the necessary tests. Run the code below for the unit test:
+
+```sh
+make test
+```
+
+Run one of the following to either only check or check and fix code quality and style:
+
+```sh
+make quality # just check
+make style # check and fix
+```
+
+You can also set up [`pre-commit`](https://pre-commit.com/) to run these fixes
+automatically as Git commit hooks.
+
+```bash
+$ pip install pre-commit
+$ pre-commit install
+```
+
+Running all the tests can take a while, so during development it can be more efficient to only [run tests specific to your change](https://docs.pytest.org/en/6.2.x/usage.html#specifying-tests-selecting-tests), e.g. via:
+
+```sh
+pytest tests/ -k
+```
+
+This should finish much quicker and allow for faster iteration.
+
+If your change is specific to a hardware setting (e.g., it requires CUDA), take a look at [`tests/test_gpu_examples.py`](https://github.com/huggingface/peft/blob/1c1c7fdaa6e6abaa53939b865dee1eded82ad032/tests/test_gpu_examples.py) and [`tests/test_common_gpu.py`](https://github.com/huggingface/peft/blob/1c1c7fdaa6e6abaa53939b865dee1eded82ad032/tests/test_common_gpu.py) to see if it makes sense to add tests there. If your change could have an effect on saving and loading models, please run the tests with the `--regression` flag to trigger regression tests.
+
+It can happen that while you’re working on your PR, the underlying code base changes due to other changes being merged. If that happens – especially when there is a merge conflict – please update your branch with the latest changes. This can be a merge or a rebase, and we'll squash and merge the PR once it’s ready. If possible, **avoid force pushes** to make reviews easier.
+
+## PR description
+
+When opening a PR, please provide a nice description of the change you're proposing. If it relates to other issues or PRs, please reference them. Providing a good description not only helps the reviewers review your code better and faster, it can also be used later (as a basis) for the commit message which helps with long term maintenance of the project.
+
+If your code makes some non-trivial changes, it may also be a good idea to add comments to the code to explain those changes. For example, if you had to iterate on your implementation multiple times because the most obvious way didn’t work, it’s a good indication that a code comment is needed.
+
+## Bugfixes
+
+Please give a description of the circumstances that led to the bug. If there is an existing issue, please link to it (e.g., “Resolves #12345”).
+
+Ideally when a bugfix is provided, it should be accompanied by a test for the bug. The test should fail with the current code and pass with the bugfix. Add a comment to the test that references the issue or PR. Without a test, it is more difficult to prevent regressions in the future.
+
+## Documentation improvements
+
+We are happy to have fixes for broken links and missing or unclear documentation. Taking care of examples, making sure that they are up-to-date and running fine in this fast moving environment is also highly appreciated.
+
+Please refrain from sending pull requests that *only* correct typing errors as these generally create more work than they safe. Such changes are better combined with more substantial fixes (such as fixing broken links or extending/updating documentation).
+
+## Add a new PEFT fine-tuning method
+
+New parameter-efficient fine-tuning methods are developed all the time. If you would like to add a new and promising method to PEFT, please follow these steps.
+
+1. If you're _not_ an author of the original paper, check for existing implementations and double check with the authors that they don't plan to submit a PR themselves.
+2. Start with the core integration work listed below.
+3. Check recent commits for new PEFT methods being added to take as inspiration.
+4. It can be useful to open a draft PR early once the method basically works and first tests pass, then ask for feedback.
+5. After working through reviewer feedback, ping the reviewer so that they know the PR is ready to review.
+
+### Core integration of a new PEFT method
+
+- [ ] Open a proposal issue on `huggingface/peft` before investing too much work.
+- [ ] Link the source of the method, usually the final paper or another stable primary reference. We want to avoid work that is still under review, as the implementation should be stable.
+- [ ] Add a new `PeftType` entry in `src/peft/utils/peft_types.py`.
+- [ ] Create a new tuner package under `src/peft/tuners/` with the files your method needs (typically: `config.py`, `model.py`, `layer.py`, and `__init__.py`).
+- [ ] Register the method in the tuner `__init__.py` with `register_peft_method(...)`.
+- [ ] Export the new config/model from `src/peft/tuners/__init__.py` and `src/peft/__init__.py`.
+- [ ] If the method needs default target modules for Transformers models, add the mapping in `src/peft/utils/constants.py`.
+- [ ] Add the method to the test matrix in `tests/test_custom_models.py` as these are the broadest and quickest tests. Check that the tests pass with `pytest tests/test_custom_models.py -k -v`, fix failures if any.
+- [ ] Run style/quality checks with `make style` before pushing.
+- [ ] In the PR description, explain the method, link the paper, summarize tradeoffs, and list what was added.
+
+### Full PR to add a new PEFT method
+
+- [ ] Ensure that the configuration arguments that are specific to the method are well named and explained, don't assume that the user knows the paper inside out.
+- [ ] Follow the naming and coding conventions of PEFT.
+- [ ] Ensure that you didn't accidentally check in unrelated changes, e.g. the code formatter changing unrelated files.
+- [ ] If some implementation choices are non-trivial, document them with a code comment.
+- [ ] Complete the full test suite (`test_config.py`, `test_decoder_models.py`, etc.) by adding the PEFT method to the test matrix. Ensure that the tests pass.
+- [ ] Add docs in `docs/source/package_reference/` with a short explanation, paper link, usage snippet, and autodoc blocks. Explain the pros and cons compared to other methods like LoRA. Register that doc page in `docs/source/_toctree.yml`.
+- [ ] Add a runnable example under `examples/` (can be a copy of an existing example), with a short `README.md`.
+- [ ] Check the benchmarks in `method_comparison/` and add experiment settings for your new method. This is a good place to sanity check that the PEFT method trains as expected. Include one or two reasonable benchmark configurations (one default, one optimized for the benchmark).
+- [ ] Recommended: Add generic quantization support. Instead of having to explicitly add quantization layer types for each quantization method, support generic quantization. As an example, check how it's implemented in [BOFT](https://github.com/huggingface/peft/tree/main/src/peft/tuners/boft). Extend https://github.com/huggingface/peft/blob/main/tests/test_quantization.py by adding your PEFT method there. Ask maintainers for help if needed.
+
+## Add other features
+
+It is best if you first open an issue on GitHub with a proposal to add the new feature. This way, you can discuss with the maintainers if it makes sense to add the feature before spending too much time on implementing it.
+
+New features should generally be accompanied by tests and documentation or examples. Without the latter, users will have a hard time discovering your cool new feature.
+
+Changes to the code should be implemented in a backward-compatible way. For example, existing code should continue to work the same way after the feature is merged.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/custom_models.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/custom_models.md
new file mode 100644
index 0000000000000000000000000000000000000000..d6ad6e93dee98cbfd00f5739276a18b01d2a9c17
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/custom_models.md
@@ -0,0 +1,304 @@
+
+
+# Custom models
+
+Some fine-tuning techniques, such as prompt tuning, are specific to language models. That means in 🤗 PEFT, it is
+assumed a 🤗 Transformers model is being used. However, other fine-tuning techniques - like
+[LoRA](../package_reference/lora) - are not restricted to specific model types.
+
+In this guide, we will see how LoRA can be applied to a multilayer perceptron, a computer vision model from the [timm](https://huggingface.co/docs/timm/index) library, or a new 🤗 Transformers architecture.
+
+## Multilayer perceptron
+
+Let's assume that we want to fine-tune a multilayer perceptron with LoRA. Here is the definition:
+
+```python
+from torch import nn
+
+
+class MLP(nn.Module):
+ def __init__(self, num_units_hidden=2000):
+ super().__init__()
+ self.seq = nn.Sequential(
+ nn.Linear(20, num_units_hidden),
+ nn.ReLU(),
+ nn.Linear(num_units_hidden, num_units_hidden),
+ nn.ReLU(),
+ nn.Linear(num_units_hidden, 2),
+ nn.LogSoftmax(dim=-1),
+ )
+
+ def forward(self, X):
+ return self.seq(X)
+```
+
+This is a straightforward multilayer perceptron with an input layer, a hidden layer, and an output layer.
+
+> [!TIP]
+> For this toy example, we choose an exceedingly large number of hidden units to highlight the efficiency gains
+> from PEFT, but those gains are in line with more realistic examples.
+
+There are a few linear layers in this model that could be tuned with LoRA. When working with common 🤗 Transformers
+models, PEFT will know which layers to apply LoRA to, but in this case, it is up to us as a user to choose the layers.
+To determine the names of the layers to tune:
+
+```python
+print([(n, type(m)) for n, m in MLP().named_modules()])
+```
+
+This should print:
+
+```
+[('', __main__.MLP),
+ ('seq', torch.nn.modules.container.Sequential),
+ ('seq.0', torch.nn.modules.linear.Linear),
+ ('seq.1', torch.nn.modules.activation.ReLU),
+ ('seq.2', torch.nn.modules.linear.Linear),
+ ('seq.3', torch.nn.modules.activation.ReLU),
+ ('seq.4', torch.nn.modules.linear.Linear),
+ ('seq.5', torch.nn.modules.activation.LogSoftmax)]
+```
+
+Let's say we want to apply LoRA to the input layer and to the hidden layer, those are `'seq.0'` and `'seq.2'`. Moreover,
+let's assume we want to update the output layer without LoRA, that would be `'seq.4'`. The corresponding config would
+be:
+
+```python
+from peft import LoraConfig
+
+config = LoraConfig(
+ target_modules=["seq.0", "seq.2"],
+ modules_to_save=["seq.4"],
+)
+```
+
+With that, we can create our PEFT model and check the fraction of parameters trained:
+
+```python
+from peft import get_peft_model
+
+model = MLP()
+peft_model = get_peft_model(model, config)
+peft_model.print_trainable_parameters()
+# prints trainable params: 56,164 || all params: 4,100,164 || trainable%: 1.369798866581922
+```
+
+Finally, we can use any training framework we like, or write our own fit loop, to train the `peft_model`.
+
+For a complete example, check out [this notebook](https://github.com/huggingface/peft/blob/main/examples/multilayer_perceptron/multilayer_perceptron_lora.ipynb).
+
+## timm models
+
+The [timm](https://huggingface.co/docs/timm/index) library contains a large number of pretrained computer vision models.
+Those can also be fine-tuned with PEFT. Let's check out how this works in practice.
+
+To start, ensure that timm is installed in the Python environment:
+
+```bash
+python -m pip install -U timm
+```
+
+Next we load a timm model for an image classification task:
+
+```python
+import timm
+
+num_classes = ...
+model_id = "timm/poolformer_m36.sail_in1k"
+model = timm.create_model(model_id, pretrained=True, num_classes=num_classes)
+```
+
+Again, we need to make a decision about what layers to apply LoRA to. Since LoRA supports 2D conv layers, and since
+those are a major building block of this model, we should apply LoRA to the 2D conv layers. To identify the names of
+those layers, let's look at all the layer names:
+
+```python
+print([(n, type(m)) for n, m in model.named_modules()])
+```
+
+This will print a very long list, we'll only show the first few:
+
+```
+[('', timm.models.metaformer.MetaFormer),
+ ('stem', timm.models.metaformer.Stem),
+ ('stem.conv', torch.nn.modules.conv.Conv2d),
+ ('stem.norm', torch.nn.modules.linear.Identity),
+ ('stages', torch.nn.modules.container.Sequential),
+ ('stages.0', timm.models.metaformer.MetaFormerStage),
+ ('stages.0.downsample', torch.nn.modules.linear.Identity),
+ ('stages.0.blocks', torch.nn.modules.container.Sequential),
+ ('stages.0.blocks.0', timm.models.metaformer.MetaFormerBlock),
+ ('stages.0.blocks.0.norm1', timm.layers.norm.GroupNorm1),
+ ('stages.0.blocks.0.token_mixer', timm.models.metaformer.Pooling),
+ ('stages.0.blocks.0.token_mixer.pool', torch.nn.modules.pooling.AvgPool2d),
+ ('stages.0.blocks.0.drop_path1', torch.nn.modules.linear.Identity),
+ ('stages.0.blocks.0.layer_scale1', timm.models.metaformer.Scale),
+ ('stages.0.blocks.0.res_scale1', torch.nn.modules.linear.Identity),
+ ('stages.0.blocks.0.norm2', timm.layers.norm.GroupNorm1),
+ ('stages.0.blocks.0.mlp', timm.layers.mlp.Mlp),
+ ('stages.0.blocks.0.mlp.fc1', torch.nn.modules.conv.Conv2d),
+ ('stages.0.blocks.0.mlp.act', torch.nn.modules.activation.GELU),
+ ('stages.0.blocks.0.mlp.drop1', torch.nn.modules.dropout.Dropout),
+ ('stages.0.blocks.0.mlp.norm', torch.nn.modules.linear.Identity),
+ ('stages.0.blocks.0.mlp.fc2', torch.nn.modules.conv.Conv2d),
+ ('stages.0.blocks.0.mlp.drop2', torch.nn.modules.dropout.Dropout),
+ ('stages.0.blocks.0.drop_path2', torch.nn.modules.linear.Identity),
+ ('stages.0.blocks.0.layer_scale2', timm.models.metaformer.Scale),
+ ('stages.0.blocks.0.res_scale2', torch.nn.modules.linear.Identity),
+ ('stages.0.blocks.1', timm.models.metaformer.MetaFormerBlock),
+ ('stages.0.blocks.1.norm1', timm.layers.norm.GroupNorm1),
+ ('stages.0.blocks.1.token_mixer', timm.models.metaformer.Pooling),
+ ('stages.0.blocks.1.token_mixer.pool', torch.nn.modules.pooling.AvgPool2d),
+ ...
+ ('head.global_pool.flatten', torch.nn.modules.linear.Identity),
+ ('head.norm', timm.layers.norm.LayerNorm2d),
+ ('head.flatten', torch.nn.modules.flatten.Flatten),
+ ('head.drop', torch.nn.modules.linear.Identity),
+ ('head.fc', torch.nn.modules.linear.Linear)]
+ ]
+```
+
+Upon closer inspection, we see that the 2D conv layers have names such as `"stages.0.blocks.0.mlp.fc1"` and
+`"stages.0.blocks.0.mlp.fc2"`. How can we match those layer names specifically? You can write a [regular
+expressions](https://docs.python.org/3/library/re.html) to match the layer names. For our case, the regex
+`r".*\.mlp\.fc\d"` should do the job.
+
+Furthermore, as in the first example, we should ensure that the output layer, in this case the classification head, is
+also updated. Looking at the end of the list printed above, we can see that it's named `'head.fc'`. With that in mind,
+here is our LoRA config:
+
+```python
+config = LoraConfig(target_modules=r".*\.mlp\.fc\d", modules_to_save=["head.fc"])
+```
+
+Then we only need to create the PEFT model by passing our base model and the config to `get_peft_model`:
+
+```python
+peft_model = get_peft_model(model, config)
+peft_model.print_trainable_parameters()
+# prints trainable params: 1,064,454 || all params: 56,467,974 || trainable%: 1.88505789139876
+```
+
+This shows us that we only need to train less than 2% of all parameters, which is a huge efficiency gain.
+
+For a complete example, check out [this notebook](https://github.com/huggingface/peft/blob/main/examples/image_classification/image_classification_timm_peft_lora.ipynb).
+
+## New transformers architectures
+
+When new popular transformers architectures are released, we do our best to quickly add them to PEFT. If you come across a transformers model that is not supported out of the box, don't worry, it will most likely still work if the config is set correctly. Specifically, you have to identify the layers that should be adapted and set them correctly when initializing the corresponding config class, e.g. `LoraConfig`. Here are some tips to help with this.
+
+As a first step, it is a good idea to check the existing models for inspiration. You can find them inside of [constants.py](https://github.com/huggingface/peft/blob/main/src/peft/utils/constants.py) in the PEFT repository. Often, you'll find a similar architecture that uses the same names. For example, if the new model architecture is a variation of the "mistral" model and you want to apply LoRA, you can see that the entry for "mistral" in `TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING` contains `["q_proj", "v_proj"]`. This tells you that for "mistral" models, the `target_modules` for LoRA should be `["q_proj", "v_proj"]`:
+
+```python
+from peft import LoraConfig, get_peft_model
+
+my_mistral_model = ...
+config = LoraConfig(
+ target_modules=["q_proj", "v_proj"],
+ ..., # other LoRA arguments
+)
+peft_model = get_peft_model(my_mistral_model, config)
+```
+
+If that doesn't help, check the existing modules in your model architecture with the `named_modules` method and try to identify the attention layers, especially the key, query, and value layers. Those will often have names such as `c_attn`, `query`, `q_proj`, etc. The key layer is not always adapted, and ideally, you should check whether including it results in better performance.
+
+Additionally, linear layers are common targets to be adapted (e.g. in [QLoRA paper](https://huggingface.co/papers/2305.14314), authors suggest to adapt them as well). Their names will often contain the strings `fc` or `dense`.
+
+If you want to add a new model to PEFT, please create an entry in [constants.py](https://github.com/huggingface/peft/blob/main/src/peft/utils/constants.py) and open a pull request on the [repository](https://github.com/huggingface/peft/pulls). Don't forget to update the [README](https://github.com/huggingface/peft#models-support-matrix) as well.
+
+## Verify parameters and layers
+
+You can verify whether you've correctly applied a PEFT method to your model in a few ways.
+
+* Check the fraction of parameters that are trainable with the [`~PeftModel.print_trainable_parameters`] method. If this number is lower or higher than expected, check the model `repr` by printing the model. This shows the names of all the layer types in the model. Ensure that only the intended target layers are replaced by the adapter layers. For example, if LoRA is applied to `nn.Linear` layers, then you should only see `lora.Linear` layers being used.
+
+```py
+peft_model.print_trainable_parameters()
+```
+
+* Another way you can view the adapted layers is to use the `targeted_module_names` attribute to list the name of each module that was adapted.
+
+```python
+print(peft_model.targeted_module_names)
+```
+
+## Unsupported module types
+
+Methods like LoRA only work if the target modules are supported by PEFT. For example, it's possible to apply LoRA to `nn.Linear` and `nn.Conv2d` layers, but not, for instance, to `nn.LSTM`. If you find a layer class you want to apply PEFT to is not supported, you can:
+
+ - define a custom mapping to dynamically dispatch custom modules in LoRA
+ - open an [issue](https://github.com/huggingface/peft/issues) and request the feature where maintainers will implement it or guide you on how to implement it yourself if demand for this module type is sufficiently high
+
+### Experimental support for dynamic dispatch of custom modules in LoRA
+
+> [!WARNING]
+> This feature is experimental and subject to change, depending on its reception by the community. We will introduce a public and stable API if there is significant demand for it.
+
+PEFT supports an experimental API for custom module types for LoRA. Let's assume you have a LoRA implementation for LSTMs. Normally, you would not be able to tell PEFT to use it, even if it would theoretically work with PEFT. However, this is possible with dynamic dispatch of custom layers.
+
+The experimental API currently looks like this:
+
+```python
+class MyLoraLSTMLayer:
+ ...
+
+base_model = ... # load the base model that uses LSTMs
+
+# add the LSTM layer names to target_modules
+config = LoraConfig(..., target_modules=["lstm"])
+# define a mapping from base layer type to LoRA layer type
+custom_module_mapping = {nn.LSTM: MyLoraLSTMLayer}
+# register the new mapping
+config._register_custom_module(custom_module_mapping)
+# after registration, create the PEFT model
+peft_model = get_peft_model(base_model, config)
+# do training
+```
+
+> [!TIP]
+> When you call [`get_peft_model`], you will see a warning because PEFT does not recognize the targeted module type. In this case, you can ignore this warning.
+
+By supplying a custom mapping, PEFT first checks the base model's layers against the custom mapping and dispatches to the custom LoRA layer type if there is a match. If there is no match, PEFT checks the built-in LoRA layer types for a match.
+
+Therefore, this feature can also be used to override existing dispatch logic, e.g. if you want to use your own LoRA layer for `nn.Linear` instead of using the one provided by PEFT.
+
+When creating your custom LoRA module, please follow the same rules as the [existing LoRA modules](https://github.com/huggingface/peft/blob/main/src/peft/tuners/lora/layer.py). Some important constraints to consider:
+
+- The custom module should inherit from `nn.Module` and `peft.tuners.lora.layer.LoraLayer`.
+- The `__init__` method of the custom module should have the positional arguments `base_layer` and `adapter_name`. After this, there are additional `**kwargs` that you are free to use or ignore.
+- The learnable parameters should be stored in an `nn.ModuleDict` or `nn.ParameterDict`, where the key corresponds to the name of the specific adapter (remember that a model can have more than one adapter at a time).
+- The name of these learnable parameter attributes should start with `"lora_"`, e.g. `self.lora_new_param = ...`.
+- Some methods are optional, e.g. you only need to implement `merge` and `unmerge` if you want to support weight merging.
+
+Currently, the information about the custom module does not persist when you save the model. When loading the model, you have to register the custom modules again.
+
+```python
+# saving works as always and includes the parameters of the custom modules
+peft_model.save_pretrained()
+
+# loading the model later:
+base_model = ...
+# load the LoRA config that you saved earlier
+config = LoraConfig.from_pretrained()
+# register the custom module again, the same way as the first time
+custom_module_mapping = {nn.LSTM: MyLoraLSTMLayer}
+config._register_custom_module(custom_module_mapping)
+# pass the config instance to from_pretrained:
+peft_model = PeftModel.from_pretrained(model, tmp_path / "lora-custom-module", config=config)
+```
+
+If you use this feature and find it useful, or if you encounter problems, let us know by creating an issue or a discussion on GitHub. This allows us to estimate the demand for this feature and add a public API if it is sufficiently high.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/low_level_api.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/low_level_api.md
new file mode 100644
index 0000000000000000000000000000000000000000..2e3236cd18207e3f5ba60d291deacf38458a8251
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/low_level_api.md
@@ -0,0 +1,148 @@
+
+
+# Adapter injection
+
+With PEFT, you can inject trainable adapters into any `torch` module which allows you to use adapter methods without relying on the modeling classes in PEFT. This works for all adapters except for those based on prompt learning (e.g. prefix tuning or p-tuning).
+
+Check the table below to see when you should inject adapters.
+
+| Pros | Cons |
+|---|---|
+| the model is modified inplace, keeping all the original attributes and methods | manually write the `from_pretrained` and `save_pretrained` utility functions from Hugging Face to save and load adapters |
+| works for any `torch` module and modality | doesn't work with any of the utility methods provided by `PeftModel` such as disabling and merging adapters |
+
+## Creating a new PEFT model
+
+To perform the adapter injection, use the [`inject_adapter_in_model`] method. This method takes 3 arguments, the PEFT config, the model, and an optional adapter name. You can also attach multiple adapters to the model if you call [`inject_adapter_in_model`] multiple times with different adapter names.
+
+For example, to inject LoRA adapters into the `linear` submodule of the `DummyModel` module:
+
+```python
+import torch
+from peft import inject_adapter_in_model, LoraConfig
+
+class DummyModel(torch.nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.embedding = torch.nn.Embedding(10, 10)
+ self.linear = torch.nn.Linear(10, 10)
+ self.lm_head = torch.nn.Linear(10, 10)
+
+ def forward(self, input_ids):
+ x = self.embedding(input_ids)
+ x = self.linear(x)
+ x = self.lm_head(x)
+ return x
+
+
+lora_config = LoraConfig(
+ lora_alpha=16,
+ lora_dropout=0.1,
+ r=64,
+ bias="none",
+ target_modules=["linear"],
+)
+
+model = DummyModel()
+model = inject_adapter_in_model(lora_config, model)
+
+dummy_inputs = torch.LongTensor([[0, 1, 2, 3, 4, 5, 6, 7]])
+dummy_outputs = model(dummy_inputs)
+```
+
+Print the model to see that the adapters have been correctly injected.
+
+```bash
+DummyModel(
+ (embedding): Embedding(10, 10)
+ (linear): Linear(
+ in_features=10, out_features=10, bias=True
+ (lora_dropout): ModuleDict(
+ (default): Dropout(p=0.1, inplace=False)
+ )
+ (lora_A): ModuleDict(
+ (default): Linear(in_features=10, out_features=64, bias=False)
+ )
+ (lora_B): ModuleDict(
+ (default): Linear(in_features=64, out_features=10, bias=False)
+ )
+ (lora_embedding_A): ParameterDict()
+ (lora_embedding_B): ParameterDict()
+ )
+ (lm_head): Linear(in_features=10, out_features=10, bias=True)
+)
+```
+
+### Injection based on a `state_dict`
+
+Sometimes, it is possible that there is a PEFT adapter checkpoint but the corresponding PEFT config is not known for whatever reason. To inject the PEFT layers for this checkpoint, you would usually have to reverse-engineer the corresponding PEFT config, most notably the `target_modules` argument, based on the `state_dict` from the checkpoint. This can be cumbersome and error prone. To avoid this, it is also possible to call [`inject_adapter_in_model`] and pass the loaded `state_dict` as an argument:
+
+```python
+from safetensors.torch import load_file
+
+model = ...
+state_dict = load_file()
+lora_config = LoraConfig(...)
+model = inject_adapter_in_model(lora_config, model, state_dict=state_dict)
+```
+
+In this case, PEFT will use the `state_dict` as reference for which layers to target instead of using the PEFT config. As a user, you don't have to set the exact `target_modules` of the PEFT config for this to work. However, you should still pass a PEFT config of the right type, in this example `LoraConfig`, you can leave the `target_modules` as `None`.
+
+Be aware that this still only creates the uninitialized PEFT layers, the values from the `state_dict` are not used to populate the model weights. To populate the weights, proceed with calling [`set_peft_model_state_dict`] as described below.
+
+⚠️ Note that if there is a mismatch between what is configured in the PEFT config and what is found in the `state_dict`, PEFT will warn you about this. You can ignore the warning if you know that the PEFT config is not correctly specified.
+
+> [!WARNING]
+> If the original PEFT adapters was using `target_parameters` instead of `target_modules`, injecting from a `state_dict` will not work correctly. In this case, it is mandatory to use the correct PEFT config for injection.
+
+## Saving the model
+
+To only save the adapter, use the [`get_peft_model_state_dict`] function:
+
+```python
+from peft import get_peft_model_state_dict
+
+peft_state_dict = get_peft_model_state_dict(model)
+print(peft_state_dict)
+```
+
+Otherwise, `model.state_dict()` returns the full state dict of the model.
+
+## Loading the model
+
+After loading the saved `state_dict`, it can be applied using the [`set_peft_model_state_dict`] function:
+
+```python
+from peft import set_peft_model_state_dict
+
+model = DummyModel()
+model = inject_adapter_in_model(lora_config, model)
+outcome = set_peft_model_state_dict(model, peft_state_dict)
+# check that there were no wrong keys
+print(outcome.unexpected_keys)
+```
+
+If injecting the adapter is slow or you need to load a large number of adapters, you may use an optimization that allows to create an "empty" adapter on meta device and only fills the weights with real weights when the [`set_peft_model_state_dict`] is called. To do this, pass `low_cpu_mem_usage=True` to both [`inject_adapter_in_model`] and [`set_peft_model_state_dict`].
+
+```python
+model = DummyModel()
+model = inject_adapter_in_model(lora_config, model, low_cpu_mem_usage=True)
+
+print(model.linear.lora_A["default"].weight.device.type == "meta") # should be True
+set_peft_model_state_dict(model, peft_state_dict, low_cpu_mem_usage=True)
+print(model.linear.lora_A["default"].weight.device.type == "cpu") # should be True
+```
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/memory_efficient_training.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/memory_efficient_training.md
new file mode 100644
index 0000000000000000000000000000000000000000..72eb7d1d85e35d374ef8d8a15efea8de2d4d2d91
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/memory_efficient_training.md
@@ -0,0 +1,63 @@
+
+
+# Memory Efficient Training
+
+🤗 PEFT makes fine-tuning parameter efficient, but not automatically memory efficient. This overview collects tips for cutting training memory and links to the detailed guides.
+
+> [!TIP]
+> Always consider the basics of choosing a smaller base model, smaller batch size or shorter sequence length to lower your memory usage.
+
+## Training memory overview
+
+Let's dissect the distribution of training memory so we can reason about potential countermeasures. We will use a large language-model trained with the Adam optimizer as an example. When doing full fine-tuning, we will have the following positions taking up memory:
+
+1. base model parameters: the memory consumption highly depends on the chosen `dtype`. The less bits per parameter (16 for float16), the less memory this will take up. A 1B model in float16 (16 bit/2 byte per parameter) will roughly take `1e9 × 2 byte = 1.863 GiB` of memory.
+2. all trainable base model parameters ×3 for gradients (1×) and Adam optimizer states (2×), therefore 5.59GB of memory
+3. memory for the intermediate activations between layers, these are hard to predict but mostly depend on the used compute dtype and sequence length / batch size.
+
+A smaller base model or a using a smaller compute dtype will reduce all points while using shorter sequences or smaller batches mainly affects gradients and activation memory. Employing PEFT methods will reduce the number of trainable parameters and therefore significantly reduce both gradients and optimizer state, saving a lot of memory.
+
+## Choosing the right method
+
+Not every PEFT method is built equally and some formulations are easier to build in a memory efficient manner. If you are on a memory budget it makes sense to check out the [PEFT method comparison suite](https://huggingface.co/spaces/peft-internal-testing/PEFT-method-comparison) and filter for **maximum** accelerator memory usage. Average accelerator memory usage can be fairly equal across methods but not every method scales equally with activations and sequence length; some methods are more prone to memory spikes than others.
+
+Consider [using trainable tokens](troubleshooting#using-trainable-tokens) when targeting large layers like language modeling heads or embedding layers to fine-tune specific tokens.
+
+## Quantization
+
+Quantization is one of the best ways to reduce memory consumption *of the base model* and will, depending on the employed quantization, also reduce activation memory. Since the PEFT methods will only take up a small portion of the total number of parameters, PEFT defaults to use a higher precision than the base model. This can also have the effect that adapters can mitigate some of the quality loss incurred by quantization methods. Read the [PEFT quantization guide](quantization).
+
+## Compilation
+
+The models we train are composed of operations like matrix multiplications, sums and assignments where each operation produces a new result and, subsequently, needs to take up memory. If those intermediate results are not needed we can fuse these operations and save up on memory. This is just one of many optimizations that `torch.compile` can do for you, so check out the [PEFT torch.compile guide](torch_compile).
+
+## Gradient Checkpointing
+
+You can trade memory with computation by only saving every nth gradient between layers and computing the rest on the fly. Check out the [gradient checkpointing](https://huggingface.co/docs/transformers/grad_checkpointing) documentation of Transformers to learn more.
+
+> [!NOTE]
+> When not using Diffusers or Transformers you may need to implement your own gradient checkpointing logic, depending on the training framework that you are using.
+
+## Chunked NLL loss
+
+Using [`NLLLoss`](https://docs.pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html) is very common when training language models (or classification tasks). You allocate a matrix of size `batch × sequence × vocabulary`. With particularly long sequences or vocabularies this can get expensive fast.
+
+When using [TRL](https://huggingface.co/docs/trl) you can either use the [Liger kernel integration](https://huggingface.co/docs/trl/liger_kernel_integration) or use [Chunked NLLLoss](https://huggingface.co/docs/trl/v1.5.1/en/reducing_memory_usage#chunked-cross-entropy-for-reducing-peak-memory-usage). The latter will split the sequence in chunks of size 256 to keep the maximum memory consumption constant.
+
+
+
+In case the default chunk size is not optimal for your setting, look in the [original TRL PR](https://github.com/huggingface/trl/pull/5575) for more information on how to tune the chunk size.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/mixed_models.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/mixed_models.md
new file mode 100644
index 0000000000000000000000000000000000000000..c42cf1416cb389867da3d04a90a8b00c8c8bfcb5
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/mixed_models.md
@@ -0,0 +1,37 @@
+
+
+# Mixed adapter types
+
+Normally, it isn't possible to mix different adapter types in 🤗 PEFT. You can create a PEFT model with two different LoRA adapters (which can have different config options), but it is not possible to combine a LoRA and LoHa adapter. With [`PeftMixedModel`] however, this works as long as the adapter types are compatible. The main purpose of allowing mixed adapter types is to combine trained adapters for inference. While it is possible to train a mixed adapter model, this has not been tested and is not recommended.
+
+To load different adapter types into a PEFT model, use [`PeftMixedModel`] instead of [`PeftModel`]:
+
+```py
+from peft import PeftMixedModel
+
+base_model = ... # load the base model, e.g. from transformers
+# load first adapter, which will be called "default"
+peft_model = PeftMixedModel.from_pretrained(base_model, )
+peft_model.load_adapter(, adapter_name="other")
+peft_model.set_adapter(["default", "other"])
+```
+
+The [`~PeftMixedModel.set_adapter`] method is necessary to activate both adapters, otherwise only the first adapter would be active. You can keep adding more adapters by calling [`~PeftModel.add_adapter`] repeatedly.
+
+[`PeftMixedModel`] does not support saving and loading mixed adapters. The adapters should already be trained, and loading the model requires a script to be run each time.
+
+## Tips
+
+- Not all adapter types can be combined. See [`peft.tuners.mixed.COMPATIBLE_TUNER_TYPES`](https://github.com/huggingface/peft/blob/1c1c7fdaa6e6abaa53939b865dee1eded82ad032/src/peft/tuners/mixed/model.py#L35) for a list of compatible types. An error will be raised if you try to combine incompatible adapter types.
+- It is possible to mix multiple adapters of the same type which can be useful for combining adapters with very different configs.
+- If you want to combine a lot of different adapters, the most performant way to do it is to consecutively add the same adapter types. For example, add LoRA1, LoRA2, LoHa1, LoHa2 in this order, instead of LoRA1, LoHa1, LoRA2, and LoHa2. While the order can affect the output, there is no inherently *best* order, so it is best to choose the fastest one.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/model_merging.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/model_merging.md
new file mode 100644
index 0000000000000000000000000000000000000000..3aab957f269b413764fb1b2ffd888b7ba98139c4
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/model_merging.md
@@ -0,0 +1,164 @@
+
+
+# Model merging
+
+Training a model for each task can be costly, take up storage space, and the models aren't able to learn new information to improve their performance. Multitask learning can overcome some of these limitations by training a model to learn several tasks, but it is expensive to train and designing a dataset for it is challenging. *Model merging* offers a solution to these challenges by combining multiple pretrained models into one model, giving it the combined abilities of each individual model without any additional training.
+
+PEFT provides several methods for merging models like a linear or SVD combination. This guide focuses on two methods that are more efficient for merging LoRA adapters by eliminating redundant parameters:
+
+* [TIES](https://hf.co/papers/2306.01708) - TrIm, Elect, and Merge (TIES) is a three-step method for merging models. First, redundant parameters are trimmed, then conflicting signs are resolved into an aggregated vector, and finally the parameters whose signs are the same as the aggregate sign are averaged. This method takes into account that some values (redundant and sign disagreement) can degrade performance in the merged model.
+* [DARE](https://hf.co/papers/2311.03099) - Drop And REscale is a method that can be used to prepare for other model merging methods like TIES. It works by randomly dropping parameters according to a drop rate and rescaling the remaining parameters. This helps to reduce the number of redundant and potentially interfering parameters among multiple models.
+
+Models are merged with the [`~LoraModel.add_weighted_adapter`] method, and the specific model merging method is specified in the `combination_type` parameter.
+
+## Merge method
+
+With TIES and DARE, merging is enabled by setting `combination_type` and `density` to a value of the weights to keep from the individual models. For example, let's merge three finetuned [TinyLlama/TinyLlama-1.1B-intermediate-step-1431k-3T](https://huggingface.co/TinyLlama/TinyLlama-1.1B-intermediate-step-1431k-3T) models: [tinyllama_lora_nobots](https://huggingface.co/smangrul/tinyllama_lora_norobots), [tinyllama_lora_sql](https://huggingface.co/smangrul/tinyllama_lora_sql), and [tinyllama_lora_adcopy](https://huggingface.co/smangrul/tinyllama_lora_adcopy).
+
+
+
+When you're attempting to merge fully trained models with TIES, you should be aware of any special tokens each model may have added to the embedding layer which are not a part of the original checkpoint's vocabulary. This may cause an issue because each model may have added a special token to the same embedding position. If this is the case, you should use the [`~transformers.PreTrainedModel.resize_token_embeddings`] method to avoid merging the special tokens at the same embedding index.
+
+
+
+This shouldn't be an issue if you're only merging LoRA adapters trained from the same base model.
+
+
+
+Load a base model and can use the [`~PeftModel.load_adapter`] method to load and assign each adapter a name:
+
+```py
+from peft import PeftConfig, PeftModel
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+
+config = PeftConfig.from_pretrained("smangrul/tinyllama_lora_norobots")
+model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path, load_in_4bit=True, device_map="auto").eval()
+tokenizer = AutoTokenizer.from_pretrained("smangrul/tinyllama_lora_norobots")
+
+model.config.vocab_size = 32005
+model.resize_token_embeddings(32005)
+
+model = PeftModel.from_pretrained(model, "smangrul/tinyllama_lora_norobots", adapter_name="norobots")
+_ = model.load_adapter("smangrul/tinyllama_lora_sql", adapter_name="sql")
+_ = model.load_adapter("smangrul/tinyllama_lora_adcopy", adapter_name="adcopy")
+```
+
+Set the adapters, weights, `adapter_name`, `combination_type`, and `density` with the [`~LoraModel.add_weighted_adapter`] method.
+
+
+
+
+Weight values greater than `1.0` typically produce better results because they preserve the correct scale. A good default starting value for the weights is to set all values to `1.0`.
+
+```py
+adapters = ["norobots", "adcopy", "sql"]
+weights = [2.0, 1.0, 1.0]
+adapter_name = "merge"
+density = 0.2
+model.add_weighted_adapter(adapters, weights, adapter_name, combination_type="ties", density=density)
+```
+
+
+
+
+```py
+adapters = ["norobots", "adcopy", "sql"]
+weights = [2.0, 0.3, 0.7]
+adapter_name = "merge"
+density = 0.2
+model.add_weighted_adapter(adapters, weights, adapter_name, combination_type="dare_ties", density=density)
+```
+
+
+
+
+Set the newly merged model as the active model with the [`~LoraModel.set_adapter`] method.
+
+```py
+model.set_adapter("merge")
+```
+
+Now you can use the merged model as an instruction-tuned model to write ad copy or SQL queries!
+
+
+
+
+```py
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+messages = [
+ {"role": "user", "content": "Write an essay about Generative AI."},
+]
+text = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
+inputs = tokenizer(text, return_tensors="pt")
+inputs = {k: v.to(device) for k, v in inputs.items()}
+outputs = model.generate(**inputs, max_new_tokens=256, do_sample=True, top_p=0.95, temperature=0.2, repetition_penalty=1.2, eos_token_id=tokenizer.eos_token_id)
+print(tokenizer.decode(outputs[0]))
+```
+
+
+
+
+```py
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+messages = [
+ {"role": "system", "content": "Create a text ad given the following product and description."},
+ {"role": "user", "content": "Product: Sony PS5 PlayStation Console\nDescription: The PS5 console unleashes new gaming possibilities that you never anticipated."},
+]
+text = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
+inputs = tokenizer(text, return_tensors="pt")
+inputs = {k: v.to(device) for k, v in inputs.items()}
+outputs = model.generate(**inputs, max_new_tokens=128, do_sample=True, top_p=0.95, temperature=0.2, repetition_penalty=1.2, eos_token_id=tokenizer.eos_token_id)
+print(tokenizer.decode(outputs[0]))
+```
+
+
+
+
+```py
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+
+text = """Table: 2-11365528-2
+Columns: ['Team', 'Head Coach', 'President', 'Home Ground', 'Location']
+Natural Query: Who is the Head Coach of the team whose President is Mario Volarevic?
+SQL Query:"""
+
+inputs = tokenizer(text, return_tensors="pt")
+inputs = {k: v.to(device) for k, v in inputs.items()}
+outputs = model.generate(**inputs, max_new_tokens=64, repetition_penalty=1.1, eos_token_id=tokenizer("").input_ids[-1])
+print(tokenizer.decode(outputs[0]))
+```
+
+
+
+
+
+## Merging (IA)³ Models
+The (IA)³ models facilitate linear merging of adapters. To merge adapters in an (IA)³ model, utilize the `add_weighted_adapter` method from the `IA3Model` class. This method is analogous to the `add_weighted_adapter` method used in `LoraModel`, with the key difference being the absence of the `combination_type` parameter. For example, to merge three (IA)³ adapters into a PEFT model, you would proceed as follows:
+
+```py
+adapters = ["adapter1", "adapter2", "adapter3"]
+weights = [0.4, 0.3, 0.3]
+adapter_name = "merge"
+model.add_weighted_adapter(adapters, weights, adapter_name)
+```
+
+It is recommended that the weights sum to 1.0 to preserve the scale of the model. The merged model can then be set as the active model using the `set_adapter` method:
+
+```py
+model.set_adapter("merge")
+```
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/quantization.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/quantization.md
new file mode 100644
index 0000000000000000000000000000000000000000..e6f75d76a2b8fd0e35499d0999d8362ad2a8a645
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/quantization.md
@@ -0,0 +1,356 @@
+
+
+# Quantization
+
+Quantization represents data with fewer bits, making it a useful technique for reducing memory-usage and accelerating inference especially when it comes to large language models (LLMs). There are several ways to quantize a model including:
+
+* optimizing which model weights are quantized with the [AWQ](https://hf.co/papers/2306.00978) algorithm
+* independently quantizing each row of a weight matrix with the [GPTQ](https://hf.co/papers/2210.17323) algorithm
+* quantizing to 8-bit and 4-bit precision with the [bitsandbytes](https://github.com/TimDettmers/bitsandbytes) library
+* quantizing to as low as 2-bit precision with the [AQLM](https://huggingface.co/papers/2401.06118) algorithm
+
+However, after a model is quantized it isn't typically further trained for downstream tasks because training can be unstable due to the lower precision of the weights and activations. But since PEFT methods only add *extra* trainable parameters, this allows you to train a quantized model with a PEFT adapter on top! Combining quantization with PEFT can be a good strategy for training even the largest models on a single GPU. For example, [QLoRA](https://hf.co/papers/2305.14314) is a method that quantizes a model to 4-bits and then trains it with LoRA. This method allows you to finetune a 65B parameter model on a single 48GB GPU!
+
+In this guide, you'll see how to quantize a model to 4-bits and train it with LoRA.
+
+## Quantize a model
+
+[bitsandbytes](https://github.com/TimDettmers/bitsandbytes) is a quantization library with a Transformers integration. With this integration, you can quantize a model to 8 or 4-bits and enable many other options by configuring the [`~transformers.BitsAndBytesConfig`] class. For example, you can:
+
+* set `load_in_4bit=True` to quantize the model to 4-bits when you load it
+* set `bnb_4bit_quant_type="nf4"` to use a special 4-bit data type for weights initialized from a normal distribution
+* set `bnb_4bit_use_double_quant=True` to use a nested quantization scheme to quantize the already quantized weights
+* set `bnb_4bit_compute_dtype=torch.bfloat16` to use bfloat16 for faster computation
+
+```py
+import torch
+from transformers import BitsAndBytesConfig
+
+config = BitsAndBytesConfig(
+ load_in_4bit=True,
+ bnb_4bit_quant_type="nf4",
+ bnb_4bit_use_double_quant=True,
+ bnb_4bit_compute_dtype=torch.bfloat16,
+)
+```
+
+Pass the `config` to the [`~transformers.AutoModelForCausalLM.from_pretrained`] method.
+
+```py
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1", quantization_config=config)
+```
+
+Next, you should call the [`~peft.utils.prepare_model_for_kbit_training`] function to preprocess the quantized model for training.
+
+```py
+from peft import prepare_model_for_kbit_training
+
+model = prepare_model_for_kbit_training(model)
+```
+
+Now that the quantized model is ready, let's set up a configuration.
+
+## LoraConfig
+
+Create a [`LoraConfig`] with the following parameters (or choose your own):
+
+```py
+from peft import LoraConfig
+
+config = LoraConfig(
+ r=16,
+ lora_alpha=8,
+ target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
+ lora_dropout=0.05,
+ bias="none",
+ task_type="CAUSAL_LM"
+)
+```
+
+Then use the [`get_peft_model`] function to create a [`PeftModel`] from the quantized model and configuration.
+
+```py
+from peft import get_peft_model
+
+model = get_peft_model(model, config)
+```
+
+You're all set for training with whichever training method you prefer!
+
+### LoftQ initialization
+
+[LoftQ](https://hf.co/papers/2310.08659) initializes LoRA weights such that the quantization error is minimized, and it can improve performance when training quantized models. To get started, follow [these instructions](https://github.com/huggingface/peft/tree/main/examples/loftq_finetuning).
+
+In general, for LoftQ to work best, it is recommended to target as many layers with LoRA as possible, since those not targeted cannot have LoftQ applied. This means that passing `LoraConfig(..., target_modules="all-linear")` will most likely give the best results. Also, you should use `nf4` as quant type in your quantization config when using 4bit quantization, i.e. `BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4")`.
+
+In general, for LoftQ to work best, it is recommended to target as many layers with LoRA as possible, since those not targeted cannot have LoftQ applied. This means that passing `LoraConfig(..., target_modules="all-linear")` will most likely give the best results. Also, you should use `nf4` as quant type in your quantization config when using 4bit quantization, i.e. `BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4")`.
+
+There are currently two intended ways of applying LoftQ:
+
+1. load the non-quantized base model, apply LoftQ with your intended quantization level (e.g., `bits=4` for nf4) and
+ save the resulting adapter. Then quantize the base model using, for example,
+ `BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4")` and load the LoftQ-initialized adapter on top
+2. load the quantized base model, initialize a PEFT model with LoRA (no loftq) and use `replace_lora_weights_loftq` to
+ apply LoftQ initialization by streaming the reference weights of the non-quantized base model from the weights file
+ (explained further in the next section)
+
+#### Using `replace_lora_weights_loftq` for on-the-fly LoftQ application
+
+An easier but more limited way to apply LoftQ initialization is to use the convenience function `replace_lora_weights_loftq`. This takes the quantized PEFT model as input and replaces the LoRA weights in-place with their LoftQ-initialized counterparts.
+
+```python
+from peft import replace_lora_weights_loftq
+from transformers import BitsAndBytesConfig
+
+bnb_config = BitsAndBytesConfig(load_in_4bit=True, ...)
+base_model = AutoModelForCausalLM.from_pretrained(..., quantization_config=bnb_config)
+# note: don't pass init_lora_weights="loftq" or loftq_config!
+lora_config = LoraConfig(task_type="CAUSAL_LM")
+peft_model = get_peft_model(base_model, lora_config)
+replace_lora_weights_loftq(peft_model)
+```
+
+`replace_lora_weights_loftq` also allows you to pass a `callback` argument to give you more control over which layers should be modified or not, which empirically can improve the results quite a lot. To see a more elaborate example of this, check out [this notebook](https://github.com/huggingface/peft/blob/main/examples/loftq_finetuning/LoftQ_weight_replacement.ipynb).
+
+`replace_lora_weights_loftq` implements only one iteration step of LoftQ. This means that only the LoRA weights are updated, instead of iteratively updating LoRA weights and quantized base model weights. This may lead to lower performance but has the advantage that we can use the original quantized weights derived from the base model, instead of having to keep an extra copy of modified quantized weights. Whether this tradeoff is worthwhile depends on the use case.
+
+At the moment, `replace_lora_weights_loftq` has these additional limitations:
+
+- Model files must be stored as a `safetensors` file.
+- Only bitsandbytes 4bit quantization is supported.
+
+### QLoRA-style training
+
+QLoRA adds trainable weights to all the linear layers in the transformer architecture. Since the attribute names for these linear layers can vary across architectures, set `target_modules` to `"all-linear"` to add LoRA to all the linear layers:
+
+```py
+config = LoraConfig(target_modules="all-linear", ...)
+```
+
+## GPTQ quantization
+
+You can learn more about GPTQ-based `[2, 3, 4, 8]` bit quantization at [GPT-QModel](https://github.com/ModelCloud/GPTQModel) and in the Transformers [GPTQ](https://huggingface.co/docs/transformers/quantization/gptq) documentation. PEFT supports GPTQ post-training through GPT-QModel.
+
+```bash
+# GPT-QModel install
+pip install "gptqmodel>=7.0.0"
+```
+
+```py
+from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfig
+
+model_id = "facebook/opt-125m"
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+gptq_config = GPTQConfig(bits=4, group_size=128, dataset="wikitext2", tokenizer=tokenizer)
+
+quantized_model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto", quantization_config=gptq_config)
+
+# save quantized model
+quantized_model.save_pretrained("./opt-125m-gptq")
+tokenizer.save_pretrained("./opt-125m-gptq")
+```
+
+Once quantized, you can post-train GPTQ models with PEFT APIs.
+
+## AQLM quantization
+
+Additive Quantization of Language Models ([AQLM](https://huggingface.co/papers/2401.06118)) is a Large Language Models compression method. It quantizes multiple weights together and takes advantage of interdependencies between them. AQLM represents groups of 8-16 weights as a sum of multiple vector codes. This allows it to compress models down to as low as 2-bit with considerably low accuracy losses.
+
+Since the AQLM quantization process is computationally expensive, the use of prequantized models is recommended. A partial list of available models can be found in the official aqlm [repository](https://github.com/Vahe1994/AQLM).
+
+The models support LoRA adapter tuning. To tune the quantized model you'll need to install the `aqlm` inference library: `pip install aqlm>=1.0.2`. Finetuned LoRA adapters shall be saved separately, as merging them with AQLM quantized weights is not possible.
+
+```py
+quantized_model = AutoModelForCausalLM.from_pretrained(
+ "BlackSamorez/Mixtral-8x7b-AQLM-2Bit-1x16-hf-test-dispatch",
+ dtype="auto", device_map="auto", low_cpu_mem_usage=True,
+)
+
+peft_config = LoraConfig(...)
+
+quantized_model = get_peft_model(quantized_model, peft_config)
+```
+
+You can refer to the [Google Colab](https://colab.research.google.com/drive/12GTp1FCj5_0SnnNQH18h_2XFh9vS_guX?usp=sharing) example for an overview of AQLM+LoRA finetuning.
+
+## EETQ quantization
+
+You can also perform LoRA fine-tuning on EETQ quantized models. [EETQ](https://github.com/NetEase-FuXi/EETQ) package offers simple and efficient way to perform 8-bit quantization, which is claimed to be faster than the `LLM.int8()` algorithm. First, make sure that you have a transformers version that is compatible with EETQ (e.g. by installing it from latest pypi or from source).
+
+```py
+import torch
+from transformers import EetqConfig
+
+config = EetqConfig("int8")
+```
+
+Pass the `config` to the [`~transformers.AutoModelForCausalLM.from_pretrained`] method.
+
+```py
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1", quantization_config=config)
+```
+
+and create a `LoraConfig` and pass it to `get_peft_model`:
+
+```py
+from peft import LoraConfig, get_peft_model
+
+config = LoraConfig(
+ r=16,
+ lora_alpha=8,
+ target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
+ lora_dropout=0.05,
+ bias="none",
+ task_type="CAUSAL_LM"
+)
+
+model = get_peft_model(model, config)
+```
+
+## HQQ quantization
+
+The models that are quantized using Half-Quadratic Quantization of Large Machine Learning Models ([HQQ](https://mobiusml.github.io/hqq_blog/)) support LoRA adapter tuning. To tune the quantized model, you'll need to install the `hqq` library with: `pip install hqq`.
+
+```python
+from hqq.engine.hf import HQQModelForCausalLM
+
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+
+quantized_model = HQQModelForCausalLM.from_quantized(save_dir_or_hfhub, device=device)
+peft_config = LoraConfig(...)
+quantized_model = get_peft_model(quantized_model, peft_config)
+```
+
+Or using transformers version that is compatible with HQQ (e.g. by installing it from latest pypi or from source).
+
+```python
+from transformers import HqqConfig, AutoModelForCausalLM
+
+quant_config = HqqConfig(nbits=4, group_size=64)
+quantized_model = AutoModelForCausalLM.from_pretrained(save_dir_or_hfhub, device_map=device_map, quantization_config=quant_config)
+peft_config = LoraConfig(...)
+quantized_model = get_peft_model(quantized_model, peft_config)
+```
+
+## torchao (PyTorch Architecture Optimization)
+
+PEFT supports models quantized with [torchao](https://github.com/pytorch/ao) ("ao") for int8 quantization.
+
+```python
+from peft import LoraConfig, get_peft_model
+from transformers import AutoModelForCausalLM, TorchAoConfig
+from torchao.quantization import Int8WeightOnlyConfig
+
+model_id = ...
+quantization_config = TorchAoConfig(quant_type=Int8WeightOnlyConfig())
+base_model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=quantization_config)
+peft_config = LoraConfig(...)
+model = get_peft_model(base_model, peft_config)
+```
+
+### Caveats:
+
+- Use the most recent versions of torchao (>= v0.4.0) and transformers (> 4.42).
+- Only linear layers are currently supported.
+- `quant_type = "int4_weight_only"` is currently not supported.
+- `NF4` is not implemented in transformers as of yet and is thus also not supported.
+- DoRA only works with `quant_type = "int8_weight_only"` at the moment.
+- There is explicit support for torchao when used with LoRA. However, when torchao quantizes a layer, its class does not change, only the type of the underlying tensor. For this reason, PEFT methods other than LoRA will generally also work with torchao, even if not explicitly supported. Be aware, however, that **merging only works correctly with LoRA and with `quant_type = "int8_weight_only"`**. If you use a different PEFT method or dtype, merging will likely result in an error, and even it doesn't, the results will still be incorrect.
+
+## INC quantization
+
+Intel Neural Compressor ([INC](https://github.com/intel/neural-compressor)) enables model quantization for various devices,
+including Intel Gaudi accelerators (also known as HPU devices). You can perform LoRA fine-tuning on models that have been
+quantized using INC. To use INC with PyTorch models, install the library with: `pip install neural-compressor[pt]`.
+Quantizing a model to FP8 precision for HPU devices can be done with the following single-step quantization workflow:
+
+```python
+import torch
+from neural_compressor.torch.quantization import FP8Config, convert, finalize_calibration, prepare
+quant_configs = {
+ ...
+}
+config = FP8Config(**quant_configs)
+```
+
+Pass the config to the `prepare` method, run inference to gather calibration stats, and call `finalize_calibration`
+and `convert` methods to quantize model to FP8 precision:
+
+```python
+model = prepare(model, config)
+# Run inference to collect calibration statistics
+...
+# Finalize calibration and convert the model to FP8 precision
+finalize_calibration(model)
+model = convert(model)
+# Load PEFT LoRA adapter as usual
+...
+```
+
+An example demonstrating how to load a PEFT LoRA adapter into an INC-quantized FLUX text-to-image model for HPU
+devices is provided [here](https://github.com/huggingface/peft/blob/main/examples/stable_diffusion/inc_flux_lora_hpu.py).
+
+
+### Caveats:
+
+- `merge()` and `unmerge()` methods are currently not supported for INC-quantized models.
+- Currently, only **Linear** INC-quantized layers are supported when loading PEFT adapters.
+
+## Other Supported PEFT Methods
+
+Besides LoRA, the following PEFT methods also support quantization:
+
+- **VeRA** (supports bitsandbytes quantization)
+- **AdaLoRA** (supports both bitsandbytes and GPTQ quantization)
+- **(IA)³** (supports bitsandbytes quantization)
+
+## Transformer Engine (TE) LoRA
+
+PEFT supports LoRA adapters on top of [NVIDIA Transformer Engine](https://docs.nvidia.com/deeplearning/transformer-engine/) layers (`te.pytorch.Linear`, `te.pytorch.LayerNormLinear`, and `te.pytorch.LayerNormMLP`). TE layers use FP8 and fused kernels to accelerate transformer training, and attaching LoRA adapters lets you parameter-efficiently fine-tune TE-accelerated models.
+
+```python
+from peft import LoraConfig, get_peft_model
+
+config = LoraConfig(
+ r=8,
+ lora_alpha=16,
+ target_modules=["q_proj", "v_proj"],
+ task_type="TOKEN_CLS",
+)
+model = get_peft_model(te_model, config)
+```
+
+When Transformer Engine is installed, PEFT automatically dispatches matching layers to the `TeLinear` adapter — no extra configuration is needed.
+
+### Caveats
+
+- `merge()` and `unmerge()` are not yet supported for TE layers.
+- DoRA is not supported with TE layers.
+
+A complete ESM2 token-classification example is available under `examples/lora_finetuning_transformer_engine/`.
+
+## Next steps
+
+If you're interested in learning more about quantization, the following may be helpful:
+
+* Learn more details about QLoRA and check out some benchmarks on its impact in the [Making LLMs even more accessible with bitsandbytes, 4-bit quantization and QLoRA](https://huggingface.co/blog/4bit-transformers-bitsandbytes) blog post.
+* Read more about different quantization schemes in the Transformers [Quantization](https://hf.co/docs/transformers/main/quantization) guide.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/torch_compile.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/torch_compile.md
new file mode 100644
index 0000000000000000000000000000000000000000..eadfe997ae00b0f9eae3bd12196d28bcd293b9d8
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/torch_compile.md
@@ -0,0 +1,70 @@
+
+
+# torch.compile
+
+In PEFT, [torch.compile](https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html) works for some but not all features. The reason why it won't always work is because PEFT is highly dynamic in certain places (loading and switching between multiple adapters, for instance), which can cause trouble for `torch.compile`. In other places, `torch.compile` may work, but won't be as fast as expected because of graph breaks.
+
+If you don't see an error, it doesn't necessarily mean that `torch.compile` worked correctly. It might give you an output, but the output is incorrect. This guide describes what works with `torch.compile` and what doesn't. For your own testing, we recommend using the latest PyTorch version, as `torch.compile` is constantly being improved.
+
+> [!TIP]
+> Unless indicated otherwise, the default `torch.compile` settings were used.
+
+## Training and inference with `torch.compile`
+
+These features **work** with `torch.compile`. Everything listed below was tested with a causal LM:
+
+- Training with `Trainer` from 🤗 transformers
+- Training with a custom PyTorch loop
+- Inference
+- Generation
+
+The following adapters were tested successfully:
+
+- AdaLoRA
+- BOFT
+- IA³
+- Layer Norm Tuning
+- LoHa
+- LoKr
+- LoRA
+- LoRA + DoRA
+- LoRA applied to embedding layers
+- OFT
+- VeRA
+- HRA
+
+## Advanced PEFT features with `torch.compile`
+
+Below are some of the more advanced PEFT features that **work**. They were all tested with LoRA.
+
+- `modules_to_save` (i.e. `config = LoraConfig(..., modules_to_save=...)`)
+- Merging adapters (one or multiple)
+- Merging multiple adapters into one adapter (i.e. calling `model.add_weighted_adapter(...)`)
+- Using PEFT adapters with quantization (bitsandbytes)
+- Disabling adapters (i.e. using `with model.disable_adapter()`)
+- Unloading (i.e. calling `model.merge_and_unload()`)
+- Mixed adapter batches (i.e. calling `model(batch, adapter_names=["__base__", "default", "other", ...])`)
+- Inference with multiple adapters (i.e. using `model.add_adapter` or `model.load_adapter` to load more than 1 adapter); for this, only call `torch.compile` _after_ loading all adapters
+
+Generally, we can expect that if a feature works correctly with LoRA and is also supported by other adapter types, it should also work for that adapter type.
+
+## Test cases
+
+All the use cases listed above are tested inside of [`peft/tests/test_torch_compile.py`](https://github.com/huggingface/peft/blob/main/tests/test_torch_compile.py). If you want to check in more detail how we tested a certain feature, please go to that file and check the test that corresponds to your use case.
+
+> [!TIP]
+> If you have another use case where you know that `torch.compile` does or does not work with PEFT, please contribute by letting us know or by opening a PR to add this use case to the covered test cases.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/troubleshooting.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/troubleshooting.md
new file mode 100644
index 0000000000000000000000000000000000000000..d56dea44d6e4d0e93d5e57f2c935d8de25a69511
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/developer_guides/troubleshooting.md
@@ -0,0 +1,458 @@
+
+
+# Troubleshooting
+
+If you encounter any issue when using PEFT, please check the following list of common issues and their solutions.
+
+## Examples don't work
+
+Examples often rely on the most recent package versions, so please ensure they're up-to-date. In particular, check the following package versions:
+
+- `peft`
+- `transformers`
+- `accelerate`
+- `torch`
+
+In general, you can update the package version by running this command inside your Python environment:
+
+```bash
+python -m pip install -U
+```
+
+Installing PEFT from source is useful for keeping up with the latest developments:
+
+```bash
+python -m pip install git+https://github.com/huggingface/peft
+```
+
+## Dtype-related issues
+
+### ValueError: Attempting to unscale FP16 gradients
+
+This error probably occurred because the model was loaded with `dtype=torch.float16` and then used in an automatic mixed precision (AMP) context, e.g. by setting `fp16=True` in the [`~transformers.Trainer`] class from 🤗 Transformers. The reason is that when using AMP, trainable weights should never use fp16. To make this work without loading the whole model in fp32, add the following to your code:
+
+```python
+peft_model = get_peft_model(...)
+
+# add this:
+for param in model.parameters():
+ if param.requires_grad:
+ param.data = param.data.float()
+
+# proceed as usual
+trainer = Trainer(model=peft_model, fp16=True, ...)
+trainer.train()
+```
+
+Alternatively, you can use the [`~utils.cast_mixed_precision_params`] function to correctly cast the weights:
+
+```python
+from peft import cast_mixed_precision_params
+
+peft_model = get_peft_model(...)
+cast_mixed_precision_params(peft_model, dtype=torch.float16)
+
+# proceed as usual
+trainer = Trainer(model=peft_model, fp16=True, ...)
+trainer.train()
+```
+
+> [!TIP]
+> Starting from PEFT version v0.12.0, PEFT automatically promotes the dtype of adapter weights from `torch.float16` and `torch.bfloat16` to `torch.float32` where appropriate. To _prevent_ this behavior, you can pass `autocast_adapter_dtype=False` to [`~get_peft_model`], to [`~PeftModel.from_pretrained`], and to [`~PeftModel.load_adapter`].
+
+### Selecting the dtype of the adapter
+
+Most PEFT methods, like LoRA, work by adding trainable adapter weights. By default, those weights are stored in float32 dtype (fp32), i.e. at a relatively high precision. Therefore, even if the base model is loaded in float16 (fp16) or bfloat16 (bf16), the adapter weights are float32. When the adapter results are calculated during the forward pass, the input will typically be in the dtype of the base model, thus it will be upcast to float32 if necessary, then cast back to the original dtype.
+
+If you prefer to have the adapter weights in the lower precision of the base model, i.e. in float16 or bfloat16, you can pass `autocast_adapter_dtype=False` when creating the model ([`~get_peft_model`]) or loading the model ([`~PeftModel.from_pretrained`]). There are some advantages and disadvantages to this:
+
+Advantages of half precision adapter:
+- computation slightly faster
+- slightly less memory
+- smaller file size of checkpoint (half the size)
+
+Disadvantages of half precision adapter:
+- slightly worse loss
+- higher risk of overflow or underflow
+
+Note that for most use cases, overall runtime and memory cost will be determined by the size of the base model and by the dataset, while the dtype of the PEFT adapter will only have a small impact.
+
+## Bad results from a loaded PEFT model
+
+There can be several reasons for getting a poor result from a loaded PEFT model which are listed below. If you're still unable to troubleshoot the problem, see if anyone else had a similar [issue](https://github.com/huggingface/peft/issues) on GitHub, and if you can't find any, open a new issue.
+
+When opening an issue, it helps a lot if you provide a minimal code example that reproduces the issue. Also, please report if the loaded model performs at the same level as the model did before fine-tuning, if it performs at a random level, or if it is only slightly worse than expected. This information helps us identify the problem more quickly.
+
+### Random deviations
+
+If your model outputs are not exactly the same as previous runs, there could be an issue with random elements. For example:
+
+1. please ensure it is in `.eval()` mode, which is important, for instance, if the model uses dropout
+2. if you use [`~transformers.GenerationMixin.generate`] on a language model, there could be random sampling, so obtaining the same result requires setting a random seed
+3. if you used quantization and merged the weights, small deviations are expected due to rounding errors
+
+### Incorrectly loaded model
+
+Please ensure that you load the model correctly. A common error is trying to load a _trained_ model with [`get_peft_model`] which is incorrect. Instead, the loading code should look like this:
+
+```python
+from peft import PeftModel, PeftConfig
+
+base_model = ... # to load the base model, use the same code as when you trained it
+config = PeftConfig.from_pretrained(peft_model_id)
+peft_model = PeftModel.from_pretrained(base_model, peft_model_id)
+```
+
+### Randomly initialized layers
+
+For some tasks, it is important to correctly configure `modules_to_save` in the config to account for randomly initialized layers.
+
+As an example, this is necessary if you use LoRA to fine-tune a language model for sequence classification because 🤗 Transformers adds a randomly initialized classification head on top of the model. If you do not add this layer to `modules_to_save`, the classification head won't be saved. The next time you load the model, you'll get a _different_ randomly initialized classification head, resulting in completely different results.
+
+PEFT tries to correctly guess the `modules_to_save` if you provide the `task_type` argument in the config. This should work for transformers models that follow the standard naming scheme. It is always a good idea to double check though because we can't guarantee all models follow the naming scheme.
+
+When you load a transformers model that has randomly initialized layers, you should see a warning along the lines of:
+
+```
+Some weights of were not initialized from the model checkpoint at and are newly initialized: [].
+You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
+```
+
+The mentioned layers should be added to `modules_to_save` in the config to avoid the described problem.
+
+> [!TIP]
+> As an example, when loading a model that is using the DeBERTa architecture for sequence classification, you'll see a warning that the following weights are newly initialized: `['classifier.bias', 'classifier.weight', 'pooler.dense.bias', 'pooler.dense.weight']`. From this, it follows that the `classifier` and `pooler` layers should be added to: `modules_to_save=["classifier", "pooler"]`.
+
+### Extending the vocabulary
+
+For many language fine-tuning tasks, extending the model's vocabulary is necessary since new tokens are being introduced. This requires extending the embedding layer to account for the new tokens and, depending on the fine-tuning method, also storing the embedding layer in addition to the adapter weights when saving the adapter. There are a few ways of achieving this ordered by parameter effectiveness:
+
+- [trainable tokens](../package_reference/trainable_tokens), train only the specified tokens, optionally store only the updated values
+- training an adapter on the embedding matrix, optionally store only the updated values
+- full-finetuning of the embedding layer
+
+#### Using trainable tokens
+
+Let's start with trainable tokens, in this case its [LoRA integration](../package_reference/lora#efficiently-train-tokens-alongside-lora). If you're interested in only training the new embeddings and nothing else, refer to the [standalone documentation](../package_reference/trainable_tokens).
+
+To enable selective token training of the embedding layer, you'll need to supply the token ids of your newly added tokens via the `trainable_token_indices` parameter. Optionally you can specify which layer to target if there is more than one embedding layer. For a Mistral model this could look like this:
+
+```python
+new_tokens = ['', '']
+tokenizer.add_tokens(new_tokens)
+base_model.resize_token_embeddings(len(tokenizer))
+
+lora_config = LoraConfig(
+ ...,
+ trainable_token_indices={'embed_tokens': tokenizer.convert_tokens_to_ids(new_tokens)},
+)
+```
+
+If your model uses tied weights (such as the `lm_head`), trainable tokens will try to resolve those and keep them updated as well, so in that case there should be no need for adding `modules_to_save=["lm_head"]`. This only works if the model uses the Transformers convention for tying weights.
+
+Saving the model with `model.save_pretrained` may save the full embedding matrix instead of
+only the difference as a precaution because the embedding matrix was resized. To save space you can disable this behavior by setting `save_embedding_layers=False` when calling `save_pretrained`. This is safe to do as long as you don't modify the embedding matrix through other means as well, as such changes will be not tracked by trainable tokens.
+
+#### Using an adapter, e.g. LoRA
+
+Prepare the embedding layer by adding it to the `target_modules` of your adapter config. For example, the Mistral config could look like this:
+
+```python
+config = LoraConfig(..., target_modules=["embed_tokens", "lm_head", "q_proj", "v_proj"])
+```
+
+Once added to `target_modules`, PEFT automatically stores the embedding layer when saving the adapter if the model has the [`~transformers.PreTrainedModel.get_input_embeddings`] and [`~transformers.PreTrainedModel.get_output_embeddings`]. This is generally the case for Transformers models.
+
+If the model's embedding layer doesn't follow the Transformer's naming scheme but nevertheless implements `get_input_embeddings`, you can still save it by manually passing `save_embedding_layers=True` when saving the adapter:
+
+```python
+model = get_peft_model(...)
+# train the model
+model.save_pretrained("my_adapter", save_embedding_layers=True)
+```
+
+For inference, load the base model first and resize it the same way you did before you trained the model. After you've resized the base model, you can load the PEFT checkpoint.
+
+For a complete example, please check out [this notebook](https://github.com/huggingface/peft/blob/main/examples/causal_language_modeling/peft_lora_clm_with_additional_tokens.ipynb).
+
+#### Full fine-tuning
+
+Full fine-tuning is more costly in terms of VRAM or storage space but if all else fails, you can fall back to this and see if it works for you. Achieve it by adding the name of the embedding layer to `modules_to_save`. Note that you need to add tied layers as well, e.g. `lm_head`. Example for a Mistral model with LoRA:
+
+```python
+config = LoraConfig(..., modules_to_save=["embed_tokens", "lm_head"], target_modules=["q_proj", "v_proj"])
+```
+
+### Getting a warning about "weights not being initialized from the model checkpoint"
+
+When you load your PEFT model which has been trained on a task (for example, classification), you may get a warning like:
+
+> Some weights of LlamaForSequenceClassification were not initialized from the model checkpoint at meta-llama/Llama-3.2-1B and are newly initialized: ['score.weight']. You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
+
+Although this looks scary, it is most likely nothing to worry about. This warning comes from Transformers, and it isn't a PEFT specific warning. It lets you know that a randomly initialized classification head (`score`) is attached to the base model, and the head must be trained to produce sensible predictions.
+
+When you get this warning _before_ training the model, PEFT automatically takes care of making the classification head trainable if you correctly passed the `task_type` argument to the PEFT config.
+
+```python
+from peft import LoraConfig, TaskType
+
+lora_config = LoraConfig(..., task_type=TaskType.SEQ_CLS)
+```
+
+If your classification head does not follow the usual naming conventions from Transformers (which is rare), you have to explicitly tell PEFT the name of the head in `modules_to_save`.
+
+```python
+lora_config = LoraConfig(..., modules_to_save=["name-of-classification-head"])
+```
+
+To check the name of the classification head, print the model and it should be the last module.
+
+If you get this warning from your inference code, i.e. _after_ training the model, when you load the PEFT model, you always have to load the Transformers model first. Since Transformers does not know that you will load PEFT weights afterwards, it still gives the warning.
+
+As always, it is best practice to ensure the model works correctly for inference by running some validation on it.
+
+### Check layer and model status
+
+Sometimes a PEFT model can end up in a bad state, especially when handling multiple adapters. There can be some confusion around what adapters exist, which one is active, which one is merged, etc. To help investigate this issue, call the [`~peft.PeftModel.get_layer_status`] and the [`~peft.PeftModel.get_model_status`] methods.
+
+The [`~peft.PeftModel.get_layer_status`] method gives you a detailed overview of each targeted layer's active, merged, and available adapters.
+
+```python
+>>> from transformers import AutoModel
+>>> from peft import get_peft_model, LoraConfig
+
+>>> model_id = "google/flan-t5-small"
+>>> model = AutoModel.from_pretrained(model_id)
+>>> model = get_peft_model(model, LoraConfig())
+
+>>> model.get_layer_status()
+[TunerLayerStatus(name='model.encoder.block.0.layer.0.SelfAttention.q',
+ module_type='lora.Linear',
+ enabled=True,
+ active_adapters=['default'],
+ merged_adapters=[],
+ requires_grad={'default': True},
+ available_adapters=['default']),
+ TunerLayerStatus(name='model.encoder.block.0.layer.0.SelfAttention.v',
+ module_type='lora.Linear',
+ enabled=True,
+ active_adapters=['default'],
+ merged_adapters=[],
+ requires_grad={'default': True},
+ available_adapters=['default']),
+...]
+
+>>> model.get_model_status()
+TunerModelStatus(
+ base_model_type='T5Model',
+ adapter_model_type='LoraModel',
+ peft_types={'default': 'LORA'},
+ trainable_params=344064,
+ total_params=60855680,
+ num_adapter_layers=48,
+ enabled=True,
+ active_adapters=['default'],
+ merged_adapters=[],
+ requires_grad={'default': True},
+ available_adapters=['default'],
+)
+```
+
+In the model state output, you should look out for entries that say `"irregular"`. This means PEFT detected an inconsistent state in the model. For instance, if `merged_adapters="irregular"`, it means that for at least one adapter, it was merged on some target modules but not on others. The inference results will most likely be incorrect as a result.
+
+The best way to resolve this issue is to reload the whole model and adapter checkpoint(s). Ensure that you don't perform any incorrect operations on the model, e.g. manually merging adapters on some modules but not others.
+
+Convert the layer status into a pandas `DataFrame` for an easier visual inspection.
+
+```python
+from dataclasses import asdict
+import pandas as pd
+
+df = pd.DataFrame(asdict(layer) for layer in model.get_layer_status())
+```
+
+It is possible to get this information for non-PEFT models if they are using PEFT layers under the hood, but some information like the `base_model_type` or the `peft_types` cannot be determined in that case. As an example, you can call this on a [diffusers](https://huggingface.co/docs/diffusers/index) model like so:
+
+```python
+>>> import torch
+>>> from diffusers import StableDiffusionPipeline
+>>> from peft import get_model_status, get_layer_status
+
+>>> path = "runwayml/stable-diffusion-v1-5"
+>>> lora_id = "takuma104/lora-test-text-encoder-lora-target"
+>>> pipe = StableDiffusionPipeline.from_pretrained(path, dtype=torch.float16)
+>>> pipe.load_lora_weights(lora_id, adapter_name="adapter-1")
+>>> pipe.load_lora_weights(lora_id, adapter_name="adapter-2")
+>>> pipe.set_lora_device(["adapter-2"], "cuda")
+>>> get_layer_status(pipe.text_encoder)
+[TunerLayerStatus(name='text_model.encoder.layers.0.self_attn.k_proj',
+ module_type='lora.Linear',
+ enabled=True,
+ active_adapters=['adapter-2'],
+ merged_adapters=[],
+ requires_grad={'adapter-1': False, 'adapter-2': True},
+ available_adapters=['adapter-1', 'adapter-2'],
+ devices={'adapter-1': ['cpu'], 'adapter-2': ['cuda']}),
+ TunerLayerStatus(name='text_model.encoder.layers.0.self_attn.v_proj',
+ module_type='lora.Linear',
+ enabled=True,
+ active_adapters=['adapter-2'],
+ merged_adapters=[],
+ requires_grad={'adapter-1': False, 'adapter-2': True},
+ devices={'adapter-1': ['cpu'], 'adapter-2': ['cuda']}),
+...]
+
+>>> get_model_status(pipe.unet)
+TunerModelStatus(
+ base_model_type='other',
+ adapter_model_type='None',
+ peft_types={},
+ trainable_params=797184,
+ total_params=861115332,
+ num_adapter_layers=128,
+ enabled=True,
+ active_adapters=['adapter-2'],
+ merged_adapters=[],
+ requires_grad={'adapter-1': False, 'adapter-2': True},
+ available_adapters=['adapter-1', 'adapter-2'],
+ devices={'adapter-1': ['cpu'], 'adapter-2': ['cuda']},
+)
+```
+
+## Speed
+
+### Loading adapter weights is slow
+
+Loading adapters like LoRA weights should generally be fast compared to loading the base model. However, there can be use cases where the adapter weights are quite large or where users need to load a large number of adapters -- the loading time can add up in this case. The reason for this is that the adapter weights are first initialized and then overridden by the loaded weights, which is wasteful. To speed up the loading time, you can pass the `low_cpu_mem_usage=True` argument to [`~PeftModel.from_pretrained`] and [`~PeftModel.load_adapter`].
+
+> [!TIP]
+> If this option works well across different use cases, it may become the default for adapter loading in the future.
+
+
+## Reproducibility
+
+### Models using batch norm
+
+When loading a trained PEFT model where the base model uses batch norm (e.g. `torch.nn.BatchNorm1d` or `torch.nn.BatchNorm2d`), you may find that you cannot reproduce the exact same outputs. This is because the batch norm layers keep track of running stats during training, but these stats are not part of the PEFT checkpoint. Therefore, when you load the PEFT model, the running stats of the base model will be used (i.e. from before training with PEFT).
+
+Depending on your use case, this may not be a big deal. If, however, you need your outputs to be 100% reproducible, you can achieve this by adding the batch norm layers to `modules_to_save`. Below is an example of this using resnet and LoRA. Notice that we set `modules_to_save=["classifier", "normalization"]`. We need the `"classifier"` argument because our task is image classification, and we add the `"normalization"` argument to ensure that the batch norm layers are saved in the PEFT checkpoint.
+
+```python
+from transformers import AutoModelForImageClassification
+from peft import LoraConfig, get_peft_model
+
+model_id = "microsoft/resnet-18"
+base_model = AutoModelForImageClassification.from_pretrained(self.model_id)
+config = LoraConfig(
+ target_modules=["convolution"],
+ modules_to_save=["classifier", "normalization"],
+),
+```
+
+Depending on the type of model you use, the batch norm layers could have different names than `"normalization"`, so please ensure that the name matches your model architecture.
+
+## Version mismatch
+
+### Error while loading the config because of an unexpected keyword argument
+
+When you encounter an error like the one shown below, it means the adapter you're trying to load was trained with a more recent version of PEFT than the version you have installed on your system.
+
+```
+TypeError: LoraConfig.__init__() got an unexpected keyword argument
+```
+
+The best way to resolve this issue is to install the latest PEFT version:
+
+```sh
+python -m pip install -U PEFT
+```
+
+If the adapter was trained from a source install of PEFT (an unreleased version of PEFT), then you also need to install PEFT from source.
+
+```sh
+python -m pip install -U git+https://github.com/huggingface/peft.git
+```
+
+If it is not possible for you to upgrade PEFT, there is a workaround you can try.
+
+Assume the error message says that the unknown keyword argument is named `foobar`. Search inside the `adapter_config.json` of this PEFT adapter for the `foobar` entry and delete it from the file. Then save the file and try loading the model again.
+
+This solution works most of the time. As long as it is the default value for `foobar`, it can be ignored. However, when it is set to some other value, you will get incorrect results. Upgrading PEFT is the recommended solution.
+
+## Adapter handling
+
+### Using multiple adapters at the same time
+
+PEFT allows you to create more than one adapter on the same model. This can be useful in many situations. For example, for inference, you may want to serve two fine-tuned models from the same base model instead of loading the base model once for each fine-tuned model, which would cost more memory. However, multiple adapters can be activated at the same time. This way, the model may leverage the learnings from all those adapters at the same time. As an example, if you have a diffusion model, you may want to use one LoRA adapter to change the style and a different one to change the subject.
+
+Activating multiple adapters at the same time is generally possible on all PEFT methods (LoRA, LoHa, IA³, etc.) except for prompt learning methods (p-tuning, prefix tuning, etc.). The following example illustrates how to achieve this:
+
+```python
+from transformers import AutoModelForCausalLM
+from peft import PeftModel
+
+model_id = ...
+base_model = AutoModelForCausalLM.from_pretrained(model_id)
+model = PeftModel.from_pretrained(base_model, lora_path_0) # default adapter_name is 'default'
+model.load_adapter(lora_path_1, adapter_name="other")
+# the 'other' adapter was loaded but it's not active yet, so to activate both adapters:
+model.base_model.set_adapter(["default", "other"])
+```
+
+> [!TIP]
+> In the example above, you can see that we need to call `model.base_model.set_adapter(["default", "other"])`. Why can we not call `model.set_adapter(["default", "other"])`? This is unfortunately not possible because, as explained earlier, some PEFT methods don't support activating more than one adapter at a time.
+
+It is also possible to train two adapters at the same time, but you should be careful to ensure that the weights of both adapters are known to the optimizer. Otherwise, only one adapter will receive updates.
+
+```python
+from transformers import AutoModelForCausalLM
+from peft import LoraConfig, get_peft_model
+
+model_id = ...
+base_model = AutoModelForCausalLM.from_pretrained(model_id)
+lora_config_0 = LoraConfig(...)
+lora_config_1 = LoraConfig(...)
+model = get_peft_model(base_model, lora_config_0)
+model.add_adapter(adapter_name="other", peft_config=lora_config_1)
+```
+
+If we would now call:
+
+```python
+from transformers import Trainer
+
+trainer = Trainer(model=model, ...)
+trainer.train()
+```
+
+or
+
+```python
+optimizer = torch.optim.AdamW([param for param in model.parameters() if param.requires_grad], ...)
+```
+
+then the second LoRA adapter (`"other"`) would not be trained. This is because it is inactive at this moment, which means the `requires_grad` attribute on its parameters is set to `False` and the optimizer will ignore it. Therefore, make sure to activate all adapters that should be trained _before_ initializing the optimizer:
+
+```python
+# activate all adapters
+model.base_model.set_adapter(["default", "other"])
+trainer = Trainer(model=model, ...)
+trainer.train()
+```
+
+> [!TIP]
+> This section deals with using multiple adapters _of the same type_ on the same model, for example, using multiple LoRA adapters at the same time. It does not apply to using _different types_ of adapters on the same model, for example one LoRA adapter and one LoHa adapter. For this, please check [`PeftMixedModel`](https://huggingface.co/docs/peft/developer_guides/mixed_models).
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/guides/peft_integrations.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/guides/peft_integrations.md
new file mode 100644
index 0000000000000000000000000000000000000000..6892fddbcb051f8d92ea3aa841e5a427dc0586b4
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/guides/peft_integrations.md
@@ -0,0 +1,152 @@
+
+
+# PEFT integrations
+
+PEFT's practical benefits extends to other Hugging Face libraries like [Diffusers](https://hf.co/docs/diffusers) and [Transformers](https://hf.co/docs/transformers). One of the main benefits of PEFT is that an adapter file generated by a PEFT method is a lot smaller than the original model, which makes it super easy to manage and use multiple adapters. You can use one pretrained base model for multiple tasks by simply loading a new adapter finetuned for the task you're solving. Or you can combine multiple adapters with a text-to-image diffusion model to create new effects.
+
+This tutorial will show you how PEFT can help you manage adapters in Diffusers and Transformers.
+
+## Diffusers
+
+Diffusers is a generative AI library for creating images and videos from text or images with diffusion models. LoRA is an especially popular training method for diffusion models because you can very quickly train and share diffusion models to generate images in new styles. To make it easier to use and try multiple LoRA models, Diffusers uses the PEFT library to help manage different adapters for inference.
+
+For example, load a base model and then load the [artificialguybr/3DRedmond-V1](https://huggingface.co/artificialguybr/3DRedmond-V1) adapter for inference with the [`load_lora_weights`](https://huggingface.co/docs/diffusers/v0.24.0/en/api/loaders/lora#diffusers.loaders.LoraLoaderMixin.load_lora_weights) method. The `adapter_name` argument in the loading method is enabled by PEFT and allows you to set a name for the adapter so it is easier to reference.
+
+```py
+import torch
+from diffusers import DiffusionPipeline
+
+pipeline = DiffusionPipeline.from_pretrained(
+ "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
+).to("cuda")
+pipeline.load_lora_weights(
+ "peft-internal-testing/artificialguybr__3DRedmond-V1",
+ weight_name="3DRedmond-3DRenderStyle-3DRenderAF.safetensors",
+ adapter_name="3d"
+)
+image = pipeline("sushi rolls shaped like kawaii cat faces").images[0]
+image
+```
+
+
+
+
+
+Now let's try another cool LoRA model, [ostris/super-cereal-sdxl-lora](https://huggingface.co/ostris/super-cereal-sdxl-lora). All you need to do is load and name this new adapter with `adapter_name`, and use the [`set_adapters`](https://huggingface.co/docs/diffusers/api/loaders/unet#diffusers.loaders.UNet2DConditionLoadersMixin.set_adapters) method to set it as the currently active adapter.
+
+```py
+pipeline.load_lora_weights(
+ "ostris/super-cereal-sdxl-lora",
+ weight_name="cereal_box_sdxl_v1.safetensors",
+ adapter_name="cereal"
+)
+pipeline.set_adapters("cereal")
+image = pipeline("sushi rolls shaped like kawaii cat faces").images[0]
+image
+```
+
+
+
+
+
+Finally, you can call the [`disable_lora`](https://huggingface.co/docs/diffusers/api/loaders/unet#diffusers.loaders.UNet2DConditionLoadersMixin.disable_lora) method to restore the base model.
+
+```py
+pipeline.disable_lora()
+```
+
+Learn more about how PEFT supports Diffusers in the [Inference with PEFT](https://huggingface.co/docs/diffusers/tutorials/using_peft_for_inference) tutorial.
+
+## Transformers
+
+🤗 [Transformers](https://hf.co/docs/transformers) is a collection of pretrained models for all types of tasks in all modalities. You can load these models for training or inference. Many of the models are large language models (LLMs), so it makes sense to integrate PEFT with Transformers to manage and train adapters.
+
+Load a base pretrained model to train.
+
+```py
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")
+```
+
+Next, add an adapter configuration to specify how to adapt the model parameters. Call the [`~PeftModel.add_adapter`] method to add the configuration to the base model.
+
+```py
+from peft import LoraConfig
+
+peft_config = LoraConfig(
+ lora_alpha=16,
+ lora_dropout=0.1,
+ r=64,
+ bias="none",
+ task_type="CAUSAL_LM"
+)
+model.add_adapter(peft_config)
+```
+
+Now you can train the model with Transformer's [`~transformers.Trainer`] class or whichever training framework you prefer.
+
+To use the newly trained model for inference, the [`~transformers.AutoModel`] class uses PEFT on the backend to load the adapter weights and configuration file into a base pretrained model.
+
+```py
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/opt-350m-lora")
+```
+
+Alternatively, you can use transformers [Pipelines](https://huggingface.co/docs/transformers/en/main_classes/pipelines) to load the model for conveniently running inference:
+
+```py
+from transformers import pipeline
+
+model = pipeline("text-generation", "peft-internal-testing/opt-350m-lora")
+print(model("Hello World"))
+```
+
+If you're interested in comparing or using more than one adapter, you can call the [`~PeftModel.add_adapter`] method to add the adapter configuration to the base model. The only requirement is the adapter type must be the same (you can't mix a LoRA and LoHa adapter).
+
+```py
+from transformers import AutoModelForCausalLM
+from peft import LoraConfig
+
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")
+model.add_adapter(lora_config_1, adapter_name="adapter_1")
+```
+
+Call [`~PeftModel.add_adapter`] again to attach a new adapter to the base model.
+
+```py
+model.add_adapter(lora_config_2, adapter_name="adapter_2")
+```
+
+Then you can use [`~PeftModel.set_adapter`] to set the currently active adapter.
+
+```py
+model.set_adapter("adapter_1")
+output = model.generate(**inputs)
+print(tokenizer.decode(output_disabled[0], skip_special_tokens=True))
+```
+
+To disable the adapter, call the [disable_adapters](https://github.com/huggingface/transformers/blob/4e3490f79b40248c53ee54365a9662611e880892/src/transformers/integrations/peft.py#L313) method.
+
+```py
+model.disable_adapters()
+```
+
+The [enable_adapters](https://github.com/huggingface/transformers/blob/4e3490f79b40248c53ee54365a9662611e880892/src/transformers/integrations/peft.py#L336) can be used to enable the adapters again.
+
+If you're curious, check out the [Load and train adapters with PEFT](https://huggingface.co/docs/transformers/main/peft) tutorial to learn more.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/guides/peft_model_config.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/guides/peft_model_config.md
new file mode 100644
index 0000000000000000000000000000000000000000..4f6df826ffce1e554abf598a1d88916ac683702e
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/guides/peft_model_config.md
@@ -0,0 +1,179 @@
+
+
+# PEFT configurations and models
+
+The sheer size of today's large pretrained models - which commonly have billions of parameters - presents a significant training challenge because they require more storage space and more computational power to crunch all those calculations. You'll need access to powerful GPUs or TPUs to train these large pretrained models which is expensive, not widely accessible to everyone, not environmentally friendly, and not very practical. PEFT methods address many of these challenges. There are several types of PEFT methods (soft prompting, matrix decomposition, adapters), but they all focus on the same thing, reduce the number of trainable parameters. This makes it more accessible to train and store large models on consumer hardware.
+
+The PEFT library is designed to help you quickly train large models on free or low-cost GPUs, and in this tutorial, you'll learn how to setup a configuration to apply a PEFT method to a pretrained base model for training. Once the PEFT configuration is setup, you can use any training framework you like (Transformer's [`~transformers.Trainer`] class, [Accelerate](https://hf.co/docs/accelerate), a custom PyTorch training loop).
+
+## PEFT configurations
+
+> [!TIP]
+> Learn more about the parameters you can configure for each PEFT method in their respective API reference page.
+
+A configuration stores important parameters that specify how a particular PEFT method should be applied.
+
+For example, take a look at the following `LoraConfig` for applying LoRA and `PromptEncoderConfig` for applying p-tuning (these configuration files are already JSON-serialized). Whenever you load a PEFT adapter, it is a good idea to check whether it has an associated `adapter_config.json` file which is required.
+
+
+
+
+```json
+{
+ "base_model_name_or_path": "facebook/opt-350m", #base model to apply LoRA to
+ "bias": "none",
+ "fan_in_fan_out": false,
+ "inference_mode": true,
+ "init_lora_weights": true,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "lora_alpha": 32,
+ "lora_dropout": 0.05,
+ "modules_to_save": null,
+ "peft_type": "LORA", #PEFT method type
+ "r": 16,
+ "revision": null,
+ "target_modules": [
+ "q_proj", #model modules to apply LoRA to (query and value projection layers)
+ "v_proj"
+ ],
+ "task_type": "CAUSAL_LM" #type of task to train model on
+}
+```
+
+You can create your own configuration for training by initializing a [`LoraConfig`].
+
+```py
+from peft import LoraConfig, TaskType
+
+lora_config = LoraConfig(
+ r=16,
+ target_modules=["q_proj", "v_proj"],
+ task_type=TaskType.CAUSAL_LM,
+ lora_alpha=32,
+ lora_dropout=0.05
+)
+```
+
+
+
+
+```json
+{
+ "base_model_name_or_path": "roberta-large", #base model to apply p-tuning to
+ "encoder_dropout": 0.0,
+ "encoder_hidden_size": 128,
+ "encoder_num_layers": 2,
+ "encoder_reparameterization_type": "MLP",
+ "inference_mode": true,
+ "num_attention_heads": 16,
+ "num_layers": 24,
+ "num_transformer_submodules": 1,
+ "num_virtual_tokens": 20,
+ "peft_type": "P_TUNING", #PEFT method type
+ "task_type": "SEQ_CLS", #type of task to train model on
+ "token_dim": 1024
+}
+```
+
+You can create your own configuration for training by initializing a [`PromptEncoderConfig`].
+
+```py
+from peft import PromptEncoderConfig, TaskType
+
+p_tuning_config = PromptEncoderConfig(
+ encoder_reparameterization_type="MLP",
+ encoder_hidden_size=128,
+ num_attention_heads=16,
+ num_layers=24,
+ num_transformer_submodules=1,
+ num_virtual_tokens=20,
+ token_dim=1024,
+ task_type=TaskType.SEQ_CLS
+)
+```
+
+
+
+
+## PEFT models
+
+With a PEFT configuration in hand, you can now apply it to any pretrained model to create a [`PeftModel`]. Choose from any of the state-of-the-art models from the [Transformers](https://hf.co/docs/transformers) library, a custom model, and even new and unsupported transformer architectures.
+
+For this tutorial, load a base [facebook/opt-350m](https://huggingface.co/facebook/opt-350m) model to finetune.
+
+```py
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")
+```
+
+Use the [`get_peft_model`] function to create a [`PeftModel`] from the base facebook/opt-350m model and the `lora_config` you created earlier.
+
+```py
+from peft import get_peft_model
+
+lora_model = get_peft_model(model, lora_config)
+lora_model.print_trainable_parameters()
+"trainable params: 1,572,864 || all params: 332,769,280 || trainable%: 0.472659014678278"
+```
+
+> [!WARNING]
+> When calling [`get_peft_model`], the base model will be modified *in-place*. That means, when calling [`get_peft_model`] on a model that was already modified in the same way before, this model will be further mutated. Therefore, if you would like to modify your PEFT configuration after having called [`get_peft_model()`] before, you would first have to unload the model with [`~LoraModel.unload`] and then call [`get_peft_model()`] with your new configuration. Alternatively, you can re-initialize the model to ensure a fresh, unmodified state before applying a new PEFT configuration.
+
+Now you can train the [`PeftModel`] with your preferred training framework! After training, you can save your model locally with [`~PeftModel.save_pretrained`] or upload it to the Hub with the [`~transformers.PreTrainedModel.push_to_hub`] method.
+
+```py
+# save locally
+lora_model.save_pretrained("your-name/opt-350m-lora")
+
+# push to Hub
+lora_model.push_to_hub("your-name/opt-350m-lora")
+```
+
+To load a [`PeftModel`] for inference, you'll need to provide the [`PeftConfig`] used to create it and the base model it was trained from.
+
+```py
+from peft import PeftModel, PeftConfig
+
+config = PeftConfig.from_pretrained("ybelkada/opt-350m-lora")
+model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path)
+lora_model = PeftModel.from_pretrained(model, "ybelkada/opt-350m-lora")
+```
+
+> [!TIP]
+> By default, the [`PeftModel`] is set for inference, but if you'd like to train the adapter some more you can set `is_trainable=True`.
+>
+> ```py
+> lora_model = PeftModel.from_pretrained(model, "ybelkada/opt-350m-lora", is_trainable=True)
+> ```
+
+The [`PeftModel.from_pretrained`] method is the most flexible way to load a [`PeftModel`] because it doesn't matter what model framework was used (Transformers, timm, a generic PyTorch model). Other classes, like [`AutoPeftModel`], are just a convenient wrapper around the base [`PeftModel`], and makes it easier to load PEFT models directly from the Hub or locally where the PEFT weights are stored.
+
+```py
+from peft import AutoPeftModelForCausalLM
+
+lora_model = AutoPeftModelForCausalLM.from_pretrained("ybelkada/opt-350m-lora")
+```
+
+Take a look at the [AutoPeftModel](../package_reference/auto_class) API reference to learn more about the [`AutoPeftModel`] classes.
+
+## Next steps
+
+With the appropriate [`PeftConfig`], you can apply it to any pretrained model to create a [`PeftModel`] and train large powerful models faster on freely available GPUs! To learn more about PEFT configurations and models, the following guide may be helpful:
+
+* Learn how to configure a PEFT method for models that aren't from Transformers in the [Working with custom models](../developer_guides/custom_models) guide.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/index.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..16b9ae63dc5c4eba608cd1e43bb9a2436c342a59
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/index.md
@@ -0,0 +1,42 @@
+
+
+# PEFT
+
+🤗 PEFT (Parameter-Efficient Fine-Tuning) is a library for efficiently adapting large pretrained models to various downstream applications without fine-tuning all of a model's parameters because it is prohibitively costly. PEFT methods only fine-tune a small number of (extra) model parameters - significantly decreasing computational and storage costs - while yielding performance comparable to a fully fine-tuned model. This makes it more accessible to train and store large language models (LLMs) and other big models on consumer hardware.
+
+PEFT is integrated with the Transformers, Diffusers, and Accelerate libraries to provide a faster and easier way to load, train, and use large models for inference.
+
+
+
+ There are numerous methods to "adapt" existing models, often extensively integrating into the model. PEFT can be thought of as a framework for arbitrary methods of model adaption (modifying weights, wrapping layers, manipulating KV-caches, ...) while also serving as a reference implementation for many fine-tuning methods.
+
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/install.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/install.md
new file mode 100644
index 0000000000000000000000000000000000000000..49279bfa873e41cc812dc7eaf636cc8751d14ceb
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/install.md
@@ -0,0 +1,47 @@
+
+
+# Installation
+
+Before you start, you will need to setup your environment, install the appropriate packages, and configure 🤗 PEFT. 🤗 PEFT is tested on **Python 3.9+**.
+
+🤗 PEFT is available on PyPI, as well as GitHub:
+
+## PyPI
+
+To install 🤗 PEFT from PyPI:
+
+```bash
+pip install peft
+```
+
+## Source
+
+New features that haven't been released yet are added every day, which also means there may be some bugs. To try them out, install from the GitHub repository:
+
+```bash
+pip install git+https://github.com/huggingface/peft
+```
+
+If you're working on contributing to the library or wish to play with the source code and see live
+results as you run the code, an editable version can be installed from a locally-cloned version of the
+repository:
+
+```bash
+git clone https://github.com/huggingface/peft
+cd peft
+pip install -e .[test]
+```
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/methods/overview.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/methods/overview.md
new file mode 100644
index 0000000000000000000000000000000000000000..c8ce9fe04bc998d3e41f50056208cffb4bd331aa
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/methods/overview.md
@@ -0,0 +1,65 @@
+
+
+
+# Parameter efficient fine-tuning methods
+
+PEFT methods train as few parameters as possible while aiming for performance comparable to full fine-tuning. Fewer trainable parameters are less expressive, so the same performance isn't guaranteed. In exchange you use less memory, often less compute, and gain features like fast hot-swapping between expert adapters and less forgetting of prior knowledge.
+
+Giving general advice for training large models is hard but for generative models, especially language models, you can follow these steps:
+
+1. use prompting (e.g. few-shot examples in the prompt) to see if the model is already capable of the task. If the model solves your problem, great! You can now use [Prompt-based methods](#prompt-based-methods) to learn the prompt and save precious tokens.
+2. If prompt-based methods are not sufficient you can use [layer tuning](#layer-tuning) and [adapter methods](#adapter-methods). These methods are generally more expressive than prompt-based methods and get closer to full-finetuning.
+3. Make sure to measure retention of already learnt knowledge since each fine-tuning step is potentially unlearning past knowledge.
+
+The [PEFT method comparison suite](https://huggingface.co/spaces/peft-internal-testing/PEFT-method-comparison) aims to give a rough overview of (most) implemented methods on selected benchmarks and models.
+
+> [!NOTE]
+> Not all PEFT methods are created equal and there are differences between capabilities:
+> * Quantization: not all methods support quantized base models
+> * Features: not all features are supported for all methods (e.g., multiple adapters, mixed adapter inference, merging/unmerging)
+> * Layer types: linear layers are generally supported, but not all adapter methods support embedding (important for extending vocabulary) or convolutional layers (important for some image models)
+> * Runtime: PEFT methods generally add runtime overhead but some of that can be mitigated (e.g., by [merging the adapter weights](../developer_guides/checkpoint#merge-the-weights))
+
+## Prompt-based methods
+
+Prompting primes a frozen pretrained model for a specific downstream task by including a text prompt that describes the task or even demonstrates an example of the task. With prompting, you can avoid fully training a separate model for each downstream task, and use the same frozen pretrained model instead. This is a lot easier because you can use the same model for several different tasks, and it is significantly more efficient to train and store a smaller set of prompt parameters than to train all the model's parameters.
+
+There are two categories of prompting methods:
+
+- hard prompts are manually handcrafted text prompts with discrete input tokens; the downside is that it requires a lot of effort to create a good prompt
+- soft prompts are learnable tensors concatenated with the input embeddings that can be optimized to a dataset; the downside is that they aren't human readable because you aren't matching these "virtual tokens" to the embeddings of a real word
+
+The PEFT library supports several types of prompting methods (p-tuning, prefix tuning, prompt tuning, ...), explore the table of contents for a full listing of soft prompt methods.
+If you're interested in applying these methods to other tasks and use cases, take a look at our [notebook collection](https://huggingface.co/spaces/PEFT/soft-prompting)!
+
+> [!TIP]
+> Some familiarity with the general process of training a causal language model would be really helpful and allow you to focus on the soft prompting methods. If you're new, we recommend taking a look at the [Causal language modeling](https://huggingface.co/docs/transformers/tasks/language_modeling) guide first from the Transformers documentation. When you're ready, come back and see how easy it is to drop PEFT into your training!
+
+## Layer Tuning
+
+Layer Tuning categorizes methods that target one type of layer or one aspect of a layer specifically, for example [LayerNorm Tuning](../package_reference/layernorm_tuning) targets only [`LayerNorm`](https://docs.pytorch.org/docs/stable/generated/torch.nn.LayerNorm.html) layers and [TrainableTokens](../package_reference/trainable_tokens) only targets specific tokens in the embedding matrix. This contrasts prompt-based methods which work with the model input or adapter methods which extend the existing weights and are generally more independent of the layer type, targeting linear or convolutional layers.
+
+## Adapter methods
+
+Adapter methods can be seen as ways of adding relatively small, trainable matrices to existing models for fine-tuning. The goal is to introduce few trainable parameters to steer the big model in the direction of the task that needs fine-tuning to save on resources, such as memory or compute.
+
+A popular way to realize adapters is to insert smaller trainable matrices that are a low-rank decomposition of the adapted weight's layout to save on memory. There are several different ways to express the weight matrix as a low-rank decomposition, but [Low-Rank Adaptation (LoRA)](../package_reference/lora) is the most common method. The PEFT library supports several other variations of this formulation - some are direct variants of LoRA and are documented under LoRA, some are different enough to count as their own methods, such as [Low-Rank Hadamard Product (LoHa)](../package_reference/loha), [Low-Rank Kronecker Product (LoKr)](../package_reference/lokr), and [Adaptive Low-Rank Adaptation (AdaLoRA)](../package_reference/adalora). If you're interested in applying these methods to other tasks and use cases like semantic segmentation, token classification, take a look at our [notebook collection](https://huggingface.co/collections/PEFT/notebooks-6573b28b33e5a4bf5b157fc1)!
+
+> [!TIP]
+> LoRA is one of the most popular PEFT methods and a good starting point if you're just getting started with PEFT. It was originally developed for large language models but it is a tremendously popular training method for diffusion models because of its efficiency and effectiveness.
+
+Low-rank adapters are only one possible adapter formulation, PEFT implements many other types of adapters as well. For example, Orthogonal Fine-Tuning methods ([OFT](../package_reference/oft), [BOFT](../package_reference/boft), ...) use orthogonal decompositions of the adapter weights to achieve small size. Methods like [MiSS](../package_reference/miss) shard matrices and share these shards to save on memory. [IA3](../package_reference/ia3) introduces learned vectors that rescale the key, value, and feed-forward activations.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/adalora.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/adalora.md
new file mode 100644
index 0000000000000000000000000000000000000000..f96142d9f21148717b28d4047ed08a275baf9539
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/adalora.md
@@ -0,0 +1,79 @@
+
+
+# AdaLoRA
+
+[AdaLoRA](https://hf.co/papers/2303.10512) (Adaptive LoRA) is a method for optimizing the number of trainable parameters to assign to weight matrices and layers, unlike LoRA, which distributes parameters evenly across all modules. More parameters are budgeted for important weight matrices and layers while less important ones receive fewer parameters. You can control the average desired *rank* or `r` of the matrices, and which modules to apply AdaLoRA to with `target_modules`. Other important parameters to set are `lora_alpha` (scaling factor), and `modules_to_save` (the modules apart from the AdaLoRA layers to be trained and saved). All of these parameters - and more - are found in the [`AdaLoraConfig`].
+
+The abstract from the paper is:
+
+*Fine-tuning large pre-trained language models on downstream tasks has become an important paradigm in NLP. However, common practice fine-tunes all of the parameters in a pre-trained model, which becomes prohibitive when a large number of downstream tasks are present. Therefore, many fine-tuning methods are proposed to learn incremental updates of pre-trained weights in a parameter efficient way, e.g., low-rank increments. These methods often evenly distribute the budget of incremental updates across all pre-trained weight matrices, and overlook the varying importance of different weight parameters. As a consequence, the fine-tuning performance is suboptimal. To bridge this gap, we propose AdaLoRA, which adaptively allocates the parameter budget among weight matrices according to their importance score. In particular, AdaLoRA parameterizes the incremental updates in the form of singular value decomposition. Such a novel approach allows us to effectively prune the singular values of unimportant updates, which is essentially to reduce their parameter budget but circumvent intensive exact SVD computations. We conduct extensive experiments with several pre-trained models on natural language processing, question answering, and natural language generation to validate the effectiveness of AdaLoRA. Results demonstrate that AdaLoRA manifests notable improvement over baselines, especially in the low budget settings. Our code is publicly available at https://github.com/QingruZhang/AdaLoRA*.
+
+> [!WARNING]
+> AdaLoRA has an [`~AdaLoraModel.update_and_allocate`] method that should be called at each training step to update the parameter budget and mask, otherwise the adaptation step is not performed. This requires writing a custom training loop or subclassing the [`~transformers.Trainer`] to incorporate this method. As an example, take a look at this [custom training loop](https://github.com/huggingface/peft/blob/912ad41e96e03652cabf47522cd876076f7a0c4f/examples/conditional_generation/peft_adalora_seq2seq.py#L120).
+
+AdaLoRA manages the parameter budget introduced from LoRA by allocating more parameters - in other words, a higher rank `r` - for important weight matrices that are better adapted for a task and pruning less important ones. The rank is controlled by a method similar to singular value decomposition (SVD). The $\Delta W$ is parameterized with two orthogonal matrices and a diagonal matrix which contains singular values. This parametrization method avoids iteratively applying SVD which is computationally expensive. Based on this method, the rank of $\Delta W$ is adjusted according to an importance score. $\Delta W$ is divided into triplets and each triplet is scored according to its contribution to model performance. Triplets with low importance scores are pruned and triplets with high importance scores are kept for finetuning.
+
+Training with AdaLoRA has three phases: the init phase, the budgeting phase and the final phase. In the initial phase, no budgeting is applied, therefore the ranks are not touched. During the budgeting phase the process described above is applied and the rank is redistributed according to a budget, aiming to give more important adapters more rank and less important layers less. When reaching the final phase, budgeting has ended, the ranks are redistributed but we may continue training for a while with the redistributed ranks to further improve performance.
+
+> [!NOTE]
+> **Contributions welcome**: This section needs clarification.
+>
+> It is unclear how importance is measured. The explanations are also a bit redundant and could benefit from consolidation.
+> See [here](../developer_guides/contributing#documentation-improvements) on how to contribute.
+
+## Benchmark overview
+
+
+
+## Usage
+
+
+```py
+from peft import AdaLoraConfig, get_peft_model
+
+config = AdaLoraConfig(
+ r=8,
+ init_r=12,
+ tinit=200,
+ tfinal=1000,
+ deltaT=10,
+ target_modules=["query", "value"],
+ modules_to_save=["classifier"],
+)
+model = get_peft_model(model, config)
+model.print_trainable_parameters()
+"trainable params: 520,325 || all params: 87,614,722 || trainable%: 0.5938785036606062"
+
+[... training code ...]
+
+model.update_and_allocate(step_idx)
+```
+
+# API
+
+## AdaLoraConfig
+
+[[autodoc]] tuners.adalora.config.AdaLoraConfig
+
+## AdaLoraModel
+
+[[autodoc]] tuners.adalora.model.AdaLoraModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/adamss.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/adamss.md
new file mode 100644
index 0000000000000000000000000000000000000000..fe3279b29e89b0b491e4bc3b97a7209845692a6b
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/adamss.md
@@ -0,0 +1,48 @@
+
+
+# AdaMSS
+
+[AdaMSS](https://openreview.net/forum?id=8ZdWmpYxT0) (AdaMSS: Adaptive Multi-Subspace Approach for Parameter-Efficient Fine-Tuning) is a parameter-efficient fine-tuning method that decomposes weight matrices using SVD and clusters the decomposed space into multiple trainable subspaces. Each subspace learns independent low-rank updates while the original weights remain frozen. AdaMSS also supports Adaptive Subspace Allocation (ASA), which dynamically prunes less important subspaces during training based on gradient information.
+
+The abstract from the paper is:
+
+> We propose AdaMSS, an adaptive multi-subspace approach for parameter-efficient fine-tuning of large models. Unlike traditional parameterefficient fine-tuning methods that operate within a large single subspace of the network weights, AdaMSS leverages subspace segmentation to obtain multiple smaller subspaces and adaptively reduces the number of trainable parameters during training, ultimately updating only those associated with a small subset of subspaces most relevant to the target downstream task. By using the lowest-rank representation, AdaMSS achieves more compact expressiveness and finer tuning of the model parameters. Theoretical analyses demonstrate that AdaMSS has better generalization guarantee than LoRA, PiSSA, and other single-subspace low-rankbased methods. Extensive experiments across image classification, natural language understanding, and natural language generation tasks show that AdaMSS achieves comparable performance to full fine-tuning and outperforms other parameterefficient fine-tuning methods in most cases, all while requiring fewer trainable parameters. Notably, on the ViT-Large model, AdaMSS achieves 4.7% higher average accuracy than LoRA across seven tasks, using just 15.4% of the trainable parameters. On RoBERTa-Large, AdaMSS outperforms PiSSA by 7% in average accuracy across six tasks while reducing the number of trainable parameters by approximately 94.4%. These results demonstrate the effectiveness of AdaMSS in parameter-efficient fine-tuning. The code for AdaMSS is available at https: //github.com/jzheng20/AdaMSS.
+
+AdaMSS currently has the following constraints:
+- Only `nn.Linear` layers are supported.
+- Requires scikit-learn for the KMeans clustering step.
+
+If these constraints don't work for your use case, consider other methods instead.
+
+## Benchmark overview
+
+
+
+# API
+
+## AdamssConfig
+
+[[autodoc]] tuners.adamss.config.AdamssConfig
+
+## AdamssModel
+
+[[autodoc]] tuners.adamss.model.AdamssModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/adapter_utils.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/adapter_utils.md
new file mode 100644
index 0000000000000000000000000000000000000000..8f8b4e6c7f713dc9152864def4b9d94f6b5dd40f
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/adapter_utils.md
@@ -0,0 +1,31 @@
+
+
+# LyCORIS
+
+[LyCORIS](https://hf.co/papers/2309.14859) (Lora beYond Conventional methods, Other Rank adaptation Implementations for Stable diffusion) are LoRA-like matrix decomposition adapters that modify the cross-attention layer of the UNet. The [LoHa](loha) and [LoKr](lokr) methods inherit from the `Lycoris` classes here.
+
+## LycorisConfig
+
+[[autodoc]] tuners.lycoris_utils.LycorisConfig
+
+## LycorisLayer
+
+[[autodoc]] tuners.lycoris_utils.LycorisLayer
+
+## LycorisTuner
+
+[[autodoc]] tuners.lycoris_utils.LycorisTuner
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/auto_class.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/auto_class.md
new file mode 100644
index 0000000000000000000000000000000000000000..c1b78a2c34235844c73a6c5590bd53951c1b09d2
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/auto_class.md
@@ -0,0 +1,48 @@
+
+
+# AutoPeftModels
+
+The `AutoPeftModel` classes loads the appropriate PEFT model for the task type by automatically inferring it from the configuration file. They are designed to quickly and easily load a PEFT model in a single line of code without having to worry about which exact model class you need or manually loading a [`PeftConfig`].
+
+## AutoPeftModel
+
+[[autodoc]] auto.AutoPeftModel
+ - from_pretrained
+
+## AutoPeftModelForCausalLM
+
+[[autodoc]] auto.AutoPeftModelForCausalLM
+
+## AutoPeftModelForSeq2SeqLM
+
+[[autodoc]] auto.AutoPeftModelForSeq2SeqLM
+
+## AutoPeftModelForSequenceClassification
+
+[[autodoc]] auto.AutoPeftModelForSequenceClassification
+
+## AutoPeftModelForTokenClassification
+
+[[autodoc]] auto.AutoPeftModelForTokenClassification
+
+## AutoPeftModelForQuestionAnswering
+
+[[autodoc]] auto.AutoPeftModelForQuestionAnswering
+
+## AutoPeftModelForFeatureExtraction
+
+[[autodoc]] auto.AutoPeftModelForFeatureExtraction
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/beft.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/beft.md
new file mode 100644
index 0000000000000000000000000000000000000000..f7c5de4a398abb4c091409919e014d38561689c2
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/beft.md
@@ -0,0 +1,52 @@
+
+
+# BEFT: Bias-Efficient Fine-Tuning of Language Models in Low-Data Regimes
+
+[BEFT](https://arxiv.org/abs/2509.15974) is a parameter efficient fine-tuning algorithm (PEFT) that only fine-tunes the added bias terms of value projections from pretrained transformer models. BEFT demonstrates that fine-tuning the added bias terms of value projections from pretrained transformers generally leads to a higher downstream performance in low-data regimes than fine-tuning the added bias terms of query/key projections.
+
+BEFT currently has the following tradeoffs:
+
+Pros:
+- BEFT requires far fewer parameters than LoRA, while maintaining competitive or superior performance across tasks in low-data regimes.
+
+Cons:
+- In high-data regimes, BEFT may show limited effectiveness compared to LoRA and full-parameters fine-tuning.
+
+If your use case belongs to the high-data regime, consider other PEFT methods such as LoRA.
+
+The abstract from the paper is:
+
+*Fine-tuning the bias terms of large language models (LLMs) has the potential to achieve unprecedented parameter efficiency while maintaining competitive performance, particularly in low-data regimes. However, the link between fine-tuning different bias terms (i.e., **b**q, **b**k, and **b**v in the query, key, or value projections) and downstream performance remains largely unclear to date. In this paper, we investigate the link between fine-tuning **b**q, **b**k, and **b**v with the performance of the downstream task. Our key finding is that directly fine-tuning **b**v generally leads to higher downstream performance in low-data regimes, in comparison to **b**q and **b**k. We extensively evaluate this unique property across a wide range of LLMs spanning encoder-only and decoder-only architectures up to 6.7B parameters (including bias-free LLMs). Our results provide strong evidence for the effectiveness of directly fine-tuning **b**v across various downstream tasks*.
+
+## Benchmark overview
+
+
+
+# API
+
+## BeftConfig
+
+[[autodoc]] tuners.beft.config.BeftConfig
+
+## BeftModel
+
+[[autodoc]] tuners.beft.model.BeftModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/boft.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/boft.md
new file mode 100644
index 0000000000000000000000000000000000000000..5a31d0adf441674678a94830efac5b82faaf8cc8
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/boft.md
@@ -0,0 +1,92 @@
+
+
+# BOFT
+
+[Orthogonal Butterfly (BOFT)](https://hf.co/papers/2311.06243) is a generic method designed for finetuning foundation models. It improves the parameter efficiency of the finetuning paradigm -- Orthogonal Finetuning (OFT), by taking inspiration from Cooley-Tukey fast Fourier transform, showing favorable results across finetuning different foundation models, including large vision transformers, large language models and text-to-image diffusion models.
+
+The abstract from the paper is:
+
+*Large foundation models are becoming ubiquitous, but training them from scratch is prohibitively expensive. Thus, efficiently adapting these powerful models to downstream tasks is increasingly important. In this paper, we study a principled finetuning paradigm -- Orthogonal Finetuning (OFT) -- for downstream task adaptation. Despite demonstrating good generalizability, OFT still uses a fairly large number of trainable parameters due to the high dimensionality of orthogonal matrices. To address this, we start by examining OFT from an information transmission perspective, and then identify a few key desiderata that enable better parameter-efficiency. Inspired by how the Cooley-Tukey fast Fourier transform algorithm enables efficient information transmission, we propose an efficient orthogonal parameterization using butterfly structures. We apply this parameterization to OFT, creating a novel parameter-efficient finetuning method, called Orthogonal Butterfly (BOFT). By subsuming OFT as a special case, BOFT introduces a generalized orthogonal finetuning framework. Finally, we conduct an extensive empirical study of adapting large vision transformers, large language models, and text-to-image diffusion models to various downstream tasks in vision and language*.
+
+BOFT focuses on preserving a pretrained model's generative capabilities while being significantly more parameter-efficient than standard [OFT](./oft). Like OFT, BOFT maintains the same cosine similarity ([hyperspherical energy](https://huggingface.co/papers/1805.09298)) between all pairwise neurons in a layer by applying an orthogonal transformation to the pretrained weight matrix, ensuring the semantic relationships among neurons are preserved.
+
+Instead of using a block-diagonal orthogonal matrix, BOFT factorizes the orthogonal transformation into a product of **sparse butterfly matrices** (originally introduced in the [Cooley–Tukey FFT](https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm)). Unlike OFT's block-diagonal rotations, which only mix inputs within each block, the butterfly structure guarantees that every input can influence every output, producing a **dense connectivity** with just `O(d log d)` parameters. This factorization preserves expressivity while drastically reducing the parameter count compared to OFT (at the expense of computation time).
+
+In practice, BOFT multiplies each pretrained weight matrix by a sequence of butterfly-structured orthogonal factors, enabling efficient and expressive neuron rotations. This makes BOFT well-suited for controllable generation and tasks where maintaining the pretrained model's subject representation is critical, while also scaling to larger models with lower memory and compute overhead.
+
+BOFT can be applied to any subset of weight matrices in a neural network to reduce the number of trainable parameters. Given the target layers for injecting BOFT parameters, the number of trainable parameters can be determined based on the size of the weight matrices.
+
+## Benchmark overview
+
+
+
+## Merge BOFT weights into the base model
+
+Similar to LoRA, the weights learned by BOFT can be integrated into the pretrained weight matrices using the [`~BOFTModel.merge_and_unload()` function. This function merges the adapter weights with the base model which allows you to effectively use the newly merged model as a standalone model.
+
+
+
+
+
+This works because during training, the orthogonal weight matrix (R in the diagram above) and the pretrained weight matrices are separate. But once training is complete, these weights can actually be merged (multiplied) into a new weight matrix that is equivalent.
+
+## BOFT Example Usage
+
+For an example of the BOFT method application to various downstream tasks, please refer to the following guides:
+
+Take a look at the following step-by-step guides on how to finetune a model with BOFT:
+- [Dreambooth finetuning with BOFT](https://github.com/huggingface/peft/blob/main/examples/boft_dreambooth/boft_dreambooth.md)
+- [Controllable generation finetuning with BOFT (ControlNet)](https://github.com/huggingface/peft/blob/main/examples/boft_controlnet/boft_controlnet.md)
+
+For the task of image classification, one can initialize the BOFT config for a DinoV2 model as follows:
+
+```py
+import transformers
+from transformers import AutoModelForSeq2SeqLM, BOFTConfig
+from peft import BOFTConfig, get_peft_model
+
+config = BOFTConfig(
+ boft_block_size=4,
+ boft_n_butterfly_factor=2,
+ target_modules=["query", "value", "key", "output.dense", "mlp.fc1", "mlp.fc2"],
+ boft_dropout=0.1,
+ bias="boft_only",
+ modules_to_save=["classifier"],
+)
+
+model = transformers.Dinov2ForImageClassification.from_pretrained(
+ "facebook/dinov2-large",
+ num_labels=100,
+)
+
+boft_model = get_peft_model(model, config)
+```
+
+# API
+
+## BOFTConfig
+
+[[autodoc]] tuners.boft.config.BOFTConfig
+
+## BOFTModel
+
+[[autodoc]] tuners.boft.model.BOFTModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/c3a.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/c3a.md
new file mode 100644
index 0000000000000000000000000000000000000000..099673b37a47faeb5fdbb7bf5fa2edc8f649436b
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/c3a.md
@@ -0,0 +1,55 @@
+
+
+# C3A: Parameter-Efficient Fine-Tuning via Circular Convolution
+
+[C3A](https://huggingface.co/papers/2407.19342) is a parameter-efficient fine-tuning technique that leverages Circular Convolution to achieve high rank adaptation within reasonable resource limits.
+
+Note that you should use a much larger learning rate (LR) for C3A than for other methods. For example, a LR of 1e-1 for C3A is a good starting point. Besides, a much smaller weight decay should be used. You can refer to the `method_comparison` folder for more details.
+
+For the `block_size`, it affects tunable parameters and performance. To start with, you can choose a $\mathrm{gcd}(d_1,d_2)$ near $\frac{\sqrt{d_1 \times d_2}}{r}$, where $r$ is the rank for LoRA you would use for this task.
+
+C3A currently has the following constraints:
+
+- Only `nn.Linear` layers are supported.
+- Quantized layers are not supported.
+- The block size should be a common divisor of both the input and output sizes of target layers.
+
+If these constraints don't work for your use case, consider other methods instead.
+
+The abstract from the paper is:
+
+> Low-Rank Adaptation (LoRA) has gained popularity for fine-tuning large foundation models, leveraging low-rank matrices $\mathbf{A}$ and $\mathbf{B}$ to represent weight changes (i.e., $\Delta \mathbf{W} = \mathbf{B} \mathbf{A}$). This method reduces trainable parameters and mitigates heavy memory consumption associated with full delta matrices by sequentially multiplying $\mathbf{A}$ and $\mathbf{B}$ with the activation. Despite its success, the intrinsic low-rank characteristic may limit its performance. Although several variants have been proposed to address this issue, they often overlook the crucial computational and memory efficiency brought by LoRA. In this paper, we propose Circular Convolution Adaptation (C3A), which not only achieves high-rank adaptation with enhanced performance but also excels in both computational power and memory utilization. Extensive experiments demonstrate that C3A consistently outperforms LoRA and its variants across various fine-tuning tasks.
+
+## Benchmark overview
+
+
+
+
+# API
+
+## C3AConfig
+
+[[autodoc]] tuners.c3a.config.C3AConfig
+
+## C3AModel
+
+[[autodoc]] tuners.c3a.model.C3AModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/cartridges.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/cartridges.md
new file mode 100644
index 0000000000000000000000000000000000000000..ac605a8ea93afce81491064ea9f3a60b03a8b3b3
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/cartridges.md
@@ -0,0 +1,93 @@
+
+
+# Cartridges
+
+Cartridges are a prompt-learning method that stores a compressed long-context representation as a parameterized KV-cache
+prefix. The core idea comes from the paper
+[Cartridges: Lightweight and general-purpose long context representations via self-study](https://huggingface.co/papers/2506.06266).
+
+For a high-level overview and motivation, see the blog post
+[Cartridges: Storing long contexts in tiny caches with self-study](https://hazyresearch.stanford.edu/blog/2025-06-08-cartridges).
+
+## How Cartridges differ from Prefix Tuning
+
+Both Prefix Tuning and Cartridges are served by injecting `past_key_values` (a prefix KV cache) into the base model.
+
+- Prefix Tuning learns virtual token embeddings (and optionally an MLP projection) and produces a KV prefix.
+- Cartridges learn the KV prefix itself directly (the per-layer key/value vectors for `p` virtual tokens), and are
+ designed to be initialized from real prefill KV (for example, the first `p` tokens of a corpus/system prompt).
+
+The paper also recommends freezing the first token as an attention sink for stability (`num_frozen_tokens=1` is the
+default).
+
+## Usage (inference)
+
+Load a trained CARTRIDGE adapter and run generation:
+
+```py
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from peft import PeftModel
+
+model_id = "Qwen/Qwen2.5-0.5B-Instruct"
+adapter_path = "path/to/cartridge_adapter"
+
+base = AutoModelForCausalLM.from_pretrained(model_id)
+model = PeftModel.from_pretrained(base, adapter_path)
+
+tok = AutoTokenizer.from_pretrained(model_id)
+if tok.pad_token is None:
+ tok.pad_token = tok.eos_token
+
+out = model.generate(**tok("Question about the corpus:", return_tensors="pt"), max_new_tokens=64)
+print(tok.decode(out[0], skip_special_tokens=True))
+```
+
+If you need to create and initialize a cartridge before training, see the initialization options below.
+
+## Initialization options
+
+The paper discusses a few practical initialization strategies:
+
+- Random KV (default): create a `CartridgeConfig` and start training. This initializes the KV prefix randomly.
+- KV from the first tokens of a prompt/corpus: use `initialize_kv_prefix_from_text(model, tokenizer, text=...)`. This
+ runs a prefill on `text` and copies the resulting KV cache for the first `num_virtual_tokens` into the adapter.
+- KV from an existing cache: use `initialize_kv_prefix_from_past_key_values(model, past_key_values=...)` if you already
+ have a `past_key_values` object from a base-model prefill.
+
+## Training
+
+The Cartridges paper proposes a SELF-STUDY distillation objective (a frozen base model provides teacher logits; the
+CARTRIDGE adapter is trained so the student matches the teacher’s next-token distribution over the target segment).
+PEFT keeps training logic out of the core library; see
+`https://github.com/huggingface/peft/tree/main/examples/cartridge_self_study` for a reference workflow.
+The example scripts use the frozen base model as the teacher and the adapted model as the student, so both share the
+same underlying checkpoint.
+
+## Composition
+
+To concatenate independently trained cartridges into a single adapter, use `compose_cartridge_adapters(...)`.
+
+# API
+
+## CartridgeConfig
+
+[[autodoc]] tuners.cartridge.config.CartridgeConfig
+
+## CartridgeEncoder
+
+[[autodoc]] tuners.cartridge.model.CartridgeEncoder
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/config.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/config.md
new file mode 100644
index 0000000000000000000000000000000000000000..9a4f755e1cd1af7c7871df11cd89100944e355cb
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/config.md
@@ -0,0 +1,22 @@
+
+
+# Configuration
+
+[`PeftConfigMixin`] is the base configuration class for storing the adapter configuration of a [`PeftModel`], and [`PromptLearningConfig`] is the base configuration class for soft prompt methods (p-tuning, prefix tuning, and prompt tuning). These base classes contain methods for saving and loading model configurations from the Hub, specifying the PEFT method to use, type of task to perform, and model configurations like number of layers and number of attention heads.
+
+## PeftConfigMixin
+
+[[autodoc]] config.PeftConfigMixin
+ - all
+
+## PeftConfig
+
+[[autodoc]] PeftConfig
+ - all
+
+## PromptLearningConfig
+
+[[autodoc]] PromptLearningConfig
+ - all
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/cpt.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/cpt.md
new file mode 100644
index 0000000000000000000000000000000000000000..b60915e6e4739318e65e7513a9d4f310f2adef8c
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/cpt.md
@@ -0,0 +1,48 @@
+
+
+# Context-aware Prompt Tuning: Advancing In-Context Learning with Adversarial Methods
+
+
+
+
+
+CPT optimizing only specific token embeddings while keeping the rest of the model frozen (image source).
+
+[Context-Aware Prompt Tuning (CPT)](https://huggingface.co/papers/2410.17222) is designed to enhance few-shot classification by refining only context embeddings.
+This approach combines ideas from In-Context Learning (ICL), [Prompt Tuning](../package_reference/prompt_tuning) (PT), and adversarial optimization, focusing on making model adaptation both parameter-efficient and effective.
+In CPT, only specific context token embeddings are optimized, while the rest of the model remains frozen.
+To prevent overfitting and maintain stability, CPT uses controlled perturbations to limit the allowed changes to context embeddings within a defined range.
+Additionally, to address the phenomenon of recency bias—where examples near the end of the context tend to be prioritized over earlier ones—CPT applies a decay loss factor.
+
+The abstract from the paper is:
+
+> Large Language Models (LLMs) can perform few-shot learning using either optimization-based approaches or In-Context Learning (ICL). Optimization-based methods often suffer from overfitting, as they require updating a large number of parameters with limited data. In contrast, ICL avoids overfitting but typically underperforms compared to optimization-based methods and is highly sensitive to the selection, order, and format of demonstration examples. To overcome these challenges, we introduce Context-aware Prompt Tuning (CPT), a method inspired by ICL, Prompt Tuning (PT), and adversarial attacks. CPT builds on the ICL strategy of concatenating examples before the input, extending it by incorporating PT-like learning to refine the context embedding through iterative optimization, extracting deeper insights from the training examples. Our approach carefully modifies specific context tokens, considering the unique structure of the examples within the context. In addition to updating the context with PT-like optimization, CPT draws inspiration from adversarial attacks, adjusting the input based on the labels present in the context while preserving the inherent value of the user-provided data. To ensure robustness and stability during optimization, we employ a projected gradient descent algorithm, constraining token embeddings to remain close to their original values and safeguarding the quality of the context. Our method has demonstrated superior accuracy across multiple classification tasks using various LLM models, outperforming existing baselines and effectively addressing the overfitting challenge in few-shot learning.
+
+Take a look at [Example](https://github.com/huggingface/peft/blob/main/examples/cpt_finetuning/README.md) for a step-by-step guide on how to train a model with CPT.
+
+## Benchmark overview
+
+There is no benchmark for this method yet. Feel free to contribute an experiment
+configuration but make sure to first create an issue
+[here](https://github.com/huggingface/peft/issues).
+
+# API
+
+## CPTConfig
+
+[[autodoc]] tuners.cpt.config.CPTConfig
+
+## CPTEmbedding
+
+[[autodoc]] tuners.cpt.model.CPTEmbedding
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/delora.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/delora.md
new file mode 100644
index 0000000000000000000000000000000000000000..fe1c91691bb4576104e455767f988238791db06e
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/delora.md
@@ -0,0 +1,51 @@
+
+
+# DeLoRA: Decoupled Low-rank Adaptation
+[DeLoRA](https://huggingface.co/papers/2503.18225) is a parameter-efficient fine-tuning technique that implicitly maintains a Frobenius boundary with respect to the pretrained weights by normalizing and scaling learnable low-rank matrices. This effectively decouples the learning of directions (BA term) and magnitude (boundary term) of the weight updates, avoiding catastrophic shifts in the adapted weights and enhancing robustness to hyperparameter choices.
+
+Note:
+- use a learning rate 10-100x larger than for standard LoRA variants (typical values from 1e-3/1e-2/..)
+- ensure the initial boundary parameter lambda is not too small (typical values around 10/15/..). Setting different lambdas to different layers is possible
+
+DeLoRA currently has the following constraints:
+- Only nn.Linear layers are supported.
+- Quantized layers are not supported.
+
+If these constraints don't work for your use case, consider other methods instead.
+
+The abstract from the paper is:
+
+> Parameter-Efficient FineTuning (PEFT) methods have recently gained significant popularity thanks to the widespread availability of large-scale pretrained models. These methods allow for quick adaptation to downstream tasks with minimal computational cost. However, popular finetuning methods such as LoRA exhibit limited robustness when it comes to hyperparameter choices or extended training regimes, preventing optimal out-of-the-box performance. In contrast, bounded approaches, such as ETHER, provide greater robustness but are limited to extremely low-rank adaptations and fixed-strength transformations, reducing their adaptation expressive power. In this work, we propose Decoupled Low-rank Adaptation (DeLoRA), a novel finetuning method that normalizes and scales learnable low-rank matrices. By bounding the distance of the transformation, DeLoRA effectively decouples the angular learning from the adaptation strength, enhancing robustness without compromising performance. Through evaluations on subject-driven image generation, natural language understanding, and instruction tuning, we show that DeLoRA matches or surpasses performance of competing PEFT methods, while exhibiting stronger robustness.
+
+## Benchmark overview
+
+
+
+# API
+
+## DeloraConfig
+
+[[autodoc]] tuners.delora.config.DeloraConfig
+
+## DeloraModel
+
+[[autodoc]] tuners.delora.model.DeloraModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/fourierft.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/fourierft.md
new file mode 100644
index 0000000000000000000000000000000000000000..42c3faccc99d93c11b4fe8c3409b8bc14372f071
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/fourierft.md
@@ -0,0 +1,49 @@
+
+
+# FourierFT: Discrete Fourier Transformation Fine-Tuning
+
+[FourierFT](https://huggingface.co/papers/2405.03003) is a parameter-efficient fine-tuning technique that leverages Discrete Fourier Transform to compress the model's tunable weights. This method outperforms LoRA in the GLUE benchmark and common ViT classification tasks using much less parameters.
+
+FourierFT currently has the following constraints:
+
+- Only `nn.Linear` layers are supported.
+- Quantized layers are not supported.
+
+If these constraints don't work for your use case, consider other methods instead.
+
+The abstract from the paper is:
+
+> Low-rank adaptation (LoRA) has recently gained much interest in fine-tuning foundation models. It effectively reduces the number of trainable parameters by incorporating low-rank matrices A and B to represent the weight change, i.e., Delta W=BA. Despite LoRA's progress, it faces storage challenges when handling extensive customization adaptations or larger base models. In this work, we aim to further compress trainable parameters by enjoying the powerful expressiveness of the Fourier transform. Specifically, we introduce FourierFT, which treats Delta W as a matrix in the spatial domain and learns only a small fraction of its spectral coefficients. With the trained spectral coefficients, we implement the inverse discrete Fourier transform to recover Delta W. Empirically, our FourierFT method shows comparable or better performance with fewer parameters than LoRA on various tasks, including natural language understanding, natural language generation, instruction tuning, and image classification. For example, when performing instruction tuning on the LLaMA2-7B model, FourierFT surpasses LoRA with only 0.064M trainable parameters, compared to LoRA's 33.5M.
+
+## Benchmark overview
+
+
+
+# API
+
+## FourierFTConfig
+
+[[autodoc]] tuners.fourierft.config.FourierFTConfig
+
+## FourierFTModel
+
+[[autodoc]] tuners.fourierft.model.FourierFTModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/frod.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/frod.md
new file mode 100644
index 0000000000000000000000000000000000000000..1062893e27ed0fce78a550698449157fbc92dabf
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/frod.md
@@ -0,0 +1,75 @@
+
+
+# FRoD: Full-Rank Efficient Fine-Tuning with Rotational Degrees
+
+FRoD is a parameter-efficient fine-tuning method that combines a shared full-rank basis with sparse learnable
+rotational degrees. The adapter update is expressed through fixed projection tensors and trainable coefficients, which
+allows FRoD to apply full-rank updates while keeping the number of trained parameters small.
+
+Paper: [Full-Rank Efficient Fine-Tuning with Rotational Degrees](https://doi.org/10.1609/aaai.v40i31.39813).
+
+When saving the adapter parameters, it is possible to avoid storing the projection tensors by setting
+`save_projection=False` on the `FrodConfig`. In that case, the projections are restored from the base model weights and
+the fixed random seed from `projection_prng_key`. This reduces checkpoint size, but the default is
+`save_projection=True` to make checkpoint loading independent of regeneration details.
+
+Compared to LoRA, FRoD can express a full-rank update in each adapted linear layer while training only the diagonal
+coefficients and a sparse set of off-diagonal rotation coefficients. This can be useful when a low-rank update is too
+restrictive. The trade-off is that FRoD computes fixed projection tensors from the base weights during adapter
+injection, which makes setup more expensive and the implementation less broadly supported than LoRA.
+
+Projection initialization can be slow on large models because FRoD runs matrix decompositions over the target module
+categories before injecting the adapters. A progress bar is shown by default and can be disabled with
+`FrodConfig(progressbar=False)`.
+
+For memory-constrained training, `runtime_offload_base_weight=True` keeps target base weights on CPU when the active
+FRoD path does not need them. This is opt-in because PEFT methods usually keep all base parameters on the accelerator
+after moving the model and after forward passes.
+
+FRoD currently has the following constraint:
+
+- Only `nn.Linear` and `transformers.pytorch_utils.Conv1D` layers are supported.
+
+## Quickstart
+
+```python
+from transformers import AutoModelForSequenceClassification
+
+from peft import FrodConfig, TaskType, get_peft_model
+
+model = AutoModelForSequenceClassification.from_pretrained("google-bert/bert-base-uncased", num_labels=2)
+
+peft_config = FrodConfig(
+ task_type=TaskType.SEQ_CLS,
+ target_modules=["query", "value"],
+ modules_to_save=["classifier"],
+ sparse_rate=0.02,
+ frod_dropout=0.0,
+ runtime_offload_base_weight=True,
+)
+
+model = get_peft_model(model, peft_config)
+model.print_trainable_parameters()
+```
+
+## FrodConfig
+
+[[autodoc]] tuners.frod.config.FrodConfig
+
+## FrodModel
+
+[[autodoc]] tuners.frod.model.FrodModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/functional.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/functional.md
new file mode 100644
index 0000000000000000000000000000000000000000..52251bd4905a3412ef12ad499c106ef9e75ec117
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/functional.md
@@ -0,0 +1,37 @@
+
+
+# Functions for PEFT integration
+
+A collection of functions that could be useful for non-PeftModel models, e.g. transformers or diffusers integration
+
+The functions provided here can be considered "public API" of PEFT and hence are safe to be used by packages that provide PEFT integrations.
+
+## Cast the adapter weight dtypes
+[[autodoc]] functional.cast_adapter_dtype
+ - all
+
+## Delete the PEFT adapter from model
+[[autodoc]] functional.delete_adapter
+ - all
+
+## Get the state dict of the PEFT adapter
+[[autodoc]] functional.get_peft_model_state_dict
+ - all
+
+## Inject a PEFT adapter into the model based on a PEFT config
+[[autodoc]] functional.inject_adapter_in_model
+ - all
+
+## Set the active PEFT adapter(s) of the model
+[[autodoc]] functional.set_adapter
+ - all
+
+## Set the `requires_grad` attribute of the specified adapters
+[[autodoc]] functional.set_requires_grad
+ - all
+
+## Load the weights of the PEFT state dict into the model
+[[autodoc]] functional.set_peft_model_state_dict
+ - all
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/gralora.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/gralora.md
new file mode 100644
index 0000000000000000000000000000000000000000..84e75f3e50daf0e13ee7faaa83de9d269c2a5cfd
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/gralora.md
@@ -0,0 +1,50 @@
+# GraLoRA
+
+[**Granular Low-Rank Adaptation (GraLoRA)**](https://huggingface.co/papers/2505.20355) is a PEFT method designed to enhance the **expressivity** of low-rank adaptation while improving **robustness to outlier** activations, based on insights from well-known issues in quantization.
+
+
+
+Unlike standard LoRA, which applies a single low-rank adapter across the entire feature space, GraLoRA introduces a structured and fine-grained adaptation scheme. It divides the adaptation space into a grid of $𝑘^2$ smaller, independent adapter pairs, each responsible for a localized subset of the input and output dimensions. As a result, each adapter operates on a subspace that is $k$ times smaller in both dimensions than the original LoRA adapter.
+
+This granular decomposition enables spatially localized and context-aware updates, effectively increasing representational capacity without additional parameters or computational cost. By isolating the influence of extreme activations within smaller subspaces, GraLoRA mitigates gradient distortion and preserves inter-channel balance during adaptation.
+
+---
+
+The abstract from the paper is:
+
+*Low-Rank Adaptation (LoRA) is a popular method for parameter-efficient fine-
+tuning (PEFT) of generative models, valued for its simplicity and effectiveness.
+Despite recent enhancements, LoRA still suffers from a fundamental limitation:
+overfitting when the bottleneck is widened. It performs best at ranks 32–64, yet its
+accuracy stagnates or declines at higher ranks, still falling short of full fine-tuning
+(FFT) performance. We identify the root cause as LoRA’s structural bottleneck,
+which introduces gradient entanglement to the unrelated input channels and distorts
+gradient propagation. To address this, we introduce a novel structure, Granular
+Low-Rank Adaptation (GraLoRA) that partitions weight matrices into sub-blocks,
+each with its own low-rank adapter. With negligible computational or storage cost,
+GraLoRA overcomes LoRA’s limitations, effectively increases the representational
+capacity, and more closely approximates FFT behavior. Experiments on code
+generation, commonsense reasoning, mathematical reasoning, general language
+understanding, and image generation benchmarks show that GraLoRA consistently
+outperforms LoRA and other baselines, achieving up to +8.5% absolute gain in
+Pass@1 on HumanEval+. These improvements hold across model sizes and rank
+settings, making GraLoRA a scalable and robust solution for PEFT.*
+
+## Benchmark overview
+
+
+
+# API
+
+## GraloraConfig
+
+[[autodoc]] tuners.gralora.config.GraloraConfig
+
+## GraloraModel
+
+[[autodoc]] tuners.gralora.model.GraloraModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/helpers.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/helpers.md
new file mode 100644
index 0000000000000000000000000000000000000000..85b3117e50eabc453019125a863e002d97974f5a
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/helpers.md
@@ -0,0 +1,41 @@
+
+
+# Helper methods
+
+A collection of helper functions for PEFT.
+
+## Checking if a model is a PEFT model
+
+[[autodoc]] helpers.check_if_peft_model
+ - all
+
+## Temporarily Rescaling Adapter Scale in LoraLayer Modules
+
+[[autodoc]] helpers.rescale_adapter_scale
+ - all
+
+## Context manager to disable input dtype casting in the `forward` method of LoRA layers
+
+[[autodoc]] helpers.disable_input_dtype_casting
+ - all
+
+## Context manager to enable DoRA caching (faster at inference time but requires more memory)
+
+[[autodoc]] helpers.DoraCaching
+ - all
+
+## KappaTune target selection
+
+`KappaTuneSelector` and `find_kappa_target_modules` implement a general target selection process from the [KappaTune paper](https://arxiv.org/abs/2506.16289).
+
+The method identifies modules with higher flexibility (higher output differential entropy) and lower specialization (lower sensitivity to specific input directions).
+
+These properties make the selected modules good candidates for mitigating catastrophic forgetting in any adaptation method that adds trainable parameters, including LoRA, DoRA, LoHa, AdaLoRA, and even direct fine-tuning of the original weights.
+
+[[autodoc]] helpers.KappaTuneSelector
+ - all
+
+[[autodoc]] helpers.find_kappa_target_modules
+ - all
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/hira.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/hira.md
new file mode 100644
index 0000000000000000000000000000000000000000..96082a7872aa4cb79604df797b4fb7663a10a293
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/hira.md
@@ -0,0 +1,89 @@
+# HiRA
+
+High-Rank Adaptation ([HiRA](https://openreview.net/pdf?id=TwJrTz9cRS)) is a PEFT method that extends the LoRA approach by applying an element-wise modulation on the original weight matrix. Instead of adding a low-rank update directly, HiRA computes:
+
+$$
+W' = W_0 + W_0 \odot (B A)
+$$
+
+where $W_0$ is the base weight, and $A, B$ are low-rank factors with rank $r \ll \min( \text{in_features}, \text{out_features})$. This formulation allows HiRA to adapt existing weights with a multiplicative, input-dependent modulation, often improving fine-tuning efficiency on downstream tasks.
+
+The abstract from the HiRA paper is:
+
+> *We propose Hadamard High-Rank Adaptation (HiRA), a parameter-efficient fine-tuning (PEFT) method that enhances the adaptability of Large Language Models (LLMs). While Low-rank Adaptation (LoRA) is widely used to reduce resource demands, its low-rank updates may limit its expressiveness for new tasks. HiRA addresses this by using a Hadamard product to retain high-rank update parameters, improving the model capacity. Empirically, HiRA outperforms LoRA and its variants on several tasks, with extensive ablation studies validating its effectiveness.*
+
+
+## Examples
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import get_peft_model
+from peft.tuners.hira import HiraConfig
+
+# Example 1: HiRA on opt-125m for causal language modeling
+model_id = "facebook/opt-125m"
+base_model = AutoModelForCausalLM.from_pretrained(model_id)
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+# Define HiRA configuration: apply to the MLP dense layers in each transformer block
+hira_config = HiraConfig(
+ r=32,
+ target_modules=["k_proj", "q_proj", "v_proj", "fc1", "fc2"],
+ hira_dropout=0.0,
+ init_weights=True,
+)
+peft_model = get_peft_model(base_model, hira_config)
+
+peft_model.print_trainable_parameters()
+# trainable params: 4,718,592 || all params: 129,957,888 || trainable%: 3.6309
+```
+
+## Benchmark overview
+
+
+
+## Citation:
+
+If you found HiRA is useful, please cite HiRA as:
+```
+@inproceedings{
+huang2025hira,
+title={Hi{RA}: Parameter-Efficient Hadamard High-Rank Adaptation for Large Language Models},
+author={Qiushi Huang and Tom Ko and Zhan Zhuang and Lilian Tang and Yu Zhang},
+booktitle={The Thirteenth International Conference on Learning Representations},
+year={2025},
+url={https://openreview.net/forum?id=TwJrTz9cRS}
+}
+```
+
+# API
+
+## HiraConfig
+
+[[autodoc]] tuners.hira.config.HiraConfig
+
+## Core Layers
+
+### HiraLayer
+
+[[autodoc]] tuners.hira.layer.HiraLayer
+
+### Linear Adapter
+
+[[autodoc]] tuners.hira.layer.Linear
+
+### Embedding Adapter
+
+[[autodoc]] tuners.hira.layer.Embedding
+
+### Convolutional Adapters
+
+[[autodoc]] tuners.hira.layer.Conv1d [[autodoc]] tuners.hira.layer.Conv2d [[autodoc]] tuners.hira.layer.ConvNd
+
+
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/hotswap.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/hotswap.md
new file mode 100644
index 0000000000000000000000000000000000000000..4cd7c41efc95595533909a8307311f91e9ac5312
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/hotswap.md
@@ -0,0 +1,80 @@
+
+
+# Hotswapping adapters
+
+The idea of hotswapping an adapter is the following: We can already load multiple adapters, e.g. two LoRAs, at the same time. But sometimes, we want to load one LoRA and then replace its weights in-place with the LoRA weights of another adapter. This is now possible the `hotswap_adapter` function.
+
+In general, this should be faster than deleting one adapter and loading the adapter in its place, which would be the how to achieve the same final outcome without hotswapping. Another advantage of hotswapping is that it prevents re-compilation in case the PEFT model is already compiled using `torch.compile`. This can save quite a lot of time.
+
+## Example without `torch.compile`
+
+```python
+import torch
+from transformers import AutoModelForCausalLM
+from peft import PeftModel
+from peft.utils.hotswap import hotswap_adapter
+
+model_id = ...
+inputs = ...
+device = ...
+model = AutoModelForCausalLM.from_pretrained(model_id).to(device)
+
+# load lora 0
+model = PeftModel.from_pretrained(model, )
+with torch.inference_mode():
+ output_adapter_0 = model(inputs)
+
+# replace the "default" lora adapter with the new one
+hotswap_adapter(model, , adapter_name="default", torch_device=device)
+with torch.inference_mode():
+ output_adapter_1 = model(inputs).logits
+```
+
+## Example with `torch.compile`
+
+```python
+import torch
+from transformers import AutoModelForCausalLM
+from peft import PeftModel
+from peft.utils.hotswap import hotswap_adapter, prepare_model_for_compiled_hotswap
+
+model_id = ...
+inputs = ...
+device = ...
+max_rank = ... # maximum rank among all LoRA adapters that will be used
+model = AutoModelForCausalLM.from_pretrained(model_id).to(device)
+
+# load lora 0
+model = PeftModel.from_pretrained(model, )
+# Prepare the model to allow hotswapping even if ranks/scalings of 2nd adapter differ.
+# You can skip this step if all ranks and scalings are identical.
+prepare_model_for_compiled_hotswap(model, target_rank=max_rank)
+model = torch.compile(model)
+with torch.inference_mode():
+ output_adapter_0 = model(inputs)
+
+# replace the "default" lora adapter with the new one
+hotswap_adapter(model, , adapter_name="default", torch_device=device)
+with torch.inference_mode():
+ output_adapter_1 = model(inputs).logits
+```
+
+Note that if you want to hotswap weights that were added through `target_parameters`, i.e. that directly target an `nn.Parameter`, re-compilation and/or graph breaks cannot be prevented. Therefore, it is recommended to avoid using `target_parameters` together with compiled models and hotswapping.
+
+## Caveats
+
+Hotswapping works with transformers models and diffusers models. However, there are some caveats:
+
+- Right now, only LoRA is properly supported.
+- It only works for the same PEFT method, so no swapping LoRA and LoHa, for example.
+- The adapter that is being swapped in must target the same layers as the previous adapter or a subset of those layers. It cannot target new layers. Therefore, if possible, start with the adapter that targets most layers.
+
+## API
+
+[[autodoc]] utils.hotswap.hotswap_adapter
+ - all
+
+[[autodoc]] utils.hotswap.hotswap_adapter_from_state_dict
+ - all
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/hra.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/hra.md
new file mode 100644
index 0000000000000000000000000000000000000000..59a35362bd663adb2f3677f1c27b144ed92d11aa
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/hra.md
@@ -0,0 +1,40 @@
+
+
+# Bridging The Gap between Low-rank and Orthogonal Adaptation via Householder Reflection Adaptation (HRA)
+
+
+
+
+Bridging The Gap between Low-rank and Orthogonal Adaptation via Householder Reflection Adaptation
+
+[HRA](https://huggingface.co/papers/2405.17484) provides a new perspective connecting LoRA to OFT, which means it can harness the advantages of both strategies, by leveraging [Householder reflections](https://en.wikipedia.org/wiki/Householder_transformation) to reduce parameters and computation costs while penalizing the loss of pre-training knowledge. It consistently achieves better performance with fewer trainable parameters and outperforms state-of-the-art adapters across different models, including large language models (LLMs) and conditional image generators.
+
+HRA constructs a chain of `r` trainable Householder reflections (HRs). Because the Householder reflection matrix is an orthogonal matrix and the product of orthogonal matrices is also an orthogonal matrix, HRA satisfies the theoretical guarantee of Orthogonal Finetuning (OFT). Meanwhile, HRA can also be viewed as a low-rank fine-tuning adapter. The higher `r`, the more trainable parameters, resulting in a larger model capacity and better performance. Besides, due to the chain structure, the orthogonality of HR planes impacts the capacity and regularity of HRA. To achieve a trade-off between the model capacity and regularity, an orthogonality regularizer of the HR planes is added to the loss function. The weight \\(\lambda\\) can control the strength of the regularizer.
+
+The abstract from the paper is:
+
+> While following different technical routes, both low-rank and orthogonal adaptation techniques can efficiently adapt large-scale pre-training models in specific tasks or domains based on a small piece of trainable parameters. In this study, we bridge the gap between these two techniques, proposing a simple but effective adaptation method based on Householder reflections. Given a pre-trained model, our method fine-tunes its layers by multiplying each frozen weight matrix with an orthogonal matrix constructed by a chain of learnable Householder reflections (HRs). This HR-based orthogonal fine-tuning is equivalent to an adaptive low-rank adaptation. Moreover, we show that the orthogonality of the reflection planes corresponding to the HRs impacts the model capacity and regularity. The analysis motivates us to regularize the orthogonality of the HRs, leading to different implementations of the proposed Householder reflection adaptation (HRA) method. Compared with state-of-the-art methods, HRA achieves superior performance with fewer learnable parameters when adapting large language models and conditional image generators. The code is available at [peft](https://github.com/huggingface/peft/tree/main/src/peft/tuners/hra) and [HRA](https://github.com/DaShenZi721/HRA).
+
+# API
+
+## HRAConfig
+
+[[autodoc]] tuners.hra.config.HRAConfig
+
+## HRAModel
+
+[[autodoc]] tuners.hra.model.HRAModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/ia3.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/ia3.md
new file mode 100644
index 0000000000000000000000000000000000000000..76c6cda2e03928ef1c1c552213839bce12c30e54
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/ia3.md
@@ -0,0 +1,79 @@
+
+
+# IA3
+
+
+
+
+IA3 introduces three vectors, lv, lk and lff to scale value, key and feed-forward activations (image source).
+
+Infused Adapter by Inhibiting and Amplifying Inner Activations, or [IA3](https://hf.co/papers/2205.05638), is a method that adds three learned vectors to rescale the keys and values of the self-attention and encoder-decoder attention layers, and the intermediate activation of the position-wise feed-forward network.
+
+The abstract from the paper is:
+
+*Few-shot in-context learning (ICL) enables pre-trained language models to perform a previously-unseen task without any gradient-based training by feeding a small number of training examples as part of the input. ICL incurs substantial computational, memory, and storage costs because it involves processing all of the training examples every time a prediction is made. Parameter-efficient fine-tuning (PEFT) (e.g. adapter modules, prompt tuning, sparse update methods, etc.) offers an alternative paradigm where a small set of parameters are trained to enable a model to perform the new task. In this paper, we rigorously compare few-shot ICL and PEFT and demonstrate that the latter offers better accuracy as well as dramatically lower computational costs. Along the way, we introduce a new PEFT method called (IA)^3 that scales activations by learned vectors, attaining stronger performance while only introducing a relatively tiny amount of new parameters. We also propose a simple recipe based on the T0 model called T-Few that can be applied to new tasks without task-specific tuning or modifications. We validate the effectiveness of T-Few on completely unseen tasks by applying it to the RAFT benchmark, attaining super-human performance for the first time and outperforming the state-of-the-art by 6% absolute. All of the code used in our experiments is publicly available*.
+
+To make fine-tuning more efficient, IA3 (Infused Adapter by Inhibiting and Amplifying Inner Activations)
+rescales inner activations with learned vectors. These learned vectors are injected in the attention and feedforward modules
+in a typical transformer-based architecture. These learned vectors are the only trainable parameters during fine-tuning, and thus the original
+weights remain frozen. Dealing with learned vectors (as opposed to learned low-rank updates to a weight matrix like LoRA)
+keeps the number of trainable parameters much smaller.
+
+Being similar to [LoRA](./lora), IA3 carries many of the same advantages:
+
+* IA3 makes fine-tuning more efficient by drastically reducing the number of trainable parameters. (For T0, an IA3 model only has about 0.01% trainable parameters, while even LoRA has > 0.1%)
+* The original pre-trained weights are kept frozen, which means you can have multiple lightweight and portable IA3 models for various downstream tasks built on top of them.
+* Performance of models fine-tuned using IA3 is comparable to the performance of fully fine-tuned models.
+* IA3 does not add any inference latency because adapter weights can be merged with the base model.
+
+In principle, IA3 can be applied to any subset of weight matrices in a neural network to reduce the number of trainable
+parameters. Following the authors' implementation, IA3 weights are added to the key, value and feedforward layers
+of a Transformer model. To be specific, for transformer models, IA3 weights are added to the outputs of key and value layers, and to the input of the second feedforward layer
+in each transformer block.
+
+Given the target layers for injecting IA3 parameters, the number of trainable parameters
+can be determined based on the size of the weight matrices.
+
+## Usage
+
+For the task of sequence classification, one can initialize the IA3 config for a Llama model as follows:
+
+```py
+peft_config = IA3Config(
+ task_type=TaskType.SEQ_CLS, target_modules=["k_proj", "v_proj", "down_proj"], feedforward_modules=["down_proj"]
+)
+```
+
+## Benchmark overview
+
+
+
+
+# API
+
+## IA3Config
+
+[[autodoc]] tuners.ia3.config.IA3Config
+
+## IA3Model
+
+[[autodoc]] tuners.ia3.model.IA3Model
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/layernorm_tuning.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/layernorm_tuning.md
new file mode 100644
index 0000000000000000000000000000000000000000..f0544df022ac440bb14de3aa8e3d71b4a7724779
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/layernorm_tuning.md
@@ -0,0 +1,45 @@
+
+
+# LayerNorm Tuning
+
+LayerNorm Tuning ([LN Tuning](https://huggingface.co/papers/2312.11420)) is a PEFT method that only fine-tunes the parameters of the LayerNorm layers in a model.
+The paper has tested the performance of this method on large language models and has shown that it can achieve strong performance with a significant reduction in the number of trainable parameters and GPU memory usage.
+However, the method is not limited to language models and can be applied to any model that uses LayerNorm layers.
+In this implementation, the default is that all layernorm layers inside a model is finetuned, but it could be used to target other layer types such as `MLP` or `Attention` layers, this can be done by specifying the `target_modules` in the `LNTuningConfig`.
+
+The abstract from the paper is:
+
+*This paper introduces an efficient strategy to transform Large Language Models (LLMs) into Multi-Modal Large Language Models (MLLMs). By conceptualizing this transformation as a domain adaptation process, i.e., transitioning from text understanding to embracing multiple modalities, we intriguingly note that, within each attention block, tuning LayerNorm suffices to yield strong performance. Moreover, when benchmarked against other tuning approaches like full parameter finetuning or LoRA, its benefits on efficiency are substantial. For example, when compared to LoRA on a 13B model scale, performance can be enhanced by an average of over 20% across five multi-modal tasks, and meanwhile, results in a significant reduction of trainable parameters by 41.9% and a decrease in GPU memory usage by 17.6%. On top of this LayerNorm strategy, we showcase that selectively tuning only with conversational data can improve efficiency further. Beyond these empirical outcomes, we provide a comprehensive analysis to explore the role of LayerNorm in adapting LLMs to the multi-modal domain and improving the expressive power of the model.*
+
+## Benchmark overview
+
+
+
+# API
+
+## LNTuningConfig
+
+[[autodoc]] tuners.ln_tuning.config.LNTuningConfig
+
+## LNTuningModel
+
+[[autodoc]] tuners.ln_tuning.model.LNTuningModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lily.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lily.md
new file mode 100644
index 0000000000000000000000000000000000000000..c971930f84b90a802e8c41e83ecd1c8ace1cbc44
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lily.md
@@ -0,0 +1,52 @@
+
+
+# Lily: Low-Rank Interconnected Adaptation across Layers
+
+[Lily](https://huggingface.co/papers/2407.09946) is a parameter-efficient fine-tuning technique that introduces cross-layer weight sharing for adapter matrices. Instead of learning an independent AB pair per layer as in LoRA, Lily uses **locally shared A adapters** (each A is shared across a block of `stride_A` consecutive layers) and **globally shared B experts** (a small pool of `num_B` B adapters is shared across all layers). At each forward pass, a lightweight data-dependent router computes a softmax-weighted combination of the B experts to produce the effective B for that layer and input.
+
+This sharing can reduce the total number of adapter matrices from `2N` (standard LoRA) to `N / stride_A + num_B`, freeing up the parameter budget to use a **much larger rank `r`** — typically `2×`–`4×` what you would use in LoRA. Higher rank and better interconnectivity increase the effective rank of the weight update `ΔW = A × combined_B`, leading to better adaptation performance.
+
+Because the B combination is **data-dependent** (the router weights depend on the input activations at runtime), `merge` and `unmerge` are **not supported**. If weight merging is required for your deployment, consider other methods such as LoRA instead.
+
+Lily currently has the following additional constraints:
+- Only `nn.Linear` layers are supported.
+- Quantized layers are not supported.
+
+If these constraints don't work for your use case, consider other methods instead.
+
+The abstract from the paper is:
+
+> Low-rank adaptation (LoRA) is a widely used parameter-efficient fine-tuning (PEFT) method that learns weight updates ΔW = AB for pretrained weights W through low-rank adapters A and B. While LoRA ensures hardware efficiency, its low-rank weight updates limit adaptation performance. In this paper, we propose low-rank interconnected adaptation across layers (Lily), a novel PEFT method that introduces an interconnected framework with locally shared A and globally shared B experts. This structure eliminates redundant per-layer AB pairs, enabling higher-rank ΔW with equal or fewer parameters. To enhance expressiveness, we use data-dependent routers to determine A-B interconnections, preventing B experts from converging to the same behavior and improving representational power across domains. Experiments across modalities, architectures, and model sizes demonstrate Lily's superior performance and efficiency.
+
+## Benchmark overview
+
+
+
+# API
+
+## LilyConfig
+
+[[autodoc]] tuners.lily.config.LilyConfig
+
+## LilyModel
+
+[[autodoc]] tuners.lily.model.LilyModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/llama_adapter.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/llama_adapter.md
new file mode 100644
index 0000000000000000000000000000000000000000..a891fa06bc3114c65813230e1538183bf1363d10
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/llama_adapter.md
@@ -0,0 +1,47 @@
+
+
+# Llama-Adapter
+
+
+
+
+LLaMA-Adapter: Efficient Fine-tuning of Language Models with Zero-init Attention
+
+[Llama-Adapter](https://hf.co/papers/2303.16199) is a PEFT method specifically designed for turning Llama into an instruction-following model. The Llama model is frozen and only a set of adaptation prompts prefixed to the input instruction tokens are learned. Since randomly initialized modules inserted into the model can cause the model to lose some of its existing knowledge, Llama-Adapter uses zero-initialized attention with zero gating to progressively add the instructional prompts to the model.
+
+The abstract from the paper is:
+
+*We present LLaMA-Adapter, a lightweight adaption method to efficiently fine-tune LLaMA into an instruction-following model. Using 52K self-instruct demonstrations, LLaMA-Adapter only introduces 1.2M learnable parameters upon the frozen LLaMA 7B model, and costs less than one hour for fine-tuning on 8 A100 GPUs. Specifically, we adopt a set of learnable adaption prompts, and prepend them to the input text tokens at higher transformer layers. Then, a zero-init attention mechanism with zero gating is proposed, which adaptively injects the new instructional cues into LLaMA, while effectively preserves its pre-trained knowledge. With efficient training, LLaMA-Adapter generates high-quality responses, comparable to Alpaca with fully fine-tuned 7B parameters. Furthermore, our approach can be simply extended to multi-modal input, e.g., images, for image-conditioned LLaMA, which achieves superior reasoning capacity on ScienceQA. We release our code at https://github.com/ZrrSkywalker/LLaMA-Adapter*.
+
+## Benchmark overview
+
+
+
+# API
+
+## AdaptionPromptConfig
+
+[[autodoc]] tuners.adaption_prompt.config.AdaptionPromptConfig
+
+## AdaptionPromptModel
+
+[[autodoc]] tuners.adaption_prompt.model.AdaptionPromptModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/loha.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/loha.md
new file mode 100644
index 0000000000000000000000000000000000000000..3dec6a08e5fabcf11af80c8be367161d88da3828
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/loha.md
@@ -0,0 +1,90 @@
+
+
+# LoHa
+
+
+
+
+Navigating Text-To-Image Customization: From LyCORIS Fine-Tuning to Model Evaluation
+
+Low-Rank Hadamard Product ([LoHa](https://huggingface.co/papers/2108.06098)), is similar to LoRA except it approximates the large weight matrix with more low-rank matrices and combines them with the Hadamard product. This method is even more parameter-efficient than LoRA and achieves comparable performance. LoHa was originally proposed for federated learning (FedPara) but works well as a general-purpose PEFT method, and is especially popular for fine-tuning image generation models such as Stable Diffusion.
+
+> **Note:** LoHa is part of the [LyCORIS](./adapter_utils) family of adapters. Its close relative [LoKr](./lokr) uses the Kronecker product instead of the Hadamard product.
+
+The abstract from the paper is:
+
+*In this work, we propose a communication-efficient parameterization, FedPara, for federated learning (FL) to overcome the burdens on frequent model uploads and downloads. Our method re-parameterizes weight parameters of layers using low-rank weights followed by the Hadamard product. Compared to the conventional low-rank parameterization, our FedPara method is not restricted to low-rank constraints, and thereby it has a far larger capacity. This property enables to achieve comparable performance while requiring 3 to 10 times lower communication costs than the model with the original layers, which is not achievable by the traditional low-rank methods. The efficiency of our method can be further improved by combining with other efficient FL optimizers. In addition, we extend our method to a personalized FL application, pFedPara, which separates parameters into global and local ones. We show that pFedPara outperforms competing personalized FL methods with more than three times fewer parameters.*
+
+Low-rank decomposition can impact performance because the weight updates are limited to the low-rank space, which can constrain a model's expressiveness. However, you don't necessarily want to use a larger rank because it increases the number of trainable parameters. To address this, LoHa was applied to diffusion models where the ability to generate diverse images is an important consideration. LoHa should also work with general model types, but support for embedding layers isn't currently implemented in PEFT.
+
+LoHa uses the [Hadamard product](https://en.wikipedia.org/wiki/Hadamard_product_(matrices)) (element-wise product) instead of the matrix product. $\Delta W$ is represented by four smaller matrices instead of two - like in LoRA - and each pair of these low-rank matrices are combined with the Hadamard product. As a result, $\Delta W$ can have the same number of trainable parameters but a higher rank and expressivity.
+
+## When to use LoHa
+
+LoHa is a good choice when:
+
+- You are fine-tuning **image generation models** (Stable Diffusion UNet or text encoder), where it is most widely used.
+- You want **higher effective rank** than LoRA for the same number of trainable parameters, since the Hadamard product of two low-rank matrices spans a larger subspace than a single low-rank product.
+- You want to **combine different PEFT methods** at inference time using [`PeftMixedModel`](./peft_model#peft.PeftMixedModel), for example LoHa together with LoKr.
+
+LoHa supports linear and Conv2d layers. For tasks that additionally require embedding layer adaptation, consider [LoRA](./lora) instead.
+
+## Usage
+
+```python
+from diffusers import StableDiffusionPipeline
+from peft import LoHaConfig, get_peft_model
+
+config_unet = LoHaConfig(
+ r=8,
+ alpha=8,
+ target_modules=[
+ "to_k",
+ "to_q",
+ "to_v",
+ "to_out.0",
+ "proj_in",
+ "proj_out",
+ ],
+ rank_dropout=0.0,
+ module_dropout=0.0,
+ use_effective_conv2d=True,
+)
+
+pipeline = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
+pipeline.unet = get_peft_model(pipeline.unet, config_unet)
+pipeline.unet.print_trainable_parameters()
+```
+
+## Benchmark overview
+
+
+
+# API
+
+## LoHaConfig
+
+[[autodoc]] tuners.loha.config.LoHaConfig
+
+## LoHaModel
+
+[[autodoc]] tuners.loha.model.LoHaModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lokr.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lokr.md
new file mode 100644
index 0000000000000000000000000000000000000000..68a54b9d56aac17f488fd7f73c937f926131e080
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lokr.md
@@ -0,0 +1,64 @@
+
+
+# LoKr
+
+
+
+
+Navigating Text-To-Image Customization: From LyCORIS Fine-Tuning to Model Evaluation
+
+Low-Rank Kronecker Product ([LoKr](https://hf.co/papers/2309.14859)), is a LoRA-variant method that approximates the large weight matrix with two low-rank matrices and combines them with the [Kronecker product](https://en.wikipedia.org/wiki/Kronecker_product). LoKr also provides an optional third low-rank matrix to provide better control during fine-tuning. By expresseing the weight update matrix as a decomposition of a Kronecker product, creating a block matrix, LoKr is able to preserve the rank of the original weight matrix. The size of the smaller matrices are determined by its *rank* or `r`. Another benefit of the Kronecker product is that it can be vectorized by stacking the matrix columns. This can speed up the process because you're avoiding fully reconstructing ∆W.
+
+The abstract from the paper is:
+
+*Text-to-image generative models have garnered immense attention for their ability to produce high-fidelity images from text prompts. Among these, Stable Diffusion distinguishes itself as a leading open-source model in this fast-growing field. However, the intricacies of fine-tuning these models pose multiple challenges from new methodology integration to systematic evaluation. Addressing these issues, this paper introduces LyCORIS [Lora beYond Conventional methods, Other Rank adaptation Implementations for Stable diffusion](https://github.com/KohakuBlueleaf/LyCORIS), an open-source library that offers a wide selection of fine-tuning methodologies for Stable Diffusion. Furthermore, we present a thorough framework for the systematic assessment of varied fine-tuning techniques. This framework employs a diverse suite of metrics and delves into multiple facets of fine-tuning, including hyperparameter adjustments and the evaluation with different prompt types across various concept categories. Through this comprehensive approach, our work provides essential insights into the nuanced effects of fine-tuning parameters, bridging the gap between state-of-the-art research and practical application.*
+
+## Usage
+
+```py
+from peft import LoKrConfig, get_peft_model
+
+config = LoKrConfig(
+ r=16,
+ alpha=16,
+ target_modules=["query", "value"],
+ module_dropout=0.1,
+ modules_to_save=["classifier"],
+)
+model = get_peft_model(model, config)
+model.print_trainable_parameters()
+"trainable params: 116,069 || all params: 87,172,042 || trainable%: 0.13314934162033282"
+```
+
+## Benchmark overview
+
+
+
+# API
+
+## LoKrConfig
+
+[[autodoc]] tuners.lokr.config.LoKrConfig
+
+## LoKrModel
+
+[[autodoc]] tuners.lokr.model.LoKrModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora.md
new file mode 100644
index 0000000000000000000000000000000000000000..090f56f99802581188b285ac69302a56edc3b777
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora.md
@@ -0,0 +1,1097 @@
+
+
+# LoRA
+
+> [!TIP]
+> LoRA is one of the most popular PEFT methods and a good starting point if you're just getting started with PEFT. It was originally developed for large language models but it is a tremendously popular training method for diffusion models because of its efficiency and effectiveness.
+
+Low-Rank Adaptation ([LoRA](https://huggingface.co/papers/2106.09685)) is a PEFT method that decomposes a large matrix into two smaller low-rank matrices. This drastically reduces the number of parameters that need to be fine-tuned.
+
+The abstract from the paper is:
+
+*An important paradigm of natural language processing consists of large-scale pre-training on general domain data and adaptation to particular tasks or domains. As we pre-train larger models, full fine-tuning, which retrains all model parameters, becomes less feasible. Using GPT-3 175B as an example -- deploying independent instances of fine-tuned models, each with 175B parameters, is prohibitively expensive. We propose Low-Rank Adaptation, or LoRA, which freezes the pre-trained model weights and injects trainable rank decomposition matrices into each layer of the Transformer architecture, greatly reducing the number of trainable parameters for downstream tasks. Compared to GPT-3 175B fine-tuned with Adam, LoRA can reduce the number of trainable parameters by 10,000 times and the GPU memory requirement by 3 times. LoRA performs on-par or better than fine-tuning in model quality on RoBERTa, DeBERTa, GPT-2, and GPT-3, despite having fewer trainable parameters, a higher training throughput, and, unlike adapters, no additional inference latency. We also provide an empirical investigation into rank-deficiency in language model adaptation, which sheds light on the efficacy of LoRA. We release a package that facilitates the integration of LoRA with PyTorch models and provide our implementations and model checkpoints for RoBERTa, DeBERTa, and GPT-2 at [this https URL](https://github.com/microsoft/LoRA).*
+
+LoRA represents the weight updates $\Delta W$ with two smaller matrices (called *update matrices*) through low-rank decomposition. These new matrices can be trained to adapt to the new data while keeping the overall number of parameters low. The original weight matrix remains frozen and doesn't receive any further updates. To produce the final results, the original and extra adapted weights are combined. You could also merge the adapter weights with the base model to eliminate inference latency.
+
+
+
+
+
+This approach has a number of advantages:
+
+* LoRA makes finetuning more efficient by drastically reducing the number of trainable parameters.
+* The original pretrained weights are kept frozen, which means you can have multiple lightweight and portable LoRA models for various downstream tasks built on top of them.
+* LoRA is orthogonal to other parameter-efficient methods and can be combined with many of them.
+* Performance of models finetuned using LoRA is comparable to the performance of fully finetuned models.
+
+In principle, LoRA can be applied to any subset of weight matrices in a neural network to reduce the number of trainable parameters. However, for simplicity and further parameter efficiency, LoRA is typically only applied to the attention blocks in Transformer models - it may be worth targeting other layers as well. The resulting number of trainable parameters in a LoRA model depends on the size of the update matrices, which is determined mainly by the rank `r` and the shape of the original weight matrix.
+
+You can initialize the low-rank matrices with different use-cases in mind - task awareness (CoRDA, EVA), faster convergence (PiSSA), mitigating quantizations (LoftQ) - just to name a few use-cases. Read about the different initializations [below](#initialization). The default initialization is for LoRA to be a no-op, to gradually learn new behavior without interfering much with the existing model.
+
+## Usage
+
+The size of the low-rank update matrices is determined by the *rank* or `r`. A higher rank means the model has more parameters to train, but it also means the model has more learning capacity. In the following example, you'll target the *query* and *value* matrices of the attention blocks. Other important parameters to set are `lora_alpha` (scaling factor), `bias` (whether `none`, `all` or only the LoRA bias parameters should be trained), and `modules_to_save` (the modules apart from the LoRA layers to be trained and saved). All of these parameters - and more - are found in the [`LoraConfig`].
+
+```py
+from peft import LoraConfig, get_peft_model
+
+config = LoraConfig(
+ r=16,
+ lora_alpha=16,
+ target_modules=["query", "value"],
+ lora_dropout=0.1,
+ bias="none",
+ modules_to_save=["classifier"],
+)
+model = get_peft_model(model, config)
+model.print_trainable_parameters()
+"trainable params: 667,493 || all params: 86,543,818 || trainable%: 0.7712775047664294"
+```
+
+
+## Benchmark overview
+
+
+
+
+
+## Initialization
+
+The initialization of LoRA weights is controlled by the parameter `init_lora_weights` in [`LoraConfig`]. By default, PEFT initializes LoRA weights with Kaiming-uniform for weight A and zeros for weight B resulting in an identity transform (same as the reference [implementation](https://github.com/microsoft/LoRA)).
+
+It is also possible to pass `init_lora_weights="gaussian"`. As the name suggests, this initializes weight A with a Gaussian distribution and zeros for weight B (this is how [Diffusers](https://huggingface.co/docs/diffusers/index) initializes LoRA weights).
+
+```py
+from peft import LoraConfig
+
+config = LoraConfig(init_lora_weights="gaussian", ...)
+```
+
+There is also an option to set `init_lora_weights=False` which is useful for debugging and testing. This should be the only time you use this option. When choosing this option, the LoRA weights are initialized such that they do *not* result in an identity transform.
+
+```py
+from peft import LoraConfig
+
+config = LoraConfig(init_lora_weights=False, ...)
+```
+
+
+
+[PiSSA](https://huggingface.co/papers/2404.02948) initializes the LoRA adapter using the principal singular values and singular vectors. This straightforward modification allows PiSSA to converge more rapidly than LoRA and ultimately attain superior performance. Moreover, PiSSA reduces the quantization error compared to QLoRA, leading to further enhancements.
+
+Configure the initialization method to "pissa", which may take several minutes to execute SVD on the pre-trained model:
+```python
+from peft import LoraConfig
+config = LoraConfig(init_lora_weights="pissa", ...)
+```
+Alternatively, execute fast SVD, which takes only a few seconds. The number of iterations determines the trade-off between the error and computation time:
+```python
+lora_config = LoraConfig(init_lora_weights="pissa_niter_[number of iters]", ...)
+```
+For detailed instruction on using PiSSA, please follow [these instructions](https://github.com/huggingface/peft/tree/main/examples/pissa_finetuning).
+
+
+
+
+[MiCA](https://arxiv.org/abs/2604.01694) (Minor Component Adaptation) is a complement to PiSSA: instead of initializing from the *principal* singular components, MiCA uses the *minor* ones. Concretely, with `W = U Σ V^T`, MiCA sets `B = U[:, -r:]` (the `r` left singular vectors associated with the smallest singular values) and `A = 0`. During training, only `A` is updated; `B` is frozen. The intuition is that the minor singular directions are largely unused by the pretrained task and therefore offer a more "plastic" subspace for injecting new knowledge while preserving pretrained capabilities.
+
+Because `A == 0` at init, the adapter contribution `B · A == 0` and the model output is preserved exactly at step 0 — no residual subtraction on the base weight is needed (unlike PiSSA). Since only `A` is trainable, the trainable parameter count for matching `r` is roughly half that of LoRA.
+
+```python
+from peft import LoraConfig
+config = LoraConfig(init_lora_weights="mica", r=16, target_modules=["q_proj", "v_proj"], ...)
+```
+
+MiCA currently supports `nn.Linear` and `nn.Embedding` target modules. The chosen rank must satisfy `r <= min(in_features, out_features)` for linear layers and `r <= min(num_embeddings, embedding_dim)` for embedding layers. For detailed usage, see [these instructions](https://github.com/huggingface/peft/tree/main/examples/mica_finetuning).
+
+MiCA is primarily intended for continued pretraining / domain-adaptive pretraining. In that setting, use the base model, not an instruction- or chat-tuned checkpoint, for the SVD initialization and MiCA training. After training, merge the adapter into the base model weights and use the resulting adapted base model as the starting point for subsequent instruction/chat tuning.
+
+
+
+[CorDA](https://huggingface.co/papers/2406.05223) builds task-aware LoRA adapters from weight decomposition oriented by the context of downstream task to learn (instruction-previewed mode, IPM) or world knowledge to maintain (knowledge-preserved mode, KPM). The KPM not only achieves better performance than LoRA on fine-tuning tasks, but also mitigates the catastrophic forgetting of pre-trained world knowledge. When preserving pre-trained knowledge is not a concern, the IPM is favored because it can further accelerate convergence and enhance the fine-tuning performance.
+
+You need to configure the initialization method to "corda", and specify the mode of IPM or KPM and the dataset to collect covariance matrices.
+
+```py
+@torch.no_grad()
+def run_model():
+ # Assume `model` and `dataset` is in context...
+ model.eval()
+ for batch in dataset:
+ model(**batch)
+
+
+corda_config = CordaConfig(
+ corda_method="kpm",
+)
+lora_config = LoraConfig(
+ init_lora_weights="corda",
+ corda_config=corda_config,
+)
+preprocess_corda(model, lora_config, run_model=run_model)
+peft_model = get_peft_model(model, lora_config)
+```
+
+For detailed instruction on using CorDA, please follow [these instructions](https://github.com/huggingface/peft/tree/main/examples/corda_finetuning).
+
+
+
+[OLoRA](https://huggingface.co/papers/2406.01775) utilizes QR decomposition to initialize the LoRA adapters. OLoRA translates the base weights of the model by a factor of their QR decompositions, i.e., it mutates the weights before performing any training on them. This approach significantly improves stability, accelerates convergence speed, and ultimately achieves superior performance.
+
+You just need to pass a single additional option to use OLoRA:
+```python
+from peft import LoraConfig
+config = LoraConfig(init_lora_weights="olora", ...)
+```
+For more advanced usage, please refer to our [documentation](https://github.com/huggingface/peft/tree/main/examples/olora_finetuning).
+
+
+
+[EVA](https://huggingface.co/papers/2410.07170) performs SVD on the input activations of each layer and uses the right-singular vectors to initialize LoRA weights. It is therefore a data-driven initialization scheme. Furthermore EVA adaptively allocates ranks across layers based on their "explained variance ratio" - a metric derived from the SVD analysis.
+
+You can use EVA by setting `init_lora_weights="eva"` and defining [`EvaConfig`] in [`LoraConfig`]:
+```python
+from peft import LoraConfig, EvaConfig
+peft_config = LoraConfig(
+ init_lora_weights = "eva",
+ eva_config = EvaConfig(rho = 2.0),
+ ...
+)
+```
+The parameter `rho` (≥ 1.0) determines how much redistribution is allowed. When `rho=1.0` and `r=16`, LoRA adapters are limited to exactly 16 ranks, preventing any redistribution from occurring. A recommended value for EVA with redistribution is 2.0, meaning the maximum rank allowed for a layer is 2r.
+
+It is recommended to perform EVA initialization on an accelerator(e.g. CUDA GPU, Intel XPU) as it is much faster. To optimize the amount of available memory for EVA, you can use the `low_cpu_mem_usage` flag in [`get_peft_model`]:
+```python
+peft_model = get_peft_model(model, peft_config, low_cpu_mem_usage=True)
+```
+Then, call [`initialize_lora_eva_weights`] to initialize the EVA weights (in most cases the dataloader used for eva initialization can be the same as the one used for finetuning):
+```python
+initialize_lora_eva_weights(peft_model, dataloader)
+```
+EVA works out of the box with bitsandbytes. Simply initialize the model with `quantization_config` and call [`initialize_lora_eva_weights`] as usual.
+
+> [!TIP]
+> For further instructions on using EVA, please refer to our [documentation](https://github.com/huggingface/peft/tree/main/examples/eva_finetuning).
+
+
+
+When quantizing the base model for QLoRA training, consider using the [LoftQ initialization](https://huggingface.co/papers/2310.08659), which has been shown to improve performance when training quantized models. The idea is that the LoRA weights are initialized such that the quantization error is minimized. To use LoftQ, follow [these instructions](https://github.com/huggingface/peft/tree/main/examples/loftq_finetuning).
+
+> [!TIP]
+> Learn more about how PEFT works with quantization and how to use LoftQ in the [Quantization](../developer_guides/quantization) guide.
+
+
+
+Another way to initialize [`LoraConfig`] is with the [rank-stabilized LoRA (rsLoRA)](https://huggingface.co/papers/2312.03732) method. The LoRA architecture scales each adapter during every forward pass by a fixed scalar which is set at initialization and depends on the rank `r`. The scalar is given by `lora_alpha/r` in the original implementation, but rsLoRA uses `lora_alpha/math.sqrt(r)` which stabilizes the adapters and increases the performance potential from using a higher `r`.
+
+```py
+from peft import LoraConfig
+
+config = LoraConfig(use_rslora=True, ...)
+```
+
+
+
+[LoRA-GA](https://hf.co/papers/2407.05000) (Low-Rank Adaptation with Gradient Approximation) initializes the adapter
+weights by performing SVD on estimated gradients, so that the weights are aligning closer to full-finetuning for faster
+convergence.
+
+This method requires an initialization function to estimate the gradients
+before beginning the actual training:
+
+```python
+from peft.tuners.lora import preprocess_loraga
+
+def train_step():
+ """Run forward and backward passes for gradient estimation."""
+ dataloader_iter = iter(grad_dataloader)
+ for _ in range(N):
+ batch = next(dataloader_iter)
+ batch = {k: v.to(device) for k, v in batch.items()}
+ outputs = model(**batch)
+ loss = outputs.loss
+ loss.backward()
+
+preprocess_loraga(model, lora_config, train_step)
+```
+
+#### Usage Tips
+
+- **Gradient Estimation**: LoRA-GA requires a gradient estimation phase before model initialization. Use `preprocess_loraga()` with a `train_step` callback to compute gradients over a small number of training batches (typically 64-128 batches).
+
+- **Initialization Strategies**: LoRA-GA supports four direction strategies (`direction`): `"ArBr"`, `"A2rBr"`, `"ArB2r"` (default), and `"random"`, and four scaling strategies (`scale`): `"stable"` (default), `"weight_svd"`, `"gd_scale"`, and `"unit"`. The default combination provides the best balance of convergence speed and stability.
+
+- **Base Weight Modification**: Unlike standard LoRA, LoRA-GA modifies the base model weights during initialization by subtracting a scaled version of the low-rank approximation. This enables better alignment with full fine-tuning gradients. Since base weights are modified, use `save_pretrained()` with the `save_embedding_layers` argument or `save_mutated_as_lora` pattern to properly save the adapter.
+
+- **Computational Overhead**: The gradient estimation adds a small overhead during initialization (typically 1-2 minutes for 64 batches), but this is quickly amortized by faster convergence during training.
+
+- **Compatibility**: LoRA-GA requires full-precision weights and does not support quantized models. Can be combined with other LoRA variants like DoRA.
+
+
+
+## Training
+
+This section shows how to handle more complex training scenarios instead of only applying a low-rank adapter to the model and feed data.
+
+### QLoRA-style training
+
+The default LoRA settings in PEFT add trainable weights to the query and value layers of each attention block. But [QLoRA](https://hf.co/papers/2305.14314), which adds trainable weights to all the linear layers of a transformer model, can provide performance equal to a fully finetuned model. To apply LoRA to all the linear layers, like in QLoRA, set `target_modules="all-linear"` (easier than specifying individual modules by name which can vary depending on the architecture).
+
+```py
+config = LoraConfig(target_modules="all-linear", ...)
+```
+
+For more information about how to apply quantization to PEFT adapters, refer to the [quantization guide](../developer_guides/quantization).
+
+### Memory efficient Layer Replication with LoRA
+
+An approach used to improve the performance of models is to expand a model by duplicating layers in the model to build a larger model from a pretrained model of a given size. For example increasing a 7B model to a 10B model as described in the [SOLAR](https://huggingface.co/papers/2312.15166) paper. PEFT LoRA supports this kind of expansion in a memory efficient manner that supports further fine-tuning using LoRA adapters attached to the layers post replication of the layers. The replicated layers do not take additional memory as they share the underlying weights so the only additional memory required is the memory for the adapter weights. To use this feature you would create a config with the `layer_replication` argument.
+
+```py
+config = LoraConfig(layer_replication=[[0,4], [2,5]], ...)
+```
+
+Assuming the original model had 5 layers `[0, 1, 2 ,3, 4]`, this would create a model with 7 layers arranged as `[0, 1, 2, 3, 2, 3, 4]`. This follows the [mergekit](https://github.com/arcee-ai/mergekit) pass through merge convention where sequences of layers specified as start inclusive and end exclusive tuples are stacked to build the final model. Each layer in the final model gets its own distinct set of LoRA adapters.
+
+[Fewshot-Metamath-OrcaVicuna-Mistral-10B](https://huggingface.co/abacusai/Fewshot-Metamath-OrcaVicuna-Mistral-10B) is an example of a model trained using this method on Mistral-7B expanded to 10B. The
+[adapter_config.json](https://huggingface.co/abacusai/Fewshot-Metamath-OrcaVicuna-Mistral-10B/blob/main/adapter_config.json) shows a sample LoRA adapter config applying this method for fine-tuning.
+
+### Fine grained control over ranks and alpha (scaling)
+
+By default, all layers targeted with LoRA will have the same rank `r` and the same `lora_alpha` (which determines the LoRA scaling), depending on what was specified in the [`LoraConfig`]. In some cases, however, you may want to indicate different values for different layers. This is possible by passing the `rank_pattern` and `alpha_pattern` arguments to [`LoraConfig`]. These arguments should be dictionaries with the key being the layer name and the value being the rank/alpha value. The keys can be [regular expressions](https://docs.python.org/3/library/re.html) (regex). All LoRA layers that are not explicitly mentioned in `rank_pattern` and `alpha_pattern` will take the default `r` and `lora_alpha` values.
+
+To give an example, let's assume that we have a model with the following structure:
+
+```python
+>>> print(model)
+Outer(
+ (foo): Linear(...)
+ (module): Middle(
+ (foo): Linear(...)
+ (foobar): Linear(...)
+ (module): Inner(
+ (foo): Linear(...)
+ (barfoo): Linear(...)
+ )
+ )
+)
+```
+
+- `rank_pattern={"foo": 42}` will match all 3 `foo` layers. Neither `foobar` nor `barfoo` are matched.
+- `rank_pattern={"^foo": 42}` will only match the `foo` layer of the model, but neither `module.foo` nor `module.module.foo`. This is because the `^` means "start of string" when using regular expressions, and only `foo` starts with `"foo"`, the other layer names have prefixes.
+- `rank_pattern={"^module.foo": 42}` matches only `module.foo`, but not `module.module.foo`, for the same reason.
+- `rank_pattern={"module.foo": 42}` matches both `module.foo` and `module.module.foo`, but not `foo`.
+- `rank_pattern={"^foo": 42, "^module.module.foo": 55}` matches `foo` and `module.module.foo`, respectively, but not `module.foo`.
+- There is no need to indicate `$` to mark the end of the match, as this is added automatically by PEFT.
+
+The same logic applies to `alpha_pattern`. If you're in doubt, don't try to get fancy with regular expressions -- just pass the full name for each module with a different rank/alpha, preceded by the `^` prefix, and you should be good.
+
+### Automatically detect viable target modules
+
+[`peft.helpers.KappaTuneSelector`] implements the condition-number-based target selection strategy from the [KappaTune paper](https://arxiv.org/abs/2506.16289). It scans every `nn.Linear` module and, for models where MoE expert weights are stored as fused 3D `nn.Parameter` tensors (e.g. Llama-4, Qwen3-MoE), also those parameters, computes the matrix condition number κ = σ_max / σ_min for each, and selects the most isotropic layers (lowest κ). These isotropic layers serve as ideal candidates for fine-tuning, since their high-entropy nature allows them to absorb new information more readily, leaving the specialized, anisotropic layers intact to mitigate catastrophic forgetting during continual learning.
+
+Use [`peft.helpers.find_kappa_target_modules`] as a one-liner to get the optimal `target_modules` for `LoraConfig`:
+
+```python
+from peft import LoraConfig, get_peft_model
+from peft.helpers import find_kappa_target_modules
+
+model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
+
+targets = find_kappa_target_modules(model, top_p=0.2)
+config = LoraConfig(
+ target_modules=targets["target_modules"],
+ target_parameters=targets["target_parameters"] if stable_modules_dic["target_parameters"] else None,
+ r=64,
+ lora_alpha=32,
+ task_type="CAUSAL_LM",
+)
+peft_model = get_peft_model(model, config)
+```
+
+See a complete example [here](https://github.com/huggingface/peft/blob/main/examples/KappaTune/experiments_kappatune_peft.py).
+
+### Targeting `nn.Parameter` directly
+
+Generally, you should use `target_modules` to target the module (e.g. `nn.Linear`). However, in some circumstances, this is not possible. E.g., in many mixture of expert (MoE) layers in HF Transformers, instead of using `nn.Linear`, an `nn.Parameter` is used. PEFT normally overwrites the `forward` method for LoRA, but for `nn.Parameter`, there is none. Therefore, to apply LoRA to that parameter, it needs to be targeted with `target_parameters`. As an example, for [Llama4](https://huggingface.co/collections/meta-llama/llama-4-67f0c30d9fe03840bc9d0164), you can pass: `target_parameters=['feed_forward.experts.gate_up_proj', 'feed_forward.experts.down_proj]`.
+
+Note that when targeting expert parameters, PEFT can add a substantial runtime overhead. The reason is that PEFT always materializes the LoRA contribution for _each expert_ even if only a small amount of experts is required. During training, this is less relevant since, over the course of the sequence, typically a large fraction of experts is activated at least once. However, during inference, normally a KV cache is used and we thus need to only compute the last token, which means that only a small amount of experts is activated. Therefore, using LoRA on MoE layers can result in a substantial slowdown at inference time. The recommendation is thus to merge the weights (`model.merge_adapter()` or `model = model.merge_and_unload()`). This removes the PEFT overhead.
+
+A more detailed investigation of this issue can be found on this [pull request on MoE optimization](https://github.com/huggingface/peft/pull/3139).
+
+#### Caveats
+
+- At the moment, this argument allows to target 2-dim or 3-dim `nn.Parameter`s. It is assumed that in the case of a 3-dim parameter, the 0th dimension is the expert dimension.
+- Multiple LoRA adapters (added via `model.add_adapter` or `model.load_adapter`) that use `target_parameters` are supported, but all of them must target the same set of parameters.
+
+#### MoE expert parameters and vLLM
+
+Some MoE models in Transformers store expert weights as `nn.Parameter` tensors (often 3D), not `nn.Linear` modules.
+To apply LoRA to those experts, use `target_parameters` and set a per-layer rank with `rank_pattern`:
+
+```python
+num_experts = getattr(model.config, "num_local_experts", None) or model.config.num_experts
+effective_r = max(1, r // num_experts)
+config = LoraConfig(
+ r=r,
+ lora_alpha=32,
+ target_modules=["q_proj", "v_proj"],
+ target_parameters=[
+ # Mixtral / Qwen3-MoE / GPT-OSS
+ "mlp.experts.gate_up_proj",
+ "mlp.experts.down_proj",
+ # Llama4
+ # "feed_forward.experts.gate_up_proj",
+ # "feed_forward.experts.down_proj",
+ ],
+ rank_pattern={
+ "experts.gate_up_proj": effective_r,
+ "experts.down_proj": effective_r,
+ },
+)
+```
+
+This keeps the total LoRA parameter budget similar to dense layers (see [LoRA Without Regret](https://thinkingmachines.ai/blog/lora/) by Schulman et. al.). Non-expert modules use the default rank `r`.
+
+Accelerated inference with the fine-tuned model is possible with, for example, [vLLM](https://vllm.ai/) which supports fused MoE expert layers since v0.11.2.
+
+### Efficiently train tokens alongside LoRA
+
+PEFT LoRA adapters support adding new tokens with the `trainable_token_indices` parameter. This allows tuning of other tokens alongside fine-tuning specific layers. Only the specified tokens are trained and all other tokens are untouched. It saves memory and doesn't throw away learned context from existing token embeddings unlike training the whole embedding matrix. Under the hood this method uses the layer of [`TrainableTokensModel`].
+
+```py
+# for layer 'embed_tokens'
+config = LoraConfig(trainable_token_indices=[idx_1, idx_2, ...], ...)
+
+# specific embedding layer
+config = LoraConfig(trainable_token_indices={'emb_tokens': [idx_1, idx_2, ...]}, ...)
+```
+
+In the snippet below we show how to add new tokens to the model and how to train it alongside the other layers in the model.
+
+```py
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import get_peft_model, LoraConfig
+
+base_model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1")
+tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1")
+
+# we define our new tokens and add them to the tokenizer as special tokens
+special_tokens = ['<|start_think|>', '<|stop_think|>']
+tokenizer.add_special_tokens({'additional_special_tokens': special_tokens})
+
+# make room for new tokens in the embedding matrix if it isn't big enough already
+base_model.resize_token_embeddings(max(len(tokenizer), base_model.model.embed_tokens.num_embeddings))
+
+# typical LoRA config with `trainable_token_indices` targeting embedding layer `embed_tokens`
+# and specifically our new tokens we just added
+lora_config = LoraConfig(
+ target_modules='all-linear',
+ trainable_token_indices={'embed_tokens': tokenizer.convert_tokens_to_ids(special_tokens)},
+)
+peft_model = get_peft_model(base_model, lora_config)
+
+# proceed to train the model like normal
+[...]
+```
+
+The token weights are saved as a part of the adapter state dict alongside the LoRA weights. Full fine-tuning and saving the embedding matrix would have stored a much bigger file.
+
+To give a bit of an indication how much VRAM can be saved, a rudimentary comparison of the above example was made between training the embedding matrix fully (`modules_to_save=["embed_tokens"]`), using a LoRA for the embedding matrix (`target_modules=[..., "embed_tokens"]`, rank 32) and trainable tokens (`trainable_token_indices=[...]`, 6 tokens):
+
+| | Trainable Tokens | LoRA | Full Fine-tuning |
+| --------: | :--------------: | :--------: | :--------------: |
+| VRAM | 15,562 MB | 15,581MB | ~16,500MB |
+| Influence | 6 tokens | all tokens | all tokens |
+
+### Weight tying
+
+Many causal LMs use **weight tying**, where two or more weights share the same underlying parameters. In the most common case, the input embedding weights (`embed_tokens`) and output projection weights (`lm_head`) share the same tensor. This is because it reduces parameters and usually preserves model quality.
+
+It's not always obvious how PEFT deals with these tied weights when they are targeted for fine-tuning. For LoRA, the `ensure_weight_tying` on the [`LoraConfig`] controls whether PEFT should explicitly keep adapter-side updates tied for those layers. In practice, this can affect `modules_to_save`, `target_modules`, and `trainable_token_indices`. Note that this logic partially relies on convention when it comes to naming the layers (`"embed_tokens"`, `"lm_head"`) and proper working cannot be guaranteed if those conventions are not used.
+
+The tables below summarize expected behavior.
+
+#### `modules_to_save`
+
+| Base model weights tied | `ensure_weight_tying` | `LoraConfig` shape | Behavior |
+|-------------------------|-----------------------|-----------------------------------------------------|--------------------------------------------------------------|
+| No | `False` | `modules_to_save=["embed_tokens"]` or `["lm_head"]` | Add `ModulesToSaveWrapper` on selected layer only |
+| No | `True` | `modules_to_save=["embed_tokens"]` or `["lm_head"]` | Warn, then add `ModulesToSaveWrapper` on selected layer only |
+| Yes | `False` | `modules_to_save=["embed_tokens"]` or `["lm_head"]` | Treat as separate |
+| Yes | `True` | `modules_to_save=["embed_tokens"]` or `["lm_head"]` | Wrap tied layers and keep wrappers tied |
+| No | `False` | `modules_to_save=["embed_tokens", "lm_head"]` | Treat as separate |
+| No | `True` | `modules_to_save=["embed_tokens", "lm_head"]` | Warn, then treat as separate |
+| Yes | `False` | `modules_to_save=["embed_tokens", "lm_head"]` | Warn, then treat as separate |
+| Yes | `True` | `modules_to_save=["embed_tokens", "lm_head"]` | Keep `ModulesToSaveWrapper`s tied |
+
+#### `target_modules`
+
+| Base model weights tied | `ensure_weight_tying` | `LoraConfig` shape | Behavior |
+|-------------------------|-----------------------|----------------------------------------------------|--------------------------------------------|
+| No | `False` | `target_modules=["embed_tokens"]` or `["lm_head"]` | Add LoRA on selected layer only |
+| No | `True` | `target_modules=["embed_tokens"]` or `["lm_head"]` | Warn, then add LoRA on selected layer only |
+| Yes | `False` | `target_modules=["embed_tokens"]` or `["lm_head"]` | Treat as separate |
+| Yes | `True` | `target_modules=["embed_tokens"]` or `["lm_head"]` | Keep LoRA adapters tied |
+| No | `False` | `target_modules=["embed_tokens", "lm_head"]` | Treat as separate |
+| No | `True` | `target_modules=["embed_tokens", "lm_head"]` | Warn, then treat as separate |
+| Yes | `False` | `target_modules=["embed_tokens", "lm_head"]` | Warn, then treat as separate |
+| Yes | `True` | `target_modules=["embed_tokens", "lm_head"]` | Keep LoRA adapters tied |
+
+#### `trainable_token_indices`
+
+For trainable tokens, we have the additional complication that even if the LM head and embeddings are tied, as a user I may want to fine-tune *different* tokens on them. In the example table below, we thus differentiate between fine-tuning the same and fine-tuning different tokens.
+
+| Base model weights tied | `ensure_weight_tying` | `LoraConfig` shape | Behavior |
+|-------------------------|-----------------------|-----------------------------------------------------------------------|------------------------------------------------|
+| No | `False` | `trainable_token_indices=[1, 2, 3]` | Trainable tokens on embeddings only |
+| No | `True` | `trainable_token_indices=[1, 2, 3]` | Warn, then trainable tokens on embeddings only |
+| Yes | `False` | `trainable_token_indices=[1, 2, 3]` | Tied trainable tokens |
+| Yes | `True` | `trainable_token_indices=[1, 2, 3]` | Tied trainable tokens |
+| No | `False` | `trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [1, 2]}` | Treat as separate |
+| No | `True` | `trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [1, 2]}` | Warn, then treat as separate |
+| Yes | `False` | `trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [1, 2]}` | Tied trainable tokens |
+| Yes | `True` | `trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [1, 2]}` | Tied trainable tokens |
+| No | `False` | `trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [3, 4]}` | Treat as separate |
+| No | `True` | `trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [3, 4]}` | Warn, then treat as separate |
+| Yes | `False` | `trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [3, 4]}` | Treat as separate |
+| Yes | `True` | `trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [3, 4]}` | Error |
+
+For users, this means:
+
+- In general, if you want to fine-tune weights that are tied and want to keep them tied, pass `ensure_weight_tying=True`.
+- If your base model's weights are untied, `ensure_weight_tying=True` cannot force tying and only warns.
+- For `trainable_token_indices`, tied layers must use the same token indices when `ensure_weight_tying=True`.
+
+## Optimizers
+
+LoRA training can optionally include special purpose optimizers. Currently PEFT supports LoRA-FA and LoRA+.
+
+### LoRA-FA Optimizer
+
+LoRA training can be more effective and efficient using LoRA-FA, as described in [LoRA-FA](https://huggingface.co/papers/2308.03303). LoRA-FA reduces activation memory consumption by fixing the matrix A and only tuning the matrix B. During training, the gradient of B is optimized to approximate the full parameter fine-tuning gradient. Moreover, the memory consumption of LoRA-FA is not sensitive to the rank (since it erases the activation of $A$), therefore it can improve performance by enlarging lora rank without increasing memory consumption.
+
+```py
+from peft import LoraConfig, get_peft_model
+from peft.optimizers import create_lorafa_optimizer
+from transformers import Trainer, get_cosine_schedule_with_warmup
+
+base_model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-8B-Instruct")
+
+config = LoraConfig(...)
+model = get_peft_model(base_model, config)
+
+optimizer = create_lorafa_optimizer(
+ model=model,
+ r=128,
+ lora_alpha=32,
+ lr=7e-5,
+)
+
+scheduler = get_cosine_schedule_with_warmup(
+ optimizer,
+ num_warmup_steps=100,
+ num_training_steps=1000,
+)
+
+trainer = Trainer(
+ ...,
+ optimizers=(optimizer, scheduler),
+)
+```
+
+### LoRA+ optimized LoRA
+
+LoRA training can be optimized using [LoRA+](https://huggingface.co/papers/2402.12354), which uses different learning rates for the adapter matrices A and B, shown to increase finetuning speed by up to 2x and performance by 1-2%.
+
+```py
+from peft import LoraConfig, get_peft_model
+from peft.optimizers import create_loraplus_optimizer
+from transformers import Trainer
+import bitsandbytes as bnb
+
+base_model = ...
+config = LoraConfig(...)
+model = get_peft_model(base_model, config)
+
+optimizer = create_loraplus_optimizer(
+ model=model,
+ optimizer_cls=bnb.optim.Adam8bit,
+ lr=5e-5,
+ loraplus_lr_ratio=16,
+)
+scheduler = None
+
+...
+trainer = Trainer(
+ ...,
+ optimizers=(optimizer, scheduler),
+)
+```
+
+
+## Post-Training
+
+This section shows potential post-processing methods for trained adapters.
+
+
+### Merge LoRA weights into the base model
+
+While LoRA is significantly smaller and faster to train, you may encounter latency issues during inference due to separately loading the base model and the LoRA adapter. To eliminate latency, use the [`~LoraModel.merge_and_unload`] function to merge the adapter weights with the base model. This allows you to use the newly merged model as a standalone model. The [`~LoraModel.merge_and_unload`] function doesn't keep the adapter weights in memory.
+
+Below is a diagram that explains the intuition of LoRA adapter merging:
+
+
+
+
+
+We show in the snippets below how to run that using PEFT.
+
+```py
+from transformers import AutoModelForCausalLM
+from peft import PeftModel
+
+base_model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1")
+peft_model_id = "alignment-handbook/zephyr-7b-sft-lora"
+model = PeftModel.from_pretrained(base_model, peft_model_id)
+model = model.merge_and_unload()
+```
+
+It is important to assign the returned model to a variable and use it, [`~LoraModel.merge_and_unload`] is not an in-place operation. If you need to keep a copy of the weights so you can unmerge the adapter later or delete and load different ones, you should use the [`~LoraModel.merge_adapter`] function instead. Now you have the option to use [`~LoraModel.unmerge_adapter`] to return the base model.
+
+```py
+from transformers import AutoModelForCausalLM
+from peft import PeftModel
+
+base_model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1")
+peft_model_id = "alignment-handbook/zephyr-7b-sft-lora"
+model = PeftModel.from_pretrained(base_model, peft_model_id)
+model.merge_adapter()
+
+# unmerge the LoRA layers from the base model
+model.unmerge_adapter()
+```
+
+The [`~LoraModel.add_weighted_adapter`] function is useful for merging multiple LoRAs into a new adapter based on a user provided weighting scheme in the `weights` parameter. Below is an end-to-end example.
+
+First load the base model:
+
+```python
+from transformers import AutoModelForCausalLM
+from peft import PeftModel
+import torch
+
+base_model = AutoModelForCausalLM.from_pretrained(
+ "mistralai/Mistral-7B-v0.1", dtype=torch.float16, device_map="auto"
+)
+```
+
+Then we load the first adapter:
+
+```python
+peft_model_id = "alignment-handbook/zephyr-7b-sft-lora"
+model = PeftModel.from_pretrained(base_model, peft_model_id, adapter_name="sft")
+```
+
+Then load a different adapter and merge it with the first one:
+
+```python
+weighted_adapter_name = "sft-dpo"
+model.load_adapter("alignment-handbook/zephyr-7b-dpo-lora", adapter_name="dpo")
+model.add_weighted_adapter(
+ adapters=["sft", "dpo"],
+ weights=[0.7, 0.3],
+ adapter_name=weighted_adapter_name,
+ combination_type="linear"
+)
+model.set_adapter(weighted_adapter_name)
+```
+
+> [!TIP]
+> There are several supported methods for `combination_type`. Refer to the [documentation](../package_reference/lora#peft.LoraModel.add_weighted_adapter) for more details. Note that "svd" as the `combination_type` is not supported when using `torch.float16` or `torch.bfloat16` as the datatype.
+
+Now, perform inference:
+
+```python
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+
+tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1")
+
+prompt = "Hey, are you conscious? Can you talk to me?"
+inputs = tokenizer(prompt, return_tensors="pt")
+inputs = {k: v.to(device) for k, v in inputs.items()}
+
+with torch.no_grad():
+ generate_ids = model.generate(**inputs, max_length=30)
+outputs = tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
+print(outputs)
+```
+
+### Recovering base model performance via intruder dimension reduction
+
+The paper [LoRA vs Full Fine-tuning: An Illusion of Equivalence](https://huggingface.co/papers/2410.21228) argues that LoRA training introduces extra dimensions into the weights that have very little in common with the already learnt weights and lead to forgetting of already learned information. PEFT implements the suggested mitigation in [`peft.tuners.lora.intruders.reduce_intruder_dimension`].
+
+The mitigation will take a PEFT model with a loaded LoRA and create a new, modified adapter that is loaded alongside the existing adapter and now the active adapter.
+
+Example usage:
+
+```python
+from peft.tuners.lora.intruders import reduce_intruder_dimension
+
+peft_model = AutoPeftModelForCausalLM.from_pretrained('hubnemo/llama-3.2b-metamathqa-lora64')
+
+reduce_intruder_dimension(
+ peft_model,
+ mitigation_lambda=0.75,
+)
+
+peft_model.generate(...)
+```
+
+There are a few hyper-parameters that can be used for tuning the effectiveness of the mitigation but, as evidenced in Figure 8 of the paper, it will always be a trade-off between task accuracy learned by the adapter and forgetting of the base model's knowledge. The mitigation will remove information from the adapter to reduce the impact on forgetting previous knowledge but this also means that some information about the task learned by the adapter is lost as well.
+
+While the defaults are set to deliver a good trade-off between the two factors it is not guaranteed that the defaults will hold for your adapter, your model and your data, therefore it is wise to have a benchmark ready to measure the effect.
+
+## Load adapters
+
+Adapters can be loaded onto a pretrained model with [`~PeftModel.load_adapter`], which is useful for trying out different adapters whose weights aren't merged. Set the active adapter weights with the [`~LoraModel.set_adapter`] function.
+
+```py
+from transformers import AutoModelForCausalLM
+from peft import PeftModel
+
+base_model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1")
+peft_model_id = "alignment-handbook/zephyr-7b-sft-lora"
+model = PeftModel.from_pretrained(base_model, peft_model_id)
+
+# load different adapter
+model.load_adapter("alignment-handbook/zephyr-7b-dpo-lora", adapter_name="dpo")
+
+# set adapter as active
+model.set_adapter("dpo")
+```
+
+To return the base model, you could use [`~LoraModel.unload`] to unload all of the LoRA modules or [`~LoraModel.delete_adapter`] to delete the adapter entirely. [`~LoraModel.unload`] is not an in-place operation, remember to assign the returned model to a variable and use it.
+
+```py
+# unload adapter
+model = model.unload()
+
+# delete adapter
+model.delete_adapter("dpo")
+```
+
+## Tensor Parallelism
+
+LoRA supports [Tensor Parallelism (TP)](https://huggingface.co/docs/transformers/main/en/perf_train_gpu_many#tensor-parallelism) as provided by Transformers. When a base model is loaded with a `tp_plan`, PEFT automatically detects the TP configuration of each target module and adds the appropriate hooks to the LoRA adapter weights so that they participate correctly in the tensor-parallel computation.
+
+> [!WARNING]
+> Tensor Parallelism support for LoRA requires `transformers >= 5.4.0`.
+
+Usage is identical to the standard LoRA workflow — simply load the base model with a `tp_plan` before wrapping it with PEFT:
+
+```py
+from transformers import AutoModelForCausalLM
+from peft import get_peft_model, LoraConfig
+
+model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B", tp_plan="auto")
+lora_config = LoraConfig(r=16, target_modules=["q_proj", "v_proj"])
+model = get_peft_model(model, lora_config)
+```
+
+Saving and loading work as usual via `save_pretrained` / `from_pretrained`. PEFT gathers the sharded adapter weights back to full tensors before saving, so checkpoints are portable and independent of the number of devices used during training.
+
+
+## Inference
+
+This section showcases what you can do during inference time with LoRA, such as uncoupling the adapter.
+
+### Activated LoRA (aLoRA)
+
+Activated LoRA (aLoRA) is a low rank adapter architecture for causal LMs that reuses the existing base model KV cache for more efficient inference. This approach is best suited for inference pipelines which rely on the base model for most tasks/generations, but use aLoRA adapter(s) to perform specialized task(s) within the chain. For example, checking or correcting generated outputs of the base model. In these settings, inference times can be sped up by an order of magnitude or more. For more information on aLoRA and many example use cases, see the aLoRA [paper](https://huggingface.co/papers/2504.12397).
+
+This technique scans for the last occurrence of an invocation sequence (`alora_invocation_tokens`) in each input (this can be as short as 1 token). It activates the adapter weights on tokens starting with the beginning of the invocation sequence. Any inputs after the invocation sequence are also adapted, and all generated tokens will use the adapted weights. Weights on prior tokens are left un-adapted, making the cache for those tokens interchangeable with base model cache due to the causal attention mask in causal LMs. Usage is very similar to standard LoRA. The key difference is that the invocation sequence must be specified when the adapter is created:
+
+```py
+from peft import LoraConfig
+
+config = LoraConfig(alora_invocation_tokens=alora_invocation_tokens, task_type="CAUSAL_LM", ...)
+```
+
+alora_invocation_tokens` is a list of integer token ids. Given a desired invocation string, this can be obtained as:
+```py
+invocation_string = "placeholder"
+alora_invocation_tokens = tokenizer.encode(invocation_string, add_special_tokens=False).
+```
+The tokenizer is the base model's tokenizer. Use `add_special_tokens=False` to avoid adding `SOS`/`EOS` tokens in our search string (which will most likely cause the search to fail).
+
+**Notes**
+* aLoRA is only supported for `task_type=CAUSAL_LM` tasks due to its focus on cache reuse.
+* Since the weights are adapted on fewer tokens, often (not always) aLoRA requires higher rank (`r`) than LoRA. `r=32` can be a good starting point.
+* aLoRA weights cannot be merged into the base model by definition, since the adapter weights are selectively applied to a subset of tokens. Attempts to merge will throw errors.
+* Beam search is not yet supported.
+* It is generally not recommended to add new tokens to the tokenizer that are not present in the base model. This can complicate the target use case of both the base model and adapter model operating on overlapping context. You can workaround this by adding [trainable tokens](../package_reference/trainable_tokens) to the base model prior to training the adapter.
+
+#### Choice of invocation sequence and SFT design
+
+You must add the `alora_invocation_tokens` sequence because it is not added automatically. We recommend activating the adapter weights early (at the start of any adapter-specific prompting), but after any long inputs, to maximize model performance without compromising cache reuse. As with any model,
+formatting should be consistent between train and test.
+
+Consider the following example, where the base model has a chat template,
+and the goal is to train the adapter to generate a desired output.
+
+* Option 1: If there is no task-specific prompt, i.e. the input is a chat history with the `assistant` prompt, then the chat template's `assistant` prompt (e.g. `<|start_of_role|>assistant<|end_of_role|>`) is a natural choice for the invocation string. See the model's chat template to find the prompt for the model.
+* Option 2: If there is a task-specific prompt for the adapter that describes the task the adapter is learning, and that prompt is put as a `user` turn immediately prior to the generation, then the chat template's `user` prompt (e.g. `<|start_of_role|>user<|end_of_role|>`) is a natural choice for the invocation string.
+
+After deciding on an invocation string, get the model tokenizer and obtain `alora_invocation_tokens` as
+```py
+alora_invocation_tokens = tokenizer.encode(invocation_string, add_special_tokens=False).
+```
+
+An example inference setup is at [alora finetuning](https://github.com/huggingface/peft/blob/main/examples/alora_finetuning/alora_finetuning.py).
+
+> [!NOTE]
+> If using custom strings for the invocation string, make sure that the start and end of the string are special tokens to avoid issues with tokenization at the boundaries.
+
+To see why, imagine that 'a', 'b', 'c', and 'ab' are tokens in your tokenizer (numbers 1, 2, 3, 4 respectively). Suppose that your alora_invocation_tokens = [2, 3]. Now imagine your input string is "abc". Because "ab" is a token, this will get tokenized as [4,3]. So the alora_invocation_tokens will fail to be found, despite the string "bc" being in it. If the start and end of the invocation string are special tokens, however, this failure case will never happen since special tokens are never tokenized into the same token with other characters.
+
+#### Using (and reusing) cache for generation
+The main purpose of aLoRA is to make KV cache interchangeable between the base model and aLoRA adapter models **prior to the invocation sequence** since base and adapted KV values are not compatible. Specifically, keys and values stored during one model generation can be used in subsequent generations to avoid expensive prefill operations for context tokens. When sharing cache between the base model and aLoRA adapters, there are 2 main patterns:
+1. The base model has generated something, and an aLoRA adapter is then called to do a follow-up generation. For example, the base model answers a question, and an aLoRA trained to detect hallucinations checks the base model response.
+2. An aLoRA adapter has generated something, and the base model or a different aLoRA adapter is called to do a follow-up generation where there is partial context overlap with the original aLoRA. For example, the user provides a query, and an aLoRA rewrites the query to be more self-contained and improve retrieval in a RAG system. Then, documents are retrieved and loaded into context, aLoRA checks if these documents are relevant to the question, and then the base model generates an answer.
+
+
+To demonstrate the above behaviors when using caching, we're using [DynamicCache](https://huggingface.co/docs/transformers/en/kv_cache) from `transformers`. Take care to ensure that adapted cache values are not mixed with base cache values. In particular, an extra step is required for sharing the cache when there is partial context overlap (pattern 2).
+
+**Pattern 1: Base model followed by aLoRA** Here, the entire input and generation from the base model is input into the aLoRA adapter, along with the invocation sequence:
+```
+from transformers import DynamicCache
+...
+cache = DynamicCache()
+inputs_base = tokenizer(prompt_base, return_tensors="pt")
+# Generate from base model and save cache
+with model_alora.disable_adapter():
+ output = model_alora.generate(inputs_base["input_ids"].to(device),attention_mask=inputs_base["attention_mask"].to(device),past_key_values = cache,return_dict_in_generate=True)
+output_text_base = tokenizer.decode(output.sequences[0])
+cache = output.past_key_values
+
+# Generate with aLoRA adapter from cache
+prompt_alora = output_text + INVOCATION_STRING
+inputs_alora = tokenizer(prompt_alora, return_tensors="pt").to(device)
+output = model_alora.generate(**inputs_alora, past_key_values=cache)
+output_text_alora = tokenizer.decode(output[0])
+
+# Note: cache is now tainted with adapter values and cannot be used in base model from here on!
+```
+
+**Pattern 2: aLoRA generation followed by base model (or another aLoRA) with partial context overlap** Here, we prefill the shared context using the base model, and then generate.
+
+```
+from transformers import DynamicCache
+import copy
+...
+cache = DynamicCache()
+inputs_shared = tokenizer(prompt_shared, return_tensors="pt").to(device)
+
+# Prefill from base model and save cache
+with model_alora.disable_adapter():
+ with torch.no_grad():
+ model_alora(**inputs_shared, past_key_values=cache)
+cache_copy = copy.deepcopy(cache)
+
+# Generate from aLoRA using prefilled cache
+prompt_alora = prompt_shared + INVOCATION_STRING
+inputs_alora = tokenizer(prompt_alora, return_tensors="pt").to(device)
+output = model_alora.generate(**inputs_alora, past_key_values=cache)
+output_text_alora = tokenizer.decode(output[0])
+
+# Generate from base model using saved cache not tainted by aLoRA KV values
+prompt_base = prompt_shared
+inputs_base = tokenizer(prompt_base, return_tensors="pt").to(device)
+with model_alora.disable_adapter():
+ output = model_alora.generate(**inputs_base, past_key_values=cache_copy)
+output_text_base = tokenizer.decode(output[0])
+```
+
+
+### Inference with different LoRA adapters in the same batch
+
+Normally, each inference batch has to use the same adapter(s) in PEFT. This can sometimes be annoying, because we may have batches that contain samples intended to be used with different LoRA adapters. For example, we could have a base model that works well in English and two more LoRA adapters, one for French and one for German. Usually, we would have to split our batches such that each batch only contains samples of one of the languages, we cannot combine different languages in the same batch.
+
+Thankfully, it is possible to mix different LoRA adapters in the same batch using the `adapter_name` argument. Below, we show an example of how this works in practice. First, let's load the base model, English, and the two adapters, French and German, like this:
+
+```python
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import PeftModel
+
+model_id = ...
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+model = AutoModelForCausalLM.from_pretrained(model_id)
+# load the LoRA adapter for French
+peft_model = PeftModel.from_pretrained(model, , adapter_name="adapter_fr")
+# next, load the LoRA adapter for German
+peft_model.load_adapter(, adapter_name="adapter_de")
+```
+
+Now, we want to generate text on a sample that contains all three languages: The first three samples are in English, the next three are in French, and the last three are in German. We can use the `adapter_names` argument to specify which adapter to use for each sample. Since our base model is used for English, we use the special string `"__base__"` for these samples. For the next three samples, we indicate the adapter name of the French LoRA fine-tune, in this case `"adapter_fr"`. For the last three samples, we indicate the adapter name of the German LoRA fine-tune, in this case `"adapter_de"`. This way, we can use the base model and the two adapters in a single batch.
+
+```python
+inputs = tokenizer(
+ [
+ "Hello, my dog is cute",
+ "Hello, my cat is awesome",
+ "Hello, my fish is great",
+ "Salut, mon chien est mignon",
+ "Salut, mon chat est génial",
+ "Salut, mon poisson est super",
+ "Hallo, mein Hund ist süß",
+ "Hallo, meine Katze ist toll",
+ "Hallo, mein Fisch ist großartig",
+ ],
+ return_tensors="pt",
+ padding=True,
+)
+
+adapter_names = [
+ "__base__", "__base__", "__base__",
+ "adapter_fr", "adapter_fr", "adapter_fr",
+ "adapter_de", "adapter_de", "adapter_de",
+]
+output = peft_model.generate(**inputs, adapter_names=adapter_names, max_new_tokens=20)
+```
+
+Note that the order does not matter here, i.e. the samples in the batch don't need to be grouped by adapter as in the example above. We just need to ensure that the `adapter_names` argument is aligned correctly with the samples.
+
+Additionally, the same approach also works with the `modules_to_save` feature, which allows for saving and reusing specific neural network layers, such as custom heads for classification tasks, across different LoRA adapters.
+
+#### Caveats
+
+Using this feature has some drawbacks, namely:
+
+- It only works for inference, not for training.
+- Disabling adapters using the `with model.disable_adapter()` context takes precedence over `adapter_names`.
+- You cannot pass `adapter_names` when some adapter weights were merged with base weight using the `merge_adapter` method. Please unmerge all adapters first by calling `model.unmerge_adapter()`.
+- For obvious reasons, this cannot be used after calling `merge_and_unload()`, since all the LoRA adapters will be merged into the base weights in this case.
+- This feature does not currently work with DoRA, so set `use_dora=False` in your `LoraConfig` if you want to use it.
+- The `modules_to_save` feature is currently only supported for the layers of types `Linear`, `Embedding`, `Conv2d` and `Conv1d`.
+- There is an expected overhead for inference with `adapter_names`, especially if the amount of different adapters in the batch is high. This is because the batch size is effectively reduced to the number of samples per adapter. If runtime performance is your top priority, try the following:
+ - Increase the batch size.
+ - Try to avoid having a large number of different adapters in the same batch, prefer homogeneous batches. This can be achieved by buffering samples with the same adapter and only perform inference with a small handful of different adapters.
+ - Take a look at alternative implementations such as [LoRAX](https://github.com/predibase/lorax), [punica](https://github.com/punica-ai/punica), or [S-LoRA](https://github.com/S-LoRA/S-LoRA), which are specialized to work with a large number of different adapters.
+
+
+### Composing and Reusing LoRA Adapters
+#### Arrow
+[Arrow](https://huggingface.co/papers/2405.11157) is a modular routing algorithm designed to combine multiple pre-trained task-specific LoRA adapters to solve a given task, similar to [Polytropon](poly) but without the need for fine-tuning. Rather than merging all adapters naively, Arrow introduces a **gradient-free, token-wise mixture-of-experts (MoE) routing mechanism**. At inference time, it first computes a _prototype_ for each LoRA by extracting the top right singular vector from its SVD decomposition. Each token representation is then compared to these prototypes via cosine similarity to obtain routing coefficients. Tokens are assigned to the top-k most relevant LoRA adapters, with the coefficients normalized through softmax, and their outputs linearly combined. This allows effective reuse of existing LoRA modules for new tasks and leads to stronger zero-shot generalization.
+
+In PEFT, Arrow is enabled through [`ArrowConfig]` and `create_arrow_model`. You can also configure parameters such as `top_k` (the number of LoRA adapters combined per token), `router_temperature` (the softmax temperature applied to the routing coefficients), and `rng_seed` (for reproducibility).
+
+```py
+from peft import create_arrow_model, ArrowConfig
+from transformers import AutoModelForCausalLM
+
+# Loading the model
+base_model = AutoModelForCausalLM.from_pretrained("microsoft/Phi-3-mini-4k-instruct")
+
+# Creating the Arrow config
+arrow_config = ArrowConfig(
+ top_k=3,
+ router_temperature=1.0,
+ rng_seed=42,
+)
+
+# The LoRA adapters below were trained on a clustered FLAN dataset.
+# Task clustering was performed using the Model-Based Clustering (MBC) method,
+# as described in the Arrow paper.
+# While one could train a separate LoRA for each task and let Arrow route tokens among them,
+# training LoRAs on clusters of tasks instead provides an indirect optimization for
+# transfer across the multi-task dataset.
+task_specific_adapter_paths = [
+ f"TahaBa/phi3-mini-clustered-flan/ts_expert_{i}" for i in range(10)
+ ]
+
+# Creating the Arrow model
+model = create_arrow_model(
+ base_model=base_model,
+ task_specific_adapter_paths=task_specific_adapter_paths,
+ arrow_config=arrow_config,
+ )
+
+# Now the forward path could be called on this model, like a normal PeftModel.
+```
+
+Furthermore, you can add or remove adapters after calling ```create_arrow_model```—for example, to fine-tune a new adapter or discard an unnecessary one. Once the adapters are in place, you can activate the ```"arrow_router"``` for inference to use Arrow. Note that if you add a new LoRA adapter after ```create_arrow_model``` and want to fine-tune it, you must explicitly set the new adapter as active, since ```"arrow_router"``` is activated by default in ```create_arrow_model```.
+
+```py
+from trl import SFTTrainer, SFTConfig
+
+# Adding a new adapter and activating it
+model.add_adapter(adapter_name='new_adapter')
+model.set_adapter('new_adapter')
+
+# Now the model could be trained along the `new_adapter`.
+trainer = SFTTrainer(
+ model=model,
+ args=SFTConfig(...),
+ ...
+ )
+
+# Once the training is done, you can activate `arrow_router` and use it in inference
+model.set_adapter('arrow_router') # Model is ready to be used at inference time now
+```
+
+#### GenKnowSub
+[GenKnowSub](https://aclanthology.org/2025.acl-short.54/) augments Arrow by purifying task-specific LoRA adapters before routing. The key idea is to subtract general knowledge encoded in LoRA space—based on the [forgetting-via-negation principle](https://huggingface.co/papers/2212.04089)—so that task adapters become more isolated and focused on task-relevant signals. Concretely, GenKnowSub estimates a low-dimensional “general” subspace from a set of general (non task-specific) LoRA adapters and removes this component from each task adapter’s LoRA update prior to Arrow’s token-wise routing. This typically improves compositionality and reduces interference when combining many task adapters.
+
+In PEFT, enable GenKnowSub by setting ```use_gks=True``` in ArrowConfig, and providing ```general_adapter_paths``` in ```create_arrow_model```:
+
+```py
+from peft import create_arrow_model, ArrowConfig
+from transformers import AutoModelForCausalLM
+
+# Loading the model
+base_model = AutoModelForCausalLM.from_pretrained("microsoft/Phi-3-mini-4k-instruct")
+
+# Creating the Arrow config
+arrow_config = ArrowConfig(
+ top_k=3,
+ router_temperature=1.0,
+ use_gks=True,
+ rng_seed=42,
+)
+
+# Path to task-specific, trained on flan clustered dataset (as we explained before.)
+task_specific_adapter_paths = [
+ f"TahaBa/phi3-mini-clustered-flan/ts_expert_{i}" for i in range(10)
+ ]
+# These general adapters are trained on English, German, and French Wikipedia dataset,
+# with causal language modelling objective, each pair like: (507 token tsentence, 5 token completion), and the loss computed on the completion
+general_adapter_paths = [
+ "TahaBa/phi3-mini-general-adapters/cluster0_batch16_prop1.0_langen/checkpoint-17",
+ "TahaBa/phi3-mini-general-adapters/cluster0_batch16_prop1.0_langfr/checkpoint-35",
+ "TahaBa/phi3-mini-general-adapters/cluster0_batch16_prop1.0_langger/checkpoint-17"
+ ]
+
+# Creating the Arrow model
+model = create_arrow_model(
+ base_model=base_model,
+ task_specific_adapter_paths=task_specific_adapter_paths,
+ general_adapter_paths=general_adapter_paths,
+ arrow_config=arrow_config,
+ )
+
+# Now the forward path could be called on this model, like a normal PeftModel.
+```
+To encode general knowledge, GenKnowSub subtracts the average of the provided general adapters from each task-specific adapter once, before routing begins. Furthermore, the ability to add or remove adapters after calling ```create_arrow_model``` (as described in the Arrow section) is still supported in this case.
+
+> [!TIP]
+> **Things to keep in mind when using Arrow + GenKnowSub:**
+>
+> - All LoRA adapters (task-specific and general) must share the same ```rank``` and ```target_modules```.
+>
+> - Any inconsistency in these settings will raise an error in ```create_arrow_model```.
+>
+> - Having different scaling factors (```lora_alpha```) across task adapters is supported — Arrow handles them automatically.
+>
+> - Merging the ```"arrow_router"``` is not supported, due to its dynamic routing behavior.
+>
+> - In create_arrow_model, task adapters are loaded as ```task_i``` and general adapters as ```gks_j``` (where ```i``` and ```j``` are indices). The function ensures consistency of ```target_modules```, ```rank```, and whether adapters are applied to ```Linear``` or ```Linear4bit``` layers. It then adds the ```"arrow_router"``` module and activates it. Any customization of this process requires overriding ```create_arrow_model```.
+>
+> - This implementation is compatible with 4-bit quantization (via bitsandbytes):
+>
+> ```py
+> from transformers import AutoModelForCausalLM, BitsAndBytesConfig
+> import torch
+>
+> # Quantisation config
+> bnb_config = BitsAndBytesConfig(
+> load_in_4bit=True,
+> bnb_4bit_quant_type="nf4",
+> bnb_4bit_compute_dtype=torch.bfloat16,
+> bnb_4bit_use_double_quant=False,
+> )
+>
+> # Loading the model
+> base_model = AutoModelForCausalLM.from_pretrained(
+> "microsoft/Phi-3-mini-4k-instruct",
+> dtype=torch.bfloat16,
+> device_map="auto",
+> quantization_config=bnb_config,
+> )
+>
+> # Now call create_arrow_model() as we explained before.
+> ```
+
+# API
+
+## LoraConfig
+
+[[autodoc]] tuners.lora.config.LoraConfig
+
+## LoraModel
+
+[[autodoc]] tuners.lora.model.LoraModel
+
+
+## Utility
+
+### ArrowConfig
+
+[[autodoc]] tuners.lora.config.ArrowConfig
+
+### LoftQ
+
+[[autodoc]] utils.loftq_utils.replace_lora_weights_loftq
+
+
+### Eva
+
+#### EvaConfig
+
+[[autodoc]] tuners.lora.config.EvaConfig
+
+#### initialize_lora_eva_weights
+
+[[autodoc]] tuners.lora.eva.initialize_lora_eva_weights
+
+#### get_eva_state_dict
+
+[[autodoc]] tuners.lora.eva.get_eva_state_dict
+
+
+### LoraGAConfig
+
+[[autodoc]] tuners.lora.config.LoraGAConfig
+
+#### Utilities
+
+[[autodoc]] tuners.lora.loraga.estimate_gradients
+
+[[autodoc]] tuners.lora.loraga.preprocess_loraga
+
+
+## Intruder Dimension Reduction
+
+[[autodoc]] tuners.lora.intruders.reduce_intruder_dimension
+
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora_conversion.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora_conversion.md
new file mode 100644
index 0000000000000000000000000000000000000000..a023db58fe52edf61bd06ce22072e830ca0584fa
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora_conversion.md
@@ -0,0 +1,155 @@
+
+
+# LoRA conversion
+
+Functions that allow to convert non-LoRA PEFT models to LoRA models.
+
+## Description
+
+PEFT supports dozens of different parameter effficient fine-tuning techniques. The most popular one by far is LoRA. This means that many other packages support LoRA too. For example, [Diffusers](https://huggingface.co/docs/diffusers/main/en/api/loaders/lora) allows to load LoRA adapters to change the capabilities of diffusion models. [vLLM](https://docs.vllm.ai/en/stable/features/lora/) allows serving models with LoRA adapters. This is nice but unfortunately, all the other, non-LoRA PEFT methods are rarely supported. Therefore, even if another PEFT method would work better for your specific use case, you may be prevented from using it because downstream packages offer no support.
+
+Here we present a potential solution. PEFT offers two functions, [`save_as_lora`] and [`convert_to_lora`], which allow to convert a PEFT adapter into a LoRA adapter. Not all PEFT methods support this for now, but if they do, it means you can start with the PEFT method that works best for you and then later use it as if it were a LoRA adapter.
+
+## Example
+
+The LoRA rank for the converted adapter can either be set to a fixed rank by passing an int > 0 to the `rank` argument, or a dynamic rank, which adapts to each layer, by passing a float between 0 and 1 to the `rank` argument. Dynamic ranks can potentially be more efficient (same performance with fewer parameters).
+
+### Fixed LoRA rank
+
+The usage of [`save_as_lora`] is relatively straightforward:
+
+```python
+from peft import get_peft_model, save_as_lora
+
+# first load and train your non-LoRA PEFT model as normal
+base_model = ...
+non_lora_config = ...
+model = get_peft_model(base_model, non_lora_config)
+# check that this PEFT method can indeed be converted to LoRA
+assert model.supports_lora_conversion()
+... # train the model
+
+# the rank of the LoRA adapter that you want to convert to
+target_rank = 64
+# save as a LoRA checkpoint
+save_as_lora(output_path, model, rank=target_rank)
+```
+
+This will create a LoRA checkpoint at `output_path` that you can load like any other LoRA adapter, or use in downstream packages such as Diffusers or vLLM.
+
+The [`convert_to_lora`] function is useful if you don't want to save the converted LoRA adapter but instead want to use the converted weights right away, for example to perform evaluations:
+
+```python
+from peft import convert_to_lora, get_peft_model, set_peft_model_state_dict
+
+base_model = ...
+non_lora_config = ...
+model = get_peft_model(base_model, non_lora_config)
+... # train the model
+
+# get the lora config and state dict of the converted lora model
+lora_config, lora_state_dict = convert_to_lora(model, rank=target_rank)
+# reload the base model, or use model.unload()
+base_model = ...
+# apply the lora config to the base model
+lora_model = get_peft_model(base_model, lora_config)
+# load the LoRA weights onto the base model
+set_peft_model_state_dict(lora_model, state_dict)
+```
+
+### Dynamic LoRA rank
+
+In the examples above, we used a fixed LoRA rank for conversion. However, it is conceivable that some layers don't require a high rank to be accurately converted, while other layers require a higher rank. To accommodate this, PEFT offers the option to pass a float between 0 and 1 as the `rank` argument. Let's say you pass `rank=0.5`. This means that for each layer, the rank for the LoRA adapter is chosen such that the LoRA adapter explains 50% of the variance in weight introduced by original adapter. In more technical terms, under the hood we perform a [Singular Value Decomposition](https://en.wikipedia.org/wiki/Singular_value_decomposition) on the weight contribution of the adapter and then take the top singular values that, when normalized, sum up to the passed value.
+
+```python
+# set a dynamic rank by passing a float
+threshold = 0.7
+# save as a LoRA checkpoint
+save_as_lora(output_path, model, rank=threshold)
+# get the lora config and state dict directly:
+lora_config, lora_state_dict = convert_to_lora(model, rank=threshold)
+# inspect the different ranks per layer:
+print(lora_config.rank_pattern)
+```
+
+Using this type of dynamic LoRA rank can be useful if the contribution of the different layers varies a lot. The disadvantage is that it could mean that some layers will have a very high LoRA rank, which can lead to memory spikes. Please test what works best for your use case.
+
+### Compiling the model
+
+For large models, doing the conversion may take some time; for instance each PEFT module has to go through an SVD computation. By passing `compile_kwargs` to [`save_as_lora`] or [`convert_to_lora`], you can apply [`torch.compile`](https://docs.pytorch.org/docs/stable/generated/torch.compile.html) to the conversion function and potentially speed up the process. The `compile_kwargs` are a dict of keyword arguments that are passed to `torch.compile` (empty dict also works). Below is an example:
+
+```python
+compile_kwargs = {"dynamic": True, "mode": "max-autotune-no-cudagraphs", "fullgraph": True}
+save_as_lora(output_path, model, rank=rank, compile_kwargs=compile_kwargs)
+```
+
+### LoRA to LoRA conversion
+
+It is also possible to convert a LoRA adapter into another LoRA adapter. Why would you want to do that? There is one reason, namely if you want to reduce the rank of the LoRA adapter. If, after training, you want to shrink the LoRA adapter, use [`save_as_lora`] or [`convert_to_lora`] and pass a smaller rank. This will give you a new LoRA adapter that has a smaller memory and storage footprint.
+
+## Metrics
+
+### Non-LoRA to LoRA conversion
+
+Of course, converting one PEFT adapter into another adapter is a lossy process. The new adapter will most likely not perform as well as the initial adapter. Therefore, it is highly advised to **evaluate the converted LoRA adapter**. This way, you can make sure that the converted adapter performs well enough for your use case. The general rule applies that the higher the rank of the LoRA adapter, the better it will approximate your initial adapter. This means that the converted LoRA adapter may require more parameters than the original adapter to achieve a similar performanace.
+
+To give an example, here are some numbers that were derived on the [PEFT MetaMathQA benchmark](https://github.com/huggingface/peft/tree/main/method_comparison/MetaMathQA). For this, a [LoHa](https://huggingface.co/docs/peft/package_reference/loha) adapter was used to fine-tune `meta-llama/Llama-3.2-3B` on MetaMathQA and evaluated on GSM8K. The initial LoKr adapter had rank 32, resulting in 18,350,080 trainable parameters and a test accuracy of 41.85%. Evaluation required 12.25 GB of memory. The checkpoint was converted into LoRA with different values for the `rank`. The resulting outcome is:
+
+| rank | trainable parameters | test accuracy (%) | accuracy change | memory reserved (max, GB) | memory increase |
+|------|---------------------:|------------------:|----------------:|--------------------------:|----------------:|
+| 8 | 2293760 | 37.60 | -4.25 | 12.41 | 0.16 |
+| 16 | 4587520 | 38.89 | -2.96 | 12.15 | -0.10 |
+| 32 | 9175040 | 40.11 | -1.74 | 12.41 | 0.16 |
+| 64 | 18350080 | 39.20 | -2.65 | 12.18 | -0.07 |
+| | | | | | |
+| 0.4 | 2428928 | 37.60 | -4.25 | 12.41 | 0.16 |
+| 0.5 | 4761600 | 40.18 | -1.67 | 12.41 | 0.16 |
+| 0.6 | 8857600 | 39.42 | -2.43 | 12.41 | 0.16 |
+| 0.7 | 16230400 | 39.04 | -2.81 | 12.15 | -0.10 |
+
+As you can see, we can attain a test accuracy that comes close to the original LoHa adapter if the rank is sufficiently high. Choosing the right rank is a tradeoff between model performance and model efficiency. To reproduce this experiment, follow the script at https://github.com/huggingface/peft/tree/main/scripts/evaluate-lora-conversion.py.
+
+Note that the number of trainable parameters cannot be translated one to one into memory usage. Some PEFT methods require more, some less memory, even with the same number of trainable parameters. Therefore, even if after conversion, the LoRA adapter has more parameters than the original one, it could still be more memory efficient when serving.
+
+### LoRA to LoRA conversion
+
+Similar to the experiment above, we can also evaluate LoRA to LoRA conversion (i.e. LoRA compression). Here, we start with a LoRA adapter of rank 64 trained on the same setup as above with RS-LoRA. The initial adapter has 18,350,080 trainable parameters, a test accuracy of 52.92%, and requires 12.58 GB of memory for evaluation. The following table shows the results of converting this adapter to LoRA adapters of smaller rank:
+
+| rank | trainable parameters | test accuracy (%) | accuracy change | memory reserved (max, GB) | memory increase |
+|------|---------------------:|------------------:|----------------:|--------------------------:|----------------:|
+| 8 | 2293760 | 43.37 | -9.55 | 12.38 | -0.20 |
+| 16 | 4587520 | 48.90 | -4.02 | 12.38 | -0.20 |
+| 32 | 9175040 | 51.48 | -1.44 | 12.49 | -0.09 |
+| 48 | 13762560 | 52.01 | -0.91 | 12.38 | -0.20 |
+| | | | | | |
+| 0.5 | 2150400 | 44.12 | -8.80 | 12.37 | -0.21 |
+| 0.6 | 3082240 | 47.54 | -5.38 | 12.37 | -0.21 |
+| 0.7 | 4448256 | 50.49 | -2.43 | 12.37 | -0.21 |
+| 0.8 | 6510592 | 50.11 | -2.81 | 12.37 | -0.21 |
+| 0.9 | 10022912 | 51.55 | -1.37 | 12.38 | -0.20 |
+| 0.95 | 12976128 | 52.62 | -0.30 | 12.39 | -0.19 |
+
+So for instance for rank 0.95, we can close the accuracy gap to just 0.3 percentage points while reducing the number of parameters by 30%. Also note that these compressed LoRAs can be better than directly training them on the lower rank -- e.g. for rank 32, training directly results in a test accuracy of 48.22%, while conversion from rank 64 results in 51.48%.
+
+## Caveats
+
+There are some limitations to the LoRA conversion. As mentioned above, a reduction in performance is expected and the converted LoRA will most likely be less parameter efficient than the original adapter. Moreover, LoRA conversion has these limitations:
+
+- Right now, only adapters applied to linear layers can be converted.
+- Not all PEFT methods currently support LoRA conversion.
+
+If there is a lot of demand to extend LoRA conversion, please let us know by creating a [GitHub discussion](https://github.com/huggingface/peft/discussions) and we will make it work with more layer types and PEFT methods.
+
+## API
+
+### Convert a non-LoRA model to a LoRA model, return the `LoraConfig` and `state_dict`
+
+[[autodoc]] tuners.lora.conversion.convert_to_lora
+ - all
+
+### Convert a non-LoRA model to a LoRA model, save the adapter checkpoint and config at the given path
+
+[[autodoc]] tuners.lora.conversion.save_as_lora
+ - all
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora_variant_bdlora.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora_variant_bdlora.md
new file mode 100644
index 0000000000000000000000000000000000000000..56fbc9a96b096939d13e9b705722a68e41c801fb
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora_variant_bdlora.md
@@ -0,0 +1,20 @@
+# Block-Diagonal LoRA for Eliminating Communication Overhead in Tensor Parallel LoRA Serving
+
+Block-Diagonal LoRA (BD-LoRA) is a LoRA variant in which some LoRA factors are constrained to be block-diagonal. This allows faster serving by eliminating communication overheads
+when running inference on multiple GPUs. Despite the block-diagonal constraint, BD-LoRA is similarly performant to vanilla LoRA at similar parameter counts.
+
+BD-LoRA is designed to be used with tensor parallelism, which means sharding the weights of a model among multiple GPUs. A popular sharding strategy is the [Megatron Sharding Strategy](https://arxiv.org/abs/1909.08053). For two linear layers $W_1$, $W_2$ that follow each other (for example the up and down projections in a transformer MLP module), we will shard the first layer in a column-parallel way (which requires LoRA B to be block-diagonal) and the second layer in a row-parallel way (which requires LoRA A to be block-diagonal). For the attention module, this can be similarly achieved by taking the Q, K and V projections together as $W_1$ and the out projection as $W_2$, sharding accordingly. This sharding allows a compatible inference engine to distribute each block-diagonal shard over a a different GPU, cutting the need to communicate partial results among GPUs. In the image below, you can see the exact sharding strategy and how this saves computational efforts.
+
+Paper: https://hf.co/papers/2510.23346
+
+
+
+
+
+### Performance, rank and parameter count
+BD-LoRA achieves similar performance to LoRA (see image below, or the `method_comparison` folder in the peft repository root) at the same parameter count. However, as every other factor in BD-LoRA is block-diagonal, a BD-LoRA adapter will have less parameters than a LoRA adapter at the same rank. The performance of BD-LoRA is only competitive when the rank is then increased accordingly. We provide example code for rank-matching at the end of this example notebook.
+
+
+
+
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora_variant_dora.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora_variant_dora.md
new file mode 100644
index 0000000000000000000000000000000000000000..c4a99c4919530add6b3eb12e700e435d30d42e9d
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora_variant_dora.md
@@ -0,0 +1,83 @@
+
+
+# Weight-Decomposed Low-Rank Adaptation (DoRA)
+
+> [!NOTE]
+> This is a variant of LoRA and therefore everything that is possible with LoRA is valid for this method except otherwise stated on this page.
+
+This technique decomposes the updates of the weights into two parts, magnitude and direction. Direction is handled by normal LoRA, whereas the magnitude is handled by a separate learnable parameter. This can improve the performance of LoRA, especially at low ranks. For more information on DoRA, see https://huggingface.co/papers/2402.09353.
+
+```py
+from peft import LoraConfig
+
+config = LoraConfig(use_dora=True, ...)
+```
+
+If parts of the model or the DoRA adapter are offloaded to CPU you can get a significant speedup at the cost of some temporary (ephemeral) VRAM overhead by using `ephemeral_gpu_offload=True` in `config.runtime_config`.
+
+```py
+from peft import LoraConfig, LoraRuntimeConfig
+
+config = LoraConfig(use_dora=True, runtime_config=LoraRuntimeConfig(ephemeral_gpu_offload=True), ...)
+```
+
+A `PeftModel` with a DoRA adapter can also be loaded with `ephemeral_gpu_offload=True` flag using the `from_pretrained` method as well as the `load_adapter` method.
+
+```py
+from peft import PeftModel
+
+model = PeftModel.from_pretrained(base_model, peft_model_id, ephemeral_gpu_offload=True)
+```
+
+## Optimization
+
+DoRA is optimized (computes faster and takes less memory) for models in the evaluation mode, or when dropout is set to 0. We reuse the
+base result at those times to get the speedup.
+Running [dora finetuning](https://github.com/huggingface/peft/blob/main/examples/dora_finetuning/dora_finetuning.py)
+with `CUDA_VISIBLE_DEVICES=0 ZE_AFFINITY_MASK=0 time python examples/dora_finetuning/dora_finetuning.py --quantize --lora_dropout 0 --batch_size 16 --eval_step 2 --use_dora` on a 4090 with gradient accumulation set to 2 and max step to 20 resulted with the following observations:
+
+| | Without Optimization | With Optimization |
+| :--: | :--: | :--: |
+| train runtime (sec) | 359.7298 | **279.2676** |
+| train samples per second | 1.779 | **2.292** |
+| train steps per second | 0.056 | **0.072** |
+
+Moreover, it is possible to further increase runtime performance of DoRA by using the [`DoraCaching`] helper context. This requires the model to be in `eval` mode:
+
+```py
+from peft.helpers import DoraCaching
+
+model.eval()
+with DoraCaching():
+ output = model(inputs)
+```
+
+For [`meta-llama/Llama-3.1-8B`](https://huggingface.co/meta-llama/Llama-3.1-8B), the [DoRA caching benchmark script](https://github.com/huggingface/peft/blob/main/examples/dora_finetuning/dora-caching.py) shows that, compared to LoRA:
+
+- DoRA without caching requires 139% more time
+- DoRA without caching requires 4% more memory
+- DoRA with caching requires 17% more time
+- DoRA with caching requires 41% more memory
+
+Caching can thus make inference with DoRA significantly faster but it also requires significantly more memory. Ideally, if the use case allows it, just merge the DoRA adapter to avoid both memory and runtime overhead.
+
+## Caveats
+
+- DoRA only supports embedding, linear, and Conv2d layers at the moment.
+- DoRA introduces a bigger overhead than pure LoRA, so it is recommended to merge weights for inference, see [`LoraModel.merge_and_unload`].
+- DoRA should work with weights quantized with bitsandbytes ("QDoRA"). However, issues have been reported when using QDoRA with DeepSpeed Zero2.
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora_variant_monteclora.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora_variant_monteclora.md
new file mode 100644
index 0000000000000000000000000000000000000000..2afb52d66e554b7b4f4ded52d75e160f1211d7bb
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora_variant_monteclora.md
@@ -0,0 +1,54 @@
+# MonteCLoRA (Monte Carlo Low-Rank Adaptation)
+
+> [!NOTE]
+> This is a variant of LoRA and therefore everything that is possible with LoRA is valid for this method except otherwise stated on this page.
+
+MonteCLoRA wraps a standard LoRA adapter with a small variational module that draws Monte Carlo samples of stochastic perturbations on top of the LoRA `A` matrix during training. Concretely, it learns variational parameters (a Wishart-based covariance, a per-sample multivariate-normal noise term, and a Dirichlet weighting over the samples) and adds the resulting averaged perturbation to `lora_A` at every forward pass. A KL-divergence + entropy term is added to the training loss to keep these variational parameters anchored to a sensible prior. At inference time the sampler is disabled and MonteCLoRA behaves exactly like a regular LoRA adapter, so there is **no extra inference cost or extra parameters to merge**. For the full method see https://huggingface.co/papers/2411.04358.
+
+You may want to consider MonteCLoRA when:
+
+- You are fine-tuning on a small or noisy dataset and want stronger regularization than vanilla LoRA. The Monte Carlo averaging and the KL term together act as a Bayesian-style regularizer.
+- You want better uncertainty calibration / robustness from your adapter without paying extra cost at inference time (the variational machinery is training-only).
+- Vanilla LoRA is overfitting and lowering `r` or increasing `lora_dropout` is not enough.
+
+You probably do *not* need MonteCLoRA when you have a large, clean dataset and vanilla LoRA already trains stably — in that regime the extra variational parameters mostly add training overhead without much benefit.
+
+To enable MonteCLoRA, pass a `MontecloraConfig` to `LoraConfig`:
+
+```py
+from peft import LoraConfig, MontecloraConfig
+
+monteclora_config = MontecloraConfig(
+ num_samples=8, # number of Monte Carlo samples per forward pass
+ sample_scaler=1e-4, # magnitude of the variational perturbation
+ kl_loss_weight=1e-5, # weight of the KL term added to the training loss
+)
+config = LoraConfig(
+ r=16,
+ lora_alpha=32,
+ target_modules=["q_proj", "v_proj"],
+ monteclora_config=monteclora_config,
+)
+```
+
+During training you must add the variational regularization loss to the task loss. The simplest way is to call [`LoraModel._get_monteclora_loss`] on the underlying `LoraModel`:
+
+```py
+task_loss = ... # standard loss returned by your model
+monteclora_loss = model._get_monteclora_loss() # 0.0 if MonteCLoRA is not used
+total_loss = task_loss + monteclora_loss
+total_loss.backward()
+```
+
+If you train with the HF `Trainer`, you can simply mix in [`peft.helpers.MontecloraTrainerMixin`] which does this for you in `compute_loss`:
+
+```py
+from transformers import Trainer
+from peft.helpers import MontecloraTrainerMixin
+
+
+class MontecloraTrainer(MontecloraTrainerMixin, Trainer):
+ pass
+```
+
+A complete working example is available at [`examples/monteclora_finetuning`](https://github.com/huggingface/peft/tree/main/examples/monteclora_finetuning).
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora_variant_velora.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora_variant_velora.md
new file mode 100644
index 0000000000000000000000000000000000000000..c9d55789b90ee0cbee6b9df75e287dcd49af0341
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/lora_variant_velora.md
@@ -0,0 +1,52 @@
+
+
+### VeLoRA
+
+> [!NOTE]
+> This is a variant of LoRA and therefore everything that is possible with LoRA is valid for this method except otherwise stated on this page.
+
+[VeLoRA](https://huggingface.co/papers/2405.17991) is a LoRA variant that reduces training memory by compressing the activations saved for the LoRA in the forward pass and then reconstructing them in the backwards pass to implement the update rules. In PEFT, VeLoRA is configured as a LoRA variant through the `velora_config` argument on [`LoraConfig`].
+
+```py
+from peft import LoraConfig, VeloraConfig
+
+config = LoraConfig(
+ target_modules=["q_proj", "v_proj"],
+ velora_config=VeloraConfig(
+ num_groups=64,
+ scale=0.2,
+ init_type="batch_average",
+ ),
+)
+```
+
+VeLoRA is applied to every LoRA layer selected by `target_modules`. `num_groups` controls how the input activation depth is split before compression. If the activation depth is not evenly divisible by `num_groups`, VeLoRA pads the grouped representation internally and removes the padding after reconstruction. `scale` rescales the reconstructed activations during the backward pass, and `init_type` chooses how the projection is initialized.
+
+Use `batch_average_once` to initialize the projection from the first training batch, `batch_average` to update it from every training forward pass, or `random` to initialize it immediately from a random normalized vector.
+
+Below are some results with the [MetaMathQA benchmark](https://github.com/huggingface/peft/tree/main/method_comparison/MetaMathQA).
+
+| Variant | Training Loss | Max Memory (GiB) | Tokens/sec |
+|---|---:|---:|---:|
+| LoRA | 0.5427 | 27.69 | 2366.2 |
+| LoRA + GC | 0.5426 | 13.17 | 1671.8 |
+| LoRA+VeLoRA | 0.5427 | 19.94 | 2057.6 |
+
+#### Caveats
+
+- VeLoRA is currently supported on standard LoRA linear layers only.
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/merge_utils.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/merge_utils.md
new file mode 100644
index 0000000000000000000000000000000000000000..e5746127dc5cb61fe9e0c804b0956ff7e3792106
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/merge_utils.md
@@ -0,0 +1,33 @@
+
+
+# Model merge
+
+PEFT provides several internal utilities for [merging LoRA adapters](../developer_guides/model_merging) with the TIES and DARE methods.
+
+[[autodoc]] utils.merge_utils.prune
+
+[[autodoc]] utils.merge_utils.calculate_majority_sign_mask
+
+[[autodoc]] utils.merge_utils.disjoint_merge
+
+[[autodoc]] utils.merge_utils.task_arithmetic
+
+[[autodoc]] utils.merge_utils.ties
+
+[[autodoc]] utils.merge_utils.dare_linear
+
+[[autodoc]] utils.merge_utils.dare_ties
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/miss.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/miss.md
new file mode 100644
index 0000000000000000000000000000000000000000..c2c321fc48d8edd854f91609b983ac0575c33b02
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/miss.md
@@ -0,0 +1,102 @@
+
+
+# MiSS
+
+[MiSS (Matrix Shard Sharing)](https://arxiv.org/abs/2409.15371) is a PEFT method that achieves a good balance between model performance and computational efficiency. It requires only a single trainable matrix and introduces a shard-sharing mechanism distinct from LoRA.
+
+The abstract from the paper is:
+
+*Parameter-Efficient Fine-Tuning (PEFT) methods, particularly Low-Rank Adaptation (LoRA), effectively reduce the number of trainable parameters in Large Language Models (LLMs). However, as model scales continue to grow, the demand for computational resources remains a significant challenge. Existing LoRA variants often struggle to strike an optimal balance between adaptability (model performance and convergence speed) and efficiency (computational overhead, memory usage, and initialization time). This paper introduces MiSS (Matrix Shard Sharing), a novel PEFT approach that addresses this trade-off through a simple shard-sharing mechanism. MiSS leverages the insight that a low-rank adaptation can be achieved by decomposing the weight matrix into multiple fragment matrices and utilizing a shared, trainable common fragment. This method constructs the low-rank update matrix through the replication of these shared, partitioned shards. We also propose a hardware-efficient and broadly applicable implementation for MiSS. Extensive experiments conducted on a range of tasks, alongside a systematic analysis of computational performance, demonstrate MiSS's superiority. The results show that MiSS significantly outperforms standard LoRA and its prominent variants in both model performance metrics and computational efficiency, including initialization speed and training throughput. By effectively balancing expressive power and resource utilization, MiSS offers a compelling solution for efficiently adapting large-scale models.*
+
+## Benchmark overview
+
+
+
+## When to use MiSS
+
+MiSS is a good choice when:
+
+- You want faster initialization and higher training throughput than advanced LoRA initialization schemes that use expensive setups (such as PiSSA, LoRA-GA, or OLoRA).
+- You want a drop-in alternative to LoRA with minimal configuration changes.
+
+If you need stronger expressiveness at the cost of some efficiency, consider the `bat` initialization variant (see below).
+
+## init_weights modes
+
+MiSS supports three initialization modes via the `init_weights` parameter:
+
+- `True` (default): Standard MiSS initialization. Best starting point for most use cases.
+- `"bat"`: Enables nonlinear updates across different shards. Produces better results than standard MiSS but uses more memory and is approximately twice as slow. Use this when performance is the priority over efficiency.
+- `"mini"`: Uses a smaller rank along the `out_features` dimension, controlled by `mini_r`. This reduces trainable parameters further. When using this mode, `mini_r` must be set and `out_features` must be divisible by `mini_r`.
+
+## Quick start
+
+```python
+import torch
+from peft import MissConfig, get_peft_model
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model = AutoModelForCausalLM.from_pretrained(
+ "meta-llama/Llama-2-7b-hf",
+ torch_dtype=torch.bfloat16,
+ device_map="auto"
+)
+tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
+tokenizer.pad_token_id = tokenizer.eos_token_id
+
+# Standard MiSS
+config = MissConfig(
+ r=64,
+ miss_dropout=0.01,
+ task_type="CAUSAL_LM"
+)
+
+# BAT variant — better performance, more memory
+# config = MissConfig(
+# r=64,
+# init_weights="bat",
+# task_type="CAUSAL_LM"
+# )
+
+# Mini variant — fewer trainable parameters
+# config = MissConfig(
+# r=64,
+# init_weights="mini",
+# mini_r=8,
+# task_type="CAUSAL_LM"
+# )
+
+model = get_peft_model(model, config)
+model.print_trainable_parameters()
+```
+
+For a full fine-tuning example including training and inference, see the [MiSS fine-tuning example](https://github.com/huggingface/peft/tree/main/examples/miss_finetuning).
+
+# API
+
+## MissConfig
+
+[[autodoc]] tuners.miss.config.MissConfig
+
+## MissModel
+
+[[autodoc]] tuners.miss.model.MissModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/multitask_prompt_tuning.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/multitask_prompt_tuning.md
new file mode 100644
index 0000000000000000000000000000000000000000..ad5efa9103681c33a45d1bf48e15770c5edf700f
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/multitask_prompt_tuning.md
@@ -0,0 +1,55 @@
+
+
+# Multitask prompt tuning
+
+[Multitask prompt tuning](https://huggingface.co/papers/2303.02861) decomposes the soft prompts of each task into a single learned transferable prompt instead of a separate prompt for each task. The single learned prompt can be adapted for each task by multiplicative low rank updates.
+
+The abstract from the paper is:
+
+*Prompt tuning, in which a base pretrained model is adapted to each task via conditioning on learned prompt vectors, has emerged as a promising approach for efficiently adapting large language models to multiple downstream tasks. However, existing methods typically learn soft prompt vectors from scratch, and it has not been clear how to exploit the rich cross-task knowledge with prompt vectors in a multitask learning setting. We propose multitask prompt tuning (MPT), which first learns a single transferable prompt by distilling knowledge from multiple task-specific source prompts. We then learn multiplicative low rank updates to this shared prompt to efficiently adapt it to each downstream target task. Extensive experiments on 23 NLP datasets demonstrate that our proposed approach outperforms the state-of-the-art methods, including the full finetuning baseline in some cases, despite only tuning 0.035% as many task-specific parameters*.
+
+
+
+
+Multitask prompt tuning enables parameter-efficient transfer learning.
+
+MPT consists of two stages:
+
+1. source training - for each task, its soft prompt is decomposed into task-specific vectors. The task-specific vectors are multiplied together to form another matrix W, and the Hadamard product is used between W and a shared prompt matrix P to generate a task-specific prompt matrix. The task-specific prompts are distilled into a single prompt matrix that is shared across all tasks. This prompt is trained with multitask training.
+2. target adaptation - to adapt the single prompt for a target task, a target prompt is initialized and expressed as the Hadamard product of the shared prompt matrix and the task-specific low-rank prompt matrix.
+
+
+
+
+Prompt decomposition.
+
+## Benchmark overview
+
+There is no benchmark for this method yet. Feel free to contribute an experiment
+configuration but make sure to first create an issue
+[here](https://github.com/huggingface/peft/issues).
+
+
+# API
+
+## MultitaskPromptTuningConfig
+
+[[autodoc]] tuners.multitask_prompt_tuning.config.MultitaskPromptTuningConfig
+
+## MultitaskPromptEmbedding
+
+[[autodoc]] tuners.multitask_prompt_tuning.model.MultitaskPromptEmbedding
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/oft.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/oft.md
new file mode 100644
index 0000000000000000000000000000000000000000..fcf3ee905083a9c9e4f37ab2a3dcdccfc70ec811
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/oft.md
@@ -0,0 +1,98 @@
+
+
+# OFT
+
+
+
+
+Controlling Text-to-Image Diffusion by Orthogonal Finetuning
+
+[Orthogonal Finetuning (OFT)](https://hf.co/papers/2306.07280) and [OFTv2](https://huggingface.co/papers/2506.19847) is a method developed for adapting text-to-image diffusion models. It works by reparameterizing the pretrained weight matrices with its orthogonal matrix to preserve information in the pretrained model. To reduce the number of parameters, OFT introduces a block-diagonal structure in the orthogonal matrix. The method primarily focuses on preserving a pretrained model's generative performance in the finetuned model. It tries to maintain the same cosine similarity ([hyperspherical energy](https://huggingface.co/papers/1805.09298)) between all pairwise neurons in a layer because this better captures the semantic information among neurons. This means OFT is more capable at preserving the subject and it is better for controllable generation (similar to [ControlNet](https://huggingface.co/docs/diffusers/using-diffusers/controlnet)).
+
+The abstract from the paper is:
+
+*Large text-to-image diffusion models have impressive capabilities in generating photorealistic images from text prompts. How to effectively guide or control these powerful models to perform different downstream tasks becomes an important open problem. To tackle this challenge, we introduce a principled finetuning method -- Orthogonal Finetuning (OFT), for adapting text-to-image diffusion models to downstream tasks. Unlike existing methods, OFT can provably preserve hyperspherical energy which characterizes the pairwise neuron relationship on the unit hypersphere. We find that this property is crucial for preserving the semantic generation ability of text-to-image diffusion models. To improve finetuning stability, we further propose Constrained Orthogonal Finetuning (COFT) which imposes an additional radius constraint to the hypersphere. Specifically, we consider two important finetuning text-to-image tasks: subject-driven generation where the goal is to generate subject-specific images given a few images of a subject and a text prompt, and controllable generation where the goal is to enable the model to take in additional control signals. We empirically show that our OFT framework outperforms existing methods in generation quality and convergence speed*.
+
+OFT preserves the hyperspherical energy by learning an orthogonal transformation for neurons to keep the cosine similarity between them unchanged, potentially leading to less forgetting of previous learnt knowledge. In practice, this means taking the matrix product of an orthogonal matrix with the pretrained weight matrix. However, to be parameter-efficient, the orthogonal matrix is represented as a block-diagonal matrix with rank `r` blocks. Whereas LoRA reduces the number of trainable parameters with low-rank structures, OFT reduces the number of trainable parameters with a sparse block-diagonal matrix structure.
+
+## Benchmark overview
+
+
+
+## Merge OFT weights into the base model
+
+Similar to LoRA, the weights learned by OFT can be integrated into the pretrained weight matrices using the [`~OFTModel.merge_and_unload()` function. This function merges the adapter weights with the base model which allows you to effectively use the newly merged model as a standalone model.
+
+## OFT Example Usage
+
+For using OFT for quantized finetuning with [TRL](https://github.com/huggingface/trl) for `SFT`, `PPO`, or `DPO` fine-tuning, follow the following outline:
+
+```py
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from trl import SFTTrainer
+from peft import OFTConfig
+
+if use_quantization:
+ bnb_config = BitsAndBytesConfig(
+ load_in_4bit=True,
+ bnb_4bit_quant_type="nf4",
+ bnb_4bit_compute_dtype=torch.bfloat16,
+ bnb_4bit_use_double_quant=True,
+ bnb_4bit_quant_storage=torch.bfloat16,
+ )
+
+model = AutoModelForCausalLM.from_pretrained(
+ "model_name",
+ quantization_config=bnb_config
+)
+tokenizer = AutoTokenizer.from_pretrained("model_name")
+
+# Configure OFT
+peft_config = OFTConfig(
+ oft_block_size=32,
+ use_cayley_neumann=True,
+ target_modules="all-linear",
+ bias="none",
+ task_type="CAUSAL_LM"
+)
+
+trainer = SFTTrainer(
+ model=model,
+ train_dataset=ds['train'],
+ peft_config=peft_config,
+ processing_class=tokenizer,
+ args=training_arguments,
+ data_collator=collator,
+)
+
+trainer.train()
+```
+
+# API
+
+## OFTConfig
+
+[[autodoc]] tuners.oft.config.OFTConfig
+
+## OFTModel
+
+[[autodoc]] tuners.oft.model.OFTModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/osf.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/osf.md
new file mode 100644
index 0000000000000000000000000000000000000000..6cd43fad7f6bc170f9150ae2a13e3f36e0fe02e6
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/osf.md
@@ -0,0 +1,254 @@
+
+
+# OSF (Orthogonal Subspace Fine-tuning)
+
+Orthogonal Subspace Fine-tuning ([OSF](https://huggingface.co/papers/2504.07097)) is a PEFT method designed for continual learning that constrains parameter updates to be orthogonal to previously important directions. This approach enables full fine-tuning while preventing catastrophic forgetting without requiring additional parameters or storing previous gradients.
+
+The abstract from the paper is:
+
+*Continual learning in large language models (LLMs) is prone to catastrophic forgetting, where adapting to new tasks significantly degrades performance on previously learned ones. Existing methods typically rely on low-rank, parameter-efficient updates that limit the model's expressivity and introduce additional parameters per task, leading to scalability issues. To address these limitations, we propose a novel continual full fine-tuning approach leveraging adaptive singular value decomposition (SVD). Our method dynamically identifies task-specific low-rank parameter subspaces and constrains updates to be orthogonal to critical directions associated with prior tasks, thus effectively minimizing interference without additional parameter overhead or storing previous task gradients. We evaluate our approach extensively on standard continual learning benchmarks using both encoder-decoder (T5-Large) and decoder-only (LLaMA-2 7B) models, spanning diverse tasks including classification, generation, and reasoning. Empirically, our method achieves state-of-the-art results, up to 7% higher average accuracy than recent baselines like O-LoRA, and notably maintains the model's general linguistic capabilities, instruction-following accuracy, and safety throughout the continual learning process by reducing forgetting to near-negligible levels. Our adaptive SVD framework effectively balances model plasticity and knowledge retention, providing a practical, theoretically grounded, and computationally scalable solution for continual learning scenarios in large language models.*
+
+## How OSF Works
+
+OSF decomposes each weight matrix into high-rank (frozen) and low-rank (trainable) components using SVD:
+
+```
+W = U_high * S_high * V_high^T + U_low * S_low * V_low^T
+```
+
+Where:
+- `U_high, S_high, V_high`: Preserve important directions from previous tasks (frozen)
+- `U_low, S_low, V_low`: Allow adaptation to new tasks (trainable)
+
+During training, gradients are projected to be orthogonal to the high-rank subspace, ensuring updates don't interfere with previously learned knowledge.
+
+## Basic Usage
+
+```python
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import OSFConfig, get_peft_model
+
+# Load base model
+model = AutoModelForCausalLM.from_pretrained("gpt2")
+
+# Configure OSF
+config = OSFConfig(
+ target_modules=["c_attn", "c_proj"], # Target attention layers
+ effective_rank=8, # Default rank for decomposition
+ rank_pattern={"c_attn": 16} # Override rank for specific modules
+)
+
+# Apply OSF
+model = get_peft_model(model, config)
+
+# Train as usual
+optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)
+
+tokenizer = AutoTokenizer.from_pretrained("gpt2")
+tokenizer.pad_token = tokenizer.eos_token
+
+inputs = tokenizer("Hello world", return_tensors="pt", padding=True)
+loss = model(**inputs, labels=inputs.input_ids).loss
+loss.backward()
+optimizer.step()
+optimizer.zero_grad()
+```
+
+## Configuration Options
+
+### Target Modules
+
+You can specify target modules in several ways:
+
+```python
+# Specific module names
+config = OSFConfig(target_modules=["q_proj", "k_proj", "v_proj", "o_proj"])
+
+# All linear layers
+config = OSFConfig(target_modules="all-linear")
+
+# Model-specific defaults (automatically detected)
+config = OSFConfig() # Uses model-appropriate defaults
+```
+
+### Effective Rank Configuration
+
+Control the preserved/trainable subspaces:
+
+```python
+# Global preserved rank (applies to all target modules)
+config = OSFConfig(effective_rank=16) # preserves top-16 singular directions; trains the rest
+
+# Automatic preserved rank (50% of the smaller matrix dimension per target)
+config = OSFConfig(effective_rank=None)
+
+# Per-module preserved-rank overrides
+config = OSFConfig(
+ effective_rank=8,
+ rank_pattern={
+ "q_proj": 16, # Higher rank for query projection
+ "gate_proj": 4 # Lower rank for gate projection
+ }
+)
+
+# Fractional preserved rank is supported (interpreted per-target as fraction * min_dim)
+config = OSFConfig(effective_rank=0.8) # preserve 80% of min_dim; train remaining 20%
+config = OSFConfig(rank_pattern={"q_proj": 0.5}) # preserve 50% on q_proj, others use global/default
+```
+
+Note: OSF's `effective_rank` is the preserved (frozen) rank, not the trainable rank. The trainable rank equals `min(weight.shape) - effective_rank`. This differs from LoRA's `r`, which directly specifies the trainable rank.
+
+
+## Training Advice for Continual Learning
+
+### Sequential Task Learning
+
+OSF is specifically designed for learning tasks sequentially. Between tasks, recompute the SVD so the preserved subspace reflects the latest weights. One simple way is to re-wrap the updated base model with OSF again:
+
+```python
+# Task 1: train on domain A with initial preserved subspace
+r = 8 # initial effective rank to preserve
+model = get_peft_model(base_model, OSFConfig(effective_rank=r))
+train_task(model, task_1_data)
+
+# Task 2: recompute SVD on updated weights and increase preserved subspace
+base_model = model.unload() # unwrap base model without assuming internals
+r += 4 # grow preserved subspace to include Task 1 knowledge
+model = get_peft_model(base_model, OSFConfig(effective_rank=r))
+train_task(model, task_2_data)
+
+# Task 3: recompute again and expand preserved subspace further
+base_model = model.unload()
+r += 4
+model = get_peft_model(base_model, OSFConfig(effective_rank=r))
+train_task(model, task_3_data)
+```
+
+### Budget Allocation for Task Sequences
+
+When training on a known sequence of n tasks, one effective strategy is to progressively allocate model capacity to balance learning new tasks while preserving previous knowledge:
+
+- **Task 1**: Use full capacity (train everything)
+- **Task 2**: Freeze 1/n of model capacity, train remaining (n-1)/n capacity
+- **Task 3**: Freeze 2/n of model capacity, train remaining (n-2)/n capacity
+- **Task n**: Freeze (n-1)/n of model capacity, use 1/n capacity for final task
+
+This approach ensures each task gets adequate learning capacity while progressively preserving more knowledge from previous tasks.
+
+```python
+# Example: 4-task sequence with progressive budget allocation
+n_tasks = 4
+max_preserved_rank = 512 # Upper bound for preserved rank per target (heuristic)
+
+for task_id in range(n_tasks):
+ # Freeze increases over time; trainable capacity shrinks
+ preserved_fraction = (task_id + 1) / n_tasks
+ preserved_rank = int(max_preserved_rank * preserved_fraction)
+
+ config = OSFConfig(
+ target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
+ effective_rank=preserved_rank,
+ )
+
+ print(
+ f"Task {task_id + 1}: Preserving rank {preserved_rank} "
+ f"({preserved_fraction:.1%} of max_preserved_rank - {max_preserved_rank} frozen); trainable rank = min_dim - preserved_rank"
+ )
+
+ model = get_peft_model(base_model, config)
+ train_task(model, task_data[task_id])
+```
+
+### Best Practices
+
+1. **Effective Rank Selection**: Start with `effective_rank=None` (auto sets rank to 50% of the smaller weight dimension per target module) and adjust based on task complexity
+2. **Learning Rate**: Use smaller learning rates (1e-5 to 1e-4) compared to standard fine-tuning
+3. **Task Importance**: Use `rank_pattern` to allocate more capacity to critical modules
+4. **Model Architecture**: OSF works best with transformer architectures having clear attention and MLP separations
+5. **Capacity Planning**: For known task sequences, use progressive budget allocation (1/n, 2/n, ..., (n-1)/n freezing) to balance plasticity and stability
+
+### Memory Considerations
+
+OSF modifies weights in-place and doesn't add parameters, making it memory-efficient:
+
+```python
+# Memory usage remains close to base model
+print(f"Base model parameters: {base_model.num_parameters():,}")
+print(f"OSF model parameters: {osf_model.num_parameters():,}") # Similar count
+```
+
+## Advanced Usage
+
+### Custom Target Modules
+
+For models with non-standard architectures:
+
+```python
+config = OSFConfig(
+ target_modules=["dense", "intermediate.dense"], # Custom layer names
+ effective_rank=12,
+ rank_pattern={"dense": 8, "intermediate.dense": 16}
+)
+```
+
+### Integration with Other Methods
+
+OSF can be combined with other techniques:
+
+```python
+# Use with gradient checkpointing for memory efficiency
+model.gradient_checkpointing_enable()
+
+# Apply weight decay selectively (regularizes low-rank factors to limit drift/overfitting in continual updates; keep small)
+optimizer = torch.optim.AdamW([
+ {"params": [p for n, p in model.named_parameters() if "U_low" in n], "weight_decay": 0.01},
+ {"params": [p for n, p in model.named_parameters() if "S_low" in n], "weight_decay": 0.001},
+ {"params": [p for n, p in model.named_parameters() if "V_low" in n], "weight_decay": 0.01},
+], lr=1e-4)
+```
+
+## Benchmark overview
+
+
+
+# API
+
+## OSFConfig
+
+[[autodoc]] tuners.osf.config.OSFConfig
+
+## OSFModel
+
+[[autodoc]] tuners.osf.model.OSFModel
+
+## Utility Functions
+
+### Weight Decomposition
+
+[[autodoc]] tuners.osf.utils.decompose_weight_matrix
+
+[[autodoc]] tuners.osf.utils.reconstruct_weight_matrix
+
+### Gradient Projection
+
+[[autodoc]] tuners.osf.utils.project_gradient_to_orthogonal_space
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/p_tuning.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/p_tuning.md
new file mode 100644
index 0000000000000000000000000000000000000000..d529448dae359845598261499acb5644cf910788
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/p_tuning.md
@@ -0,0 +1,70 @@
+
+
+# P-tuning
+
+
+
+
+Prompt tokens can be inserted anywhere in the input sequence, and they are optimized by a prompt encoder (image source).
+
+[P-tuning](https://hf.co/papers/2103.10385) is designed for natural language understanding (NLU) tasks and all language models.
+
+The abstract from the paper is:
+
+*While GPTs with traditional fine-tuning fail to achieve strong results on natural language understanding (NLU), we show that GPTs can be better than or comparable to similar-sized BERTs on NLU tasks with a novel method P-tuning -- which employs trainable continuous prompt embeddings. On the knowledge probing (LAMA) benchmark, the best GPT recovers 64\% (P@1) of world knowledge without any additional text provided during test time, which substantially improves the previous best by 20+ percentage points. On the SuperGlue benchmark, GPTs achieve comparable and sometimes better performance to similar-sized BERTs in supervised learning. Importantly, we find that P-tuning also improves BERTs' performance in both few-shot and supervised settings while largely reducing the need for prompt engineering. Consequently, P-tuning outperforms the state-of-the-art approaches on the few-shot SuperGlue benchmark.*.
+
+The method adds trainable prompt embeddings to the input that is optimized by a prompt encoder to find a better prompt, eliminating the need to manually design prompts. The prompt tokens can be added anywhere in the input sequence, and p-tuning also introduces anchor tokens for improving performance. A prompt encoder (a bidirectional long-short term memory network or LSTM) is used to optimize the prompt parameters. Unlike prefix tuning:
+
+- the prompt tokens can be inserted anywhere in the input sequence, and it isn't restricted to only the beginning
+- the prompt tokens are only added to the input instead of adding them to every layer of the model
+- introducing *anchor* tokens can improve performance because they indicate characteristics of a component in the input sequence
+
+The paper's results suggest that P-tuning is more efficient than manually crafting prompts, and it enables GPT-like models to compete with BERT-like models on NLU tasks.
+
+## Usage
+
+Create a [`PromptEncoderConfig`] with the task type, the number of virtual tokens to add and learn, and the hidden size of the encoder for learning the prompt parameters.
+
+```py
+from peft import PromptEncoderConfig, get_peft_model
+
+peft_config = PromptEncoderConfig(task_type="CAUSAL_LM", num_virtual_tokens=20, encoder_hidden_size=128)
+model = get_peft_model(model, peft_config)
+model.print_trainable_parameters()
+"trainable params: 300,288 || all params: 559,514,880 || trainable%: 0.05366935013417338"
+```
+
+## Benchmark overview
+
+
+
+
+# API
+
+## PromptEncoderConfig
+
+[[autodoc]] tuners.p_tuning.config.PromptEncoderConfig
+
+## PromptEncoder
+
+[[autodoc]] tuners.p_tuning.model.PromptEncoder
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/peanut.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/peanut.md
new file mode 100644
index 0000000000000000000000000000000000000000..f986d878977ac946dcf69700f8f363f42dd7c57c
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/peanut.md
@@ -0,0 +1,64 @@
+
+
+# PEANuT: Parameter-Efficient Adaptation with Weight-aware Neural Tweakers
+
+[PEANuT](https://arxiv.org/abs/2410.01870) is a parameter-efficient fine-tuning technique that introduces
+weight-aware neural tweakers to generate adapter updates from the frozen pretrained weights themselves. Instead of
+learning a purely linear low-rank update as in LoRA, PEANuT conditions the adapter transformation on the base weight,
+which makes the update rule more expressive while keeping the number of trainable parameters small.
+
+PEANuT uses an input projection `A`, an output projection `B`, and optional intermediate residual encoder/decoder
+pairs with non-linear activations. This makes it possible to model more complex update patterns than weight-agnostic
+linear adapters while still remaining within the PEFT setting.
+
+PEANuT currently has the following tradeoffs:
+
+Pros:
+- Higher theoretical expressiveness than linear low-rank updates.
+- Better performance than LoRA on a range of tasks under similar budgets.
+- Works well in very low-parameter regimes, for example around `0.2M` trainable parameters.
+
+Cons:
+- Higher memory usage than LoRA, because `ΔW` is explicitly constructed before being applied.
+- Slower training and inference than LoRA, and deeper intermediate layers increase the overhead further.
+- The non-linearity can require more careful hyperparameter tuning, especially learning rate and related optimization settings.
+
+If these tradeoffs do not fit your use case, consider other PEFT methods such as LoRA.
+
+The abstract from the paper is:
+
+> Fine-tuning large pre-trained foundation models often yields excellent downstream performance but is prohibitively expensive when updating all parameters. Parameter-efficient fine-tuning (PEFT) methods such as LoRA alleviate this by introducing lightweight update modules, yet they commonly rely on weight-agnostic linear approximations, limiting their expressiveness. In this work, we propose PEANuT, a novel PEFT framework that introduces weight-aware neural tweakers, compact neural modules that generate task-adaptive updates conditioned on frozen pre-trained weights. PEANuT provides a flexible yet efficient way to capture complex update patterns without full model tuning. We theoretically show that PEANuT achieves equivalent or greater expressivity than existing linear PEFT methods with comparable or fewer parameters. Extensive experiments across four benchmarks with over twenty datasets demonstrate that PEANuT consistently outperforms strong baselines in both NLP and vision tasks, while maintaining low computational overhead.
+
+## Benchmark overview
+
+
+
+# API
+
+## PeanutConfig
+
+[[autodoc]] tuners.peanut.config.PeanutConfig
+
+## PeanutModel
+
+[[autodoc]] tuners.peanut.model.PeanutModel
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/peft_model.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/peft_model.md
new file mode 100644
index 0000000000000000000000000000000000000000..366ef91fd8bf09e7103d6595d2f09ca16b0b7fd9
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/peft_model.md
@@ -0,0 +1,77 @@
+
+
+# Models
+
+[`PeftModel`] is the base model class for specifying the base Transformer model and configuration to apply a PEFT method to. The base `PeftModel` contains methods for loading and saving models from the Hub.
+
+## PeftModel
+
+[[autodoc]] PeftModel
+ - all
+
+## PeftModelForSequenceClassification
+
+A `PeftModel` for sequence classification tasks.
+
+[[autodoc]] PeftModelForSequenceClassification
+ - all
+
+## PeftModelForTokenClassification
+
+A `PeftModel` for token classification tasks.
+
+[[autodoc]] PeftModelForTokenClassification
+ - all
+
+## PeftModelForCausalLM
+
+A `PeftModel` for causal language modeling.
+
+[[autodoc]] PeftModelForCausalLM
+ - all
+
+## PeftModelForSeq2SeqLM
+
+A `PeftModel` for sequence-to-sequence language modeling.
+
+[[autodoc]] PeftModelForSeq2SeqLM
+ - all
+
+## PeftModelForQuestionAnswering
+
+A `PeftModel` for question answering.
+
+[[autodoc]] PeftModelForQuestionAnswering
+ - all
+
+## PeftModelForFeatureExtraction
+
+A `PeftModel` for getting extracting features/embeddings from transformer models.
+
+[[autodoc]] PeftModelForFeatureExtraction
+ - all
+
+## PeftMixedModel
+
+A `PeftModel` for mixing different adapter types (e.g. LoRA and LoHa).
+
+[[autodoc]] PeftMixedModel
+ - all
+
+## Utilities
+
+[[autodoc]] utils.cast_mixed_precision_params
+
+[[autodoc]] get_peft_model
+
+[[autodoc]] inject_adapter_in_model
+
+[[autodoc]] utils.get_peft_model_state_dict
+
+[[autodoc]] utils.prepare_model_for_kbit_training
+
+[[autodoc]] get_layer_status
+
+[[autodoc]] get_model_status
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/peft_types.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/peft_types.md
new file mode 100644
index 0000000000000000000000000000000000000000..55edbbd21a47ff035dc39dc90e55e6e524df6493
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/peft_types.md
@@ -0,0 +1,27 @@
+
+
+# PEFT types
+
+[`PeftType`] includes the supported adapters in PEFT, and [`TaskType`] includes PEFT-supported tasks.
+
+## PeftType
+
+[[autodoc]] utils.peft_types.PeftType
+
+## TaskType
+
+[[autodoc]] utils.peft_types.TaskType
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/poly.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/poly.md
new file mode 100644
index 0000000000000000000000000000000000000000..3dd2a20c9b3b9fc4bb71d0bfe1e6deed84a9b246
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/poly.md
@@ -0,0 +1,48 @@
+
+
+# Polytropon
+
+[Polytropon](https://hf.co/papers/2202.13914) is a multitask model with a number of different LoRA adapters in its "inventory". The model learns the correct combination of adapters from the inventory with a routing function to choose the best subset of modules for a specific task. PEFT also supports [Multi-Head Adapter Routing (MHR)](https://hf.co/papers/2211.03831) for Polytropon which builds on and improves the routing function by combining the adapter heads more granularly. The adapter heads are separated into disjoint blocks and a different routing function is learned for each one, allowing for more expressivity.
+
+
+
+
+The abstract from the paper is:
+
+*A modular design encourages neural models to disentangle and recombine different facets of knowledge to generalise more systematically to new tasks. In this work, we assume that each task is associated with a subset of latent discrete skills from a (potentially small) inventory. In turn, skills correspond to parameter-efficient (sparse / low-rank) model parameterisations. By jointly learning these and a task-skill allocation matrix, the network for each task is instantiated as the average of the parameters of active skills. To favour non-trivial soft partitions of skills across tasks, we experiment with a series of inductive biases, such as an Indian Buffet Process prior and a two-speed learning rate. We evaluate our latent-skill model on two main settings: 1) multitask reinforcement learning for grounded instruction following on 8 levels of the BabyAI platform; and 2) few-shot adaptation of pre-trained text-to-text generative models on CrossFit, a benchmark comprising 160 NLP tasks. We find that the modular design of a network significantly increases sample efficiency in reinforcement learning and few-shot generalisation in supervised learning, compared to baselines with fully shared, task-specific, or conditionally generated parameters where knowledge is entangled across tasks. In addition, we show how discrete skills help interpretability, as they yield an explicit hierarchy of tasks.*
+
+
+
+
+The abstract from the paper is:
+
+*Parameter-efficient fine-tuning (PEFT) for cross-task generalization consists in pre-training adapters on a multi-task training set before few-shot adaptation to test tasks. Polytropon [Ponti et al., 2023] (Poly) jointly learns an inventory of adapters and a routing function that selects a (variable-size) subset of adapters for each task during both pre-training and few-shot adaptation. In this paper, we investigate the role that adapter routing plays in its success and design new variants based on our findings. First, we build on the intuition that finer-grained routing provides more expressivity. Hence, we propose MHR (Multi-Head Routing), which combines subsets of adapter parameters and outperforms Poly under a comparable parameter budget; by only fine-tuning the routing function and not the adapters (MHR-z), we achieve competitive performance with extreme parameter efficiency. Second, we find that Poly/MHR performance is a result of better multi-task optimization, rather than modular inductive biases that facilitate adapter recombination and local adaptation, as previously hypothesized. In fact, we find that MHR exhibits higher gradient alignment between tasks than any other method. Since this implies that routing is only crucial during multi-task pre-training, we propose MHR-mu, which discards routing and fine-tunes the average of the pre-trained adapters during few-shot adaptation. This establishes MHR-mu as an effective method for single-adapter fine-tuning.*.
+
+
+
+
+In case you want to try out routing without training first, you can check out the [Arrow LoRA variant](./lora#Arrow).
+
+# API
+
+## PolyConfig
+
+[[autodoc]] tuners.poly.config.PolyConfig
+
+## PolyModel
+
+[[autodoc]] tuners.poly.model.PolyModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/prefix_tuning.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/prefix_tuning.md
new file mode 100644
index 0000000000000000000000000000000000000000..06ec4c52453f0921e33f577731ed9f7dbc0cb7bb
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/prefix_tuning.md
@@ -0,0 +1,123 @@
+
+
+# Prefix tuning
+
+
+
+
+Optimize the prefix parameters for each task (image source).
+
+[Prefix tuning](https://hf.co/papers/2101.00190) prefixes a series of task-specific vectors to the input sequence that can be learned while keeping the pretrained model frozen. The prefix parameters are inserted in all of the model layers.
+
+The abstract from the paper is:
+
+*Fine-tuning is the de facto way to leverage large pretrained language models to perform downstream tasks. However, it modifies all the language model parameters and therefore necessitates storing a full copy for each task. In this paper, we propose prefix-tuning, a lightweight alternative to fine-tuning for natural language generation tasks, which keeps language model parameters frozen, but optimizes a small continuous task-specific vector (called the prefix). Prefix-tuning draws inspiration from prompting, allowing subsequent tokens to attend to this prefix as if it were "virtual tokens". We apply prefix-tuning to GPT-2 for table-to-text generation and to BART for summarization. We find that by learning only 0.1\% of the parameters, prefix-tuning obtains comparable performance in the full data setting, outperforms fine-tuning in low-data settings, and extrapolates better to examples with topics unseen during training*.
+
+**Note** For encoder-decoder models (seq2seq), the prefix is only applied to the decoder, which does not correspond to the paper specification (see e.g. Figure 2). Prefix tuning can still be fine-tuned on these model architectures but the performance could be sub-par; consider using other PEFT methods for encoder-decoder models.
+
+Prefix tuning is very similar to [prompt tuning](../package_reference/prompt_tuning). The main difference is that the prefix parameters are inserted in **all** of the model layers, whereas prompt tuning only adds the prompt parameters to the model input embeddings. The prefix parameters are also optimized by a separate feed-forward network (FFN) instead of training directly on the soft prompts because it causes instability and hurts performance. The FFN is discarded after updating the soft prompts.
+
+As a result, the authors found that prefix tuning demonstrates comparable performance to fully finetuning a model, despite having 1000x fewer parameters, and it performs even better in low-data settings.
+
+## Basic Usage
+
+Create a [`PrefixTuningConfig`] with the task type and number of virtual tokens to add and learn.
+
+```py
+from peft import PrefixTuningConfig, get_peft_model
+
+peft_config = PrefixTuningConfig(task_type="CAUSAL_LM", num_virtual_tokens=20)
+model = get_peft_model(model, peft_config)
+model.print_trainable_parameters()
+"trainable params: 983,040 || all params: 560,197,632 || trainable%: 0.1754809274167014"
+```
+
+## Possible Initializations
+
+By default, prefix tuning uses randomly initialized virtual tokens. There's also the option to initialize the vectors
+to be close to a no-op (initialized to zero, it will still shift the probability mass a bit).
+This means that the KV-cache injected prefixes have less impact from the beginning and reduces the variance in training
+performance.
+
+PEFT also provides utilities to initialize a prefix-tuning adapter from an existing KV cache prefix (for example, from
+the first `p` tokens of a prompt/corpus). This is only supported when `prefix_projection=False` (the default), because
+in that case the learned parameters are the KV prefix itself.
+
+```py
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from peft import PrefixTuningConfig, get_peft_model, initialize_kv_prefix_from_text
+
+base = AutoModelForCausalLM.from_pretrained("gpt2")
+tok = AutoTokenizer.from_pretrained("gpt2")
+
+peft_cfg = PrefixTuningConfig(task_type="CAUSAL_LM", num_virtual_tokens=20, prefix_projection=False)
+model = get_peft_model(base, peft_cfg)
+
+initialize_kv_prefix_from_text(
+ model,
+ tok,
+ text="...a long context with at least num_virtual_tokens tokens...",
+ use_chat_template=False,
+)m peft import PrefixTuningConfig, get_peft_model, initialize_kv_prefix_from_text
+
+base = AutoModelForCausalLM.from_pretrained("gpt2")
+tok = AutoTokenizer.from_pretrained("gpt2")
+
+peft_cfg = PrefixTuningConfig(task_type="CAUSAL_LM", num_virtual_tokens=20, prefix_projection=False)
+model = get_peft_model(base, peft_cfg)
+
+initialize_kv_prefix_from_text(
+ model,
+ tok,
+ text="...a long context with at least num_virtual_tokens tokens...",
+ use_chat_template=False,
+)
+
+```
+
+Make sure the text is long enough to produce at least `num_virtual_tokens` tokens, otherwise initialization will fail.
+
+As a guideline:
+
+* start with a neutral starting sequence using `initialize_kv_prefix_from_text`, it can be a very short string like
+ "Question: "
+* if that doesn't help, use a longer sequence with task relevance (i.e. an engineered prompt), giving you more virtual
+ tokens to fit but also more steering of the model
+* if it is not possible to use an initialization text or you want to quickly check if prefix tuning is viable at all,
+ use a zero init without projection
+
+
+## Benchmark overview
+
+
+
+
+# API
+
+## PrefixTuningConfig
+
+[[autodoc]] tuners.prefix_tuning.config.PrefixTuningConfig
+
+## PrefixEncoder
+
+[[autodoc]] tuners.prefix_tuning.model.PrefixEncoder
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/prompt_tuning.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/prompt_tuning.md
new file mode 100644
index 0000000000000000000000000000000000000000..e03be042fab493de43a467c3711ba3c54bc581a7
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/prompt_tuning.md
@@ -0,0 +1,74 @@
+
+
+# Prompt tuning
+
+
+
+
+Only train and store a significantly smaller set of task-specific prompt parameters (image source).
+
+[Prompt tuning](https://hf.co/papers/2104.08691) adds a task-specific, virtual prompt to the input that consists of trainable vectors in the embedding space. The virtual token parameters are updated independently of the pretrained model parameters which are frozen.
+
+The abstract from the paper is:
+
+*In this work, we explore "prompt tuning", a simple yet effective mechanism for learning "soft prompts" to condition frozen language models to perform specific downstream tasks. Unlike the discrete text prompts used by GPT-3, soft prompts are learned through backpropagation and can be tuned to incorporate signal from any number of labeled examples. Our end-to-end learned approach outperforms GPT-3's "few-shot" learning by a large margin. More remarkably, through ablations on model size using T5, we show that prompt tuning becomes more competitive with scale: as models exceed billions of parameters, our method "closes the gap" and matches the strong performance of model tuning (where all model weights are tuned). This finding is especially relevant in that large models are costly to share and serve, and the ability to reuse one frozen model for multiple downstream tasks can ease this burden. Our method can be seen as a simplification of the recently proposed "prefix tuning" of Li and Liang (2021), and we provide a comparison to this and other similar approaches. Finally, we show that conditioning a frozen model with soft prompts confers benefits in robustness to domain transfer, as compared to full model tuning*.
+
+In contrast to [prefix tuning](../package_reference/prefix_tuning), only the
+input of the first layer receives the virtual tokens.
+
+## Usage
+
+There are two decisions to take: how many virtual tokens are added to the
+input of the model (`num_virtual_tokens`) - this will define how many
+trainable parameters there will be - and how these tokens are initialized.
+
+Create a [`PromptTuningConfig`] with the task type, the initial prompt tuning text to train the model with, the number of virtual tokens to add and learn, and a tokenizer.
+
+```py
+from peft import PromptTuningConfig, PromptTuningInit, get_peft_model
+
+prompt_tuning_init_text = "Classify if the tweet is a complaint or no complaint.\n"
+peft_config = PromptTuningConfig(
+ task_type="CAUSAL_LM",
+ prompt_tuning_init=PromptTuningInit.TEXT,
+ num_virtual_tokens=len(tokenizer(prompt_tuning_init_text)["input_ids"]),
+ prompt_tuning_init_text=prompt_tuning_init_text,
+ tokenizer_name_or_path="bigscience/bloomz-560m",
+)
+model = get_peft_model(model, peft_config)
+model.print_trainable_parameters()
+"trainable params: 8,192 || all params: 559,222,784 || trainable%: 0.0014648902430985358"
+```
+
+## Benchmark overview
+
+
+
+# API
+
+## PromptTuningConfig
+
+[[autodoc]] tuners.prompt_tuning.config.PromptTuningConfig
+
+## PromptEmbedding
+
+[[autodoc]] tuners.prompt_tuning.model.PromptEmbedding
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/psoft.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/psoft.md
new file mode 100644
index 0000000000000000000000000000000000000000..d5aaeed4d1cefd152db315ead093fc532264bf0e
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/psoft.md
@@ -0,0 +1,139 @@
+
+
+# PSOFT
+
+[PSOFT](https://hf.co/papers/2505.11235) is an Orthogonal Fine-Tuning (OFT)-based parameter-efficient fine-tuning method that preserves the geometric relationships of pre-trained weight column vectors while achieving a balanced trade-off between performance and multi-dimensional efficiency, including parameter count, memory usage, and computational cost. By restricting orthogonal transformations to a low-rank principal subspace derived from pre-trained weights, PSOFT bridges the gap between LoRA and OFT, providing both theoretical guarantees and practical adaptability. Its effectiveness is validated through extensive evaluations on diverse benchmarks, including GLUE, VTAB-1K, GSM8K, MATH, and commonsense reasoning benchmarks.
+
+- Only `nn.Linear` layers are supported.
+- Quantized layers are not supported.
+
+The abstract from the paper is:
+
+*Driven by the rapid growth of model parameters, parameter-efficient fine-tuning (PEFT) has become essential for adapting large models to diverse downstream tasks under constrained computational resources. Within this paradigm, orthogonal fine-tuning and its variants preserve semantic representations of pre-trained models, but struggle to achieve both expressiveness and efficiency in terms of parameter counts, memory, and computation. To overcome this limitation, we propose efficient Orthogonal Fine-Tuning with Principal Subspace adaptation (PSOFT), which confines orthogonal transformations to the principal subspace of pre-trained weights. Specifically, PSOFT constructs this subspace via matrix decomposition to enable compatible transformations, establishes a theoretical condition that strictly maintains the geometry of this subspace for essential semantic preservation, and introduces efficient tunable vectors that gradually relax orthogonality during training to enhance adaptability. Extensive experiments on 35 NLP and CV tasks across four representative models demonstrate that PSOFT offers a practical and scalable solution to simultaneously achieve semantic preservation, expressiveness, and multi-dimensional efficiency in PEFT.*
+
+
+## How PSOFT Works
+
+PSOFT decomposes each weight matrix $W_{pre}$ into $W_{pri}$ and $W_{res}$ using SVD:
+$W_{\text{pre}} = U S V^\top$
+
+The principal subspace $W_{\text{pri}} = U_r S_r V_r^\top = AB$ is constructed from the top-$r$ singular components:
+
+$W_{\text{pre}} = W_{\text{pri}} + W_{\text{res}} = AB + W_{\text{res}},$
+
+
+$W_{\text{ps-tuned}} = ARB + W_{\text{res}}.$ (PSOFT-SO: PSOFT with strict orthogonality)
+
+
+$W_{\text{ps-tuned}} = A \, \mathrm{diag}(\alpha) \, R \, \mathrm{diag}(\beta) \, B + W_{\text{res}}.$ (PSOFT-RO: PSOFT with relaxed orthogonality)
+
+During training, $A$, $B$, and $W_{\text{res}}$ are frozen, and only $R$ (or $R$ with $\alpha$ and $\beta$) is trainable.
+
+For compatibility with the PEFT framework (which expects additive weight updates), PSOFT is implemented in the following additive form:
+$W_{\text{ps-tuned}} = W_{\text{pre}} + A (R - I_r) B$
+
+
+## Trainable Parameters
+
+After applying PSOFT:
+
+- The original model weights ($A$, $B$, and $W_{\text{res}}$) are frozen.
+- Only the orthogonal matrix $R$ (and optionally $\alpha$, $\beta$) are trainable.
+- No additional bias parameters are introduced.
+
+## Basic Usage
+```python
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import PsoftConfig, get_peft_model
+
+# Load base model
+model_id = "facebook/opt-125m"
+model = AutoModelForCausalLM.from_pretrained(model_id)
+
+# Configure PSOFT
+config = PsoftConfig(
+ r=32, # the dimension of trainable matrix R,
+ psoft_alpha=32, # scaling factor (typically set to r in PSOFT),
+ target_modules=["q_proj", "v_proj"], # target attention projection layers
+ ab_svd_init="psoft_init", # principal subspace initialization
+ psoft_svd="full", # SVD method
+ psoft_orth=True, # enable orthogonal R (Cayley parameterization)
+ psoft_mag_a=True, # enable tunable vector alpha
+ psoft_mag_b=True, # enable tunable vector beta
+ use_cayley_neumann=False, # disable Cayley–Neumann approximation
+ num_cayley_neumann_terms=5, # number of Neumann series terms
+ cayley_neumann_eps=None, # improve numerical stability
+)
+
+# Apply PSOFT
+model = get_peft_model(model, config)
+model.train()
+
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+tokenizer.pad_token = tokenizer.eos_token
+
+# Train
+inputs = tokenizer("Hello world", return_tensors="pt", padding=True)
+loss = model(**inputs, labels=inputs["input_ids"]).loss
+loss.backward()
+
+trainable = [p for p in model.parameters() if p.requires_grad]
+optimizer = torch.optim.AdamW(trainable, lr=5e-4)
+optimizer.step()
+optimizer.zero_grad(set_to_none=True)
+```
+## Configuration Options
+
+### Different Mode
+
+(PSOFT-SO: PSOFT with strict orthogonality)
+
+```python
+config = PsoftConfig(psoft_orth=True,psoft_mag_a=False,psoft_mag_b=False)
+```
+
+(PSOFT-RO: PSOFT with relaxed orthogonality)
+```python
+config = PsoftConfig(psoft_orth=True,psoft_mag_a=True,psoft_mag_b=True)
+```
+
+### Best Practices
+1. **Rank Choice**: Smaller ranks (e.g., `32–128`) are suitable for simpler tasks, while larger ranks (e.g., `64–256`) provide greater expressiveness for more complex tasks at the cost of increased parameters and computation.
+2. **Scaling Factor**: The scaling factor is typically set to $r$ in PSOFT.
+3. **Learning Rate**: Use standard learning rates (e.g., `1e-4` to `5e-3`) for stable training.
+4. **SVD Initialization**: The `lowrank` option is more memory- and compute-efficient than `full`, making it more suitable for large models.
+5. **Cayley–Neumann Approximation**: When the rank is large, enabling the Cayley–Neumann approximation can significantly improve computational efficiency, while the benefit is less pronounced for small ranks. In practice, a small number of Neumann series terms (typically `5`) usually provides a good balance between accuracy and efficiency.
+
+## Benchmark overview
+
+
+
+# API
+
+## PsoftConfig
+
+[[autodoc]] tuners.psoft.config.PsoftConfig
+
+## PsoftModel
+
+[[autodoc]] tuners.psoft.model.PsoftModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/pvera.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/pvera.md
new file mode 100644
index 0000000000000000000000000000000000000000..d0c6ca4e93df9eb8d2daf80a964f2d6cd56d2fd0
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/pvera.md
@@ -0,0 +1,51 @@
+
+
+# PVeRA: Probabilistic Vector-Based Random Matrix Adaptation
+
+[PVeRA](https://huggingface.co/papers/2512.07703) is a parameter-efficient fine-tuning technique that is base on VeRA, in the family of the LoRA-based adapters. It keeps the very low parameter budget of VeRA, but increases the performance by learning a distribution of latent adaptations. This also enables models adapted with PVeRA to generate Monte Carlo confidence interval estimates, by sampling from the learned distribution at inference.
+
+When saving the adapter parameters, it's possible to eschew storing the low rank matrices by setting `save_projection=False` on the `PveraConfig`. In that case, these matrices will be restored based on the fixed random seed from the `projection_prng_key` argument. This cuts down on the size of the checkpoint, but we cannot guarantee reproducibility on all devices and for all future versions of PyTorch. If you want to ensure reproducibility, set `save_projection=True` (which is the default).
+
+To handle different shapes of adapted layers, PVeRA initializes shared A and B matrices with the largest required size for each dimension. During the forward pass, submatrices A and B for a given layer are sliced out from these shared matrices and used as described in the paper. For example, adapting two linear layers of shapes (100, 20) and (80, 50) will create A and B matrices of shapes (rank, 50) and (100, rank) respectively. Then, to adapt a layer of shape (100, 20), submatrices A and B of shapes (rank, 20) and (100, rank) will be extracted.
+
+PVeRA currently has the following constraint:
+
+- Only `nn.Linear` layers are supported.
+- The latent representation is not easily accessible, for training using the KL divergence.
+
+The abstract from the paper is:
+
+> Large foundation models have emerged in the last years and are pushing performance boundaries for a variety of tasks. Training or even finetuning such models demands vast datasets and computational resources, which are often scarce and costly. Adaptation methods provide a computationally efficient solution to address these limitations by allowing such models to be finetuned on small amounts of data and computing power. This is achieved by appending new trainable modules to frozen backbones with only a fraction of the trainable parameters and fitting only these modules on novel tasks. Recently, the VeRA adapter was shown to excel in parameter-efficient adaptations by utilizing a pair of frozen random low-rank matrices shared across all layers. In this paper, we propose PVeRA, a probabilistic version of the VeRA adapter, which modifies the low-rank matrices of VeRA in a probabilistic manner. This modification naturally allows handling inherent ambiguities in the input and allows for different sampling configurations during training and testing. A comprehensive evaluation was performed on the VTAB-1k benchmark and seven adapters, with PVeRA outperforming VeRA and other adapters.
+
+## Benchmark overview
+
+
+
+# API
+
+## PveraConfig
+
+[[autodoc]] tuners.pvera.config.PveraConfig
+
+## PveraModel
+
+[[autodoc]] tuners.pvera.model.PveraModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/randlora.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/randlora.md
new file mode 100644
index 0000000000000000000000000000000000000000..99023649a9e949df7ac8cba35ccc76c0178f4f90
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/randlora.md
@@ -0,0 +1,56 @@
+
+
+# RandLora: Full-rank parameter-efficient fine-tuning of large models
+[RandLora](https://huggingface.co/papers/2502.00987) is a parameter-efficient fine-tuning technique that is similar to [LoRA](https://huggingface.co/papers/2106.09685) and [VeRA](https://huggingface.co/papers/2310.11454) but performs full rank updates to improve performance. RandLora can be particularly useful when adapting large model to hard tasks that require complex updates while preserving the parameter efficiency of LoRA. The full rank update of RandLora is achieved by linearly scaling random bases. The random bases are a collection of multiple low rank matrices such that the summation of their ranks if greater or equal to the full rank of the parameter matrices. The trainable parameters of RandLora are two diagonal matrices (vectors) that get multiplied with the right hand low rank random bases, in a similar way to VeRA's update. To maintain low memory usage, RandLora uses a custom function that prevents storing unnecessary bases in memory for backpropagation.
+
+RandLora presents the noteworthy difference that contrary to other LoRA-like PEFT algorithm, increasing RandLora's random base ranks increases the amount of trainable parameters. Because number of bases x bases rank is constant in RandLora, reducing the rank will increase the number of random bases, hence the number of base-specific trainable diagonal bases.
+
+Because reducing the rank of RandLora's random bases will increase their number, RandLora can become slower to train than LoRA for very small ranks where typically, ranks below 4 with result in a large training time increase. This does not affect inference though as the RandLora adapters can be merged into the pretrained weight matrices.
+
+RandLora additionally supports training with sparse, ternary random bases (only containing -1, 0 and 1). These bases are as described in [Bingham et al.](https://cs-people.bu.edu/evimaria/cs565/kdd-rp.pdf) and [Ping et al.](https://hastie.su.domains/Papers/Ping/KDD06_rp.pdf) and could theoretically be used to reduce compute needs by performing aggregations instead of matrix multiplications to create the weight update. This is not currently supported. Although it does not currently reduce compute, using sparse random bases in RandLora can reduce overfitting in some cases. For users interested in using sparse ternary bases, the `sparse` option is recommended over the `very_sparse` one that can reduce performance.
+
+Similarly to VeRA, when saving the RandLora's parameters, it's possible to eschew storing the low rank matrices by setting `save_projection=False` on the `VeraConfig`. In that case, these matrices will be restored based on the fixed random seed from the `projection_prng_key` argument. This cuts down on the size of the checkpoint, but we cannot guarantee reproducibility on all devices and for all future versions of PyTorch. If you want to ensure reproducibility, set `save_projection=True` (which is the default).
+
+As in Vera and to handle different shapes of adapted layers, RandLora initializes shared A and B matrices with the largest required size for each dimension. During the forward pass, submatrices A and B for a given layer are sliced out from these shared matrices and used as described in the paper. For example, adapting two linear layers of shapes (100, 20) and (80, 50) will create A and B matrices of shapes (rank, 50) and (100, rank) respectively. Then, to adapt a layer of shape (100, 20), submatrices A and B of shapes (rank, 20) and (100, rank) will be extracted.
+
+RandLora currently has the following constraint:
+
+- Only `nn.Linear` layers are supported.
+
+The abstract from the paper is:
+
+> Low-Rank Adaptation (LoRA) and its variants have shown impressive results in reducing the number of trainable parameters and memory requirements of large transformer networks while maintaining fine-tuning performance. The low-rank nature of the weight update inherently limits the representation power of fine-tuned models, however, thus potentially compromising performance on complex tasks. This raises a critical question: when a performance gap between LoRA and standard fine-tuning is observed, is it due to the reduced number of trainable parameters or the rank deficiency?
+This paper aims to answer this question by introducing RandLora, a parameter-efficient method that performs full-rank updates using a learned linear combinations of low-rank, non-trainable random matrices. Our method limits the number of trainable parameters by restricting optimization to diagonal scaling matrices applied to the fixed random matrices. This allows us to effectively overcome the low-rank limitations while maintaining parameter and memory efficiency during training. Through extensive experimentation across vision, language, and vision-language benchmarks, we systematically evaluate the limitations of LoRA and existing random basis methods. Our findings reveal that full-rank updates are beneficial across vision and language tasks individually, and even more so for vision-language tasks, where RandLora significantly reduces---and sometimes eliminates---the performance gap between standard fine-tuning and LoRA, demonstrating its efficacy.
+
+## Benchmark overview
+
+
+
+# API
+
+## RandLoraConfig
+
+[[autodoc]] tuners.randlora.config.RandLoraConfig
+
+## RandLoraModel
+
+[[autodoc]] tuners.randlora.model.RandLoraModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/road.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/road.md
new file mode 100644
index 0000000000000000000000000000000000000000..31a6f30d88007cec84349b5249b57ef840473db6
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/road.md
@@ -0,0 +1,42 @@
+
+
+# RoAd
+
+[RoAd](https://huggingface.co/papers/2409.00119) is a parameter‑efficient fine‑tuning technique that adapts large language models by learning a small set of 2×2 rotation matrices (and optional scaling factors) applied to pairs of hidden dimensions. RoAd achieves competitive or superior performance compared to other PEFT methods with under 0.1% trainable parameters. Unlike LoRA’s batched low‑rank updates, RoAd’s sparse rotations reformulate to simple element‑wise operations, yielding significantly higher serving throughput when handling heterogeneous requests in the same batch, i.e. serving multiple adapters simultaneously. Moreover, RoAd integrates seamlessly into a distributed interchange intervention framework, interpreting its sparse 2D rotations as task-specific interventions within learned subspaces of hidden representations. These orthogonal subspaces can be composed to merge multiple task-specific behaviors—like multilingual capabilities or instruction following—without additional fine-tuning, enabling modular, interpretable adaptations in LLMs.
+
+Finetuning with RoAd typically requires higher learning rate compared to LoRA or similar methods, around 1e-3. Currently RoAd only supports linear layers and it can be used on models quantized with bitsandbytes (4-bit or 8-bit).
+
+For running inference with different RoAd adapters in the same batch see [Inference with different LoRA adapters in the same batch](lora#inference-with-different-lora-adapters-in-the-same-batch).
+
+## Benchmark overview
+
+
+
+# API
+
+## RoadConfig
+
+[[autodoc]] tuners.road.config.RoadConfig
+
+## RoadModel
+
+[[autodoc]] tuners.road.model.RoadModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/shira.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/shira.md
new file mode 100644
index 0000000000000000000000000000000000000000..05d12dd26346c9ac27d307c8c8c9662e2af3400a
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/shira.md
@@ -0,0 +1,46 @@
+
+
+# Sparse High Rank Adapters
+
+Sparse High Rank Adapters or [SHiRA](https://huggingface.co/papers/2406.13175) is an alternate type of adapter and has been found to have significant advantages over the low rank adapters. Specifically, SHiRA achieves better accuracy than LoRA for a variety of vision and language tasks. It also offers simpler and higher quality multi-adapter fusion by significantly reducing concept loss, a common problem faced by low rank adapters. SHiRA directly finetunes a small number of the base model's parameters to finetune the model on any adaptation task.
+
+SHiRA currently has the following constraint:
+
+- Only `nn.Linear` layers are supported.
+
+The abstract from the paper is:
+
+> Low Rank Adaptation (LoRA) has gained massive attention in the recent generative AI research. One of the main advantages of LoRA is its ability to be fused with pretrained models, adding no overhead during inference. However, from a mobile deployment standpoint, we can either avoid inference overhead in the fused mode but lose the ability to switch adapters rapidly, or suffer significant (up to 30% higher) inference latency while enabling rapid switching in the unfused mode. LoRA also exhibits concept-loss when multiple adapters are used concurrently. In this paper, we propose Sparse High Rank Adapters (SHiRA), a new paradigm which incurs no inference overhead, enables rapid switching, and significantly reduces concept-loss. Specifically, SHiRA can be trained by directly tuning only 1-2% of the base model weights while leaving others unchanged. This results in a highly sparse adapter which can be switched directly in the fused mode. We further provide theoretical and empirical insights on how high sparsity in SHiRA can aid multi-adapter fusion by reducing concept loss. Our extensive experiments on LVMs and LLMs demonstrate that finetuning only a small fraction of the parameters in the base model significantly outperforms LoRA while enabling both rapid switching and multi-adapter fusion. Finally, we provide a latency- and memory-efficient SHiRA implementation based on Parameter-Efficient Finetuning (PEFT) Library which trains at nearly the same speed as LoRA while consuming up to 16% lower peak GPU memory, thus making SHiRA easy to adopt for practical use cases. To demonstrate rapid switching benefits during inference, we show that loading SHiRA on a base model can be 5x-16x faster than LoRA fusion on a CPU.
+
+## Benchmark overview
+
+
+
+# API
+
+## ShiraConfig
+
+[[autodoc]] tuners.shira.config.ShiraConfig
+
+## ShiraModel
+
+[[autodoc]] tuners.shira.model.ShiraModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/tinylora.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/tinylora.md
new file mode 100644
index 0000000000000000000000000000000000000000..16bcaf2db7647c5b4ad0ecc21358378c95da6108
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/tinylora.md
@@ -0,0 +1,52 @@
+
+
+# TinyLoRA: Learning to Reason in 13 Parameters
+
+[TinyLoRA](https://huggingface.co/papers/2602.04118) is an extremely parameter-efficient fine-tuning technique that builds upon the [LoRA-XS](https://huggingface.co/papers/2405.17604) approach by using SVD decomposition of frozen weights and projecting a tiny trainable vector through fixed random tensors. When combined with reinforcement learning (RL) training methods like GRPO, TinyLoRA can achieve competitive performance with as few as 1-13 trainable parameters.
+
+The key innovation of TinyLoRA is replacing the trainable low-rank matrix R with a weighted sum of fixed random projection matrices: `R = Σᵢ vᵢ Pᵢ`, where `v ∈ R^u` is a tiny trainable vector of dimension `u` and `Pᵢ` are fixed random matrices. This dramatically reduces the number of trainable parameters while maintaining competitive performance.
+
+TinyLoRA supports weight tying through the `weight_tying` parameter, a ratio between 0.0 and 1.0 that controls how many modules share the same trainable vector `v`. Setting `weight_tying=0.0` (the default) means no sharing, while `weight_tying=1.0` means full sharing across all target modules — achieving extreme parameter efficiency with just a single vector of `u` trainable parameters for the entire model.
+
+When saving the adapter parameters, it's possible to eschew storing the random projection matrices by setting `save_projection=False` on the `TinyLoraConfig`. In that case, these matrices will be restored based on the fixed random seed from the `projection_seed` argument. This cuts down on the size of the checkpoint, but we cannot guarantee reproducibility on all devices and for all future versions of PyTorch. If you want to ensure reproducibility, set `save_projection=True` (which is the default).
+
+TinyLoRA currently has the following constraints:
+
+- Only `nn.Linear`, `nn.Embedding`, and `transformers.pytorch_utils.Conv1D` layers are supported.
+
+The abstract from the paper is:
+
+> Recent research has shown that language models can learn to reason, often via reinforcement learning. Some work even trains low-rank parameterizations for reasoning, but conventional LoRA cannot scale below the model dimension. We question whether even rank=1 LoRA is necessary for learning to reason and propose TinyLoRA, a method for scaling low-rank adapters to sizes as small as one parameter. Within our new parameterization, we are able to train the 8B parameter size of Qwen2.5 to 91% accuracy on GSM8K with only 13 trained parameters in bf16 (26 total bytes). We find this trend holds in general: we are able to recover 90% of performance improvements while training 1000x fewer parameters across a suite of more difficult learning-to-reason benchmarks such as AIME, AMC, and MATH500. Notably, we are only able to achieve such strong performance with RL: models trained using SFT require 100-1000x larger updates to reach the same performance.
+
+## Benchmark overview
+
+
+
+# API
+
+## TinyLoraConfig
+
+[[autodoc]] tuners.tinylora.config.TinyLoraConfig
+
+## TinyLoraModel
+
+[[autodoc]] tuners.tinylora.model.TinyLoraModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/trainable_tokens.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/trainable_tokens.md
new file mode 100644
index 0000000000000000000000000000000000000000..42d22a3f743a943936be6bccdb690450ef0245d4
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/trainable_tokens.md
@@ -0,0 +1,61 @@
+
+
+# Trainable Tokens
+
+The Trainable Tokens method provides a way to target specific token embeddings for fine-tuning without resorting to
+training the full embedding matrix or using an adapter on the embedding matrix. It is based on the initial implementation from
+[here](https://github.com/huggingface/peft/pull/1541).
+
+The method only targets specific tokens and selectively trains the token indices you specify. Consequently the
+required RAM will be lower and disk memory is also significantly lower than storing the full fine-tuned embedding matrix.
+
+Some preliminary benchmarks acquired with [this script](https://github.com/huggingface/peft/blob/main/scripts/train_memory.py)
+suggest that for `gemma-2-2b` (which has a rather large embedding matrix) you can save ~4 GiB VRAM with Trainable Tokens
+over fully fine-tuning the embedding matrix. While LoRA will use comparable amounts of VRAM it might also target
+tokens you don't want to be changed. Note that these are just indications and varying embedding matrix sizes might skew
+these numbers a bit.
+
+Note that this method does not add tokens for you, you have to add tokens to the tokenizer yourself and resize the
+embedding matrix of the model accordingly. This method will only re-train the embeddings for the tokens you specify.
+This method can also be used in conjunction with LoRA layers! See [the LoRA documentation](lora#efficiently-train-tokens-alongside-lora).
+
+> [!TIP]
+> Saving the model with [`~PeftModel.save_pretrained`] or retrieving the state dict using
+> [`get_peft_model_state_dict`] when adding new tokens may save the full embedding matrix instead of only the difference
+> as a precaution because the embedding matrix was resized. To save space you can disable this behavior by setting
+> `save_embedding_layers=False` when calling `save_pretrained`. This is safe to do as long as you don't modify the
+> embedding matrix through other means as well, as such changes will be not tracked by trainable tokens.
+
+## Benchmark overview
+
+
+
+# API
+
+## TrainableTokensConfig
+
+[[autodoc]] tuners.trainable_tokens.config.TrainableTokensConfig
+
+## TrainableTokensModel
+
+[[autodoc]] tuners.trainable_tokens.model.TrainableTokensModel
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/tuners.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/tuners.md
new file mode 100644
index 0000000000000000000000000000000000000000..ae0594624713def2c67bee0aad7b27a969051ed0
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/tuners.md
@@ -0,0 +1,27 @@
+
+
+# Tuners
+
+A tuner (or adapter) is a module that can be plugged into a `torch.nn.Module`. [`BaseTuner`] base class for other tuners and provides shared methods and attributes for preparing an adapter configuration and replacing a target module with the adapter module. [`BaseTunerLayer`] is a base class for adapter layers. It offers methods and attributes for managing adapters such as activating and disabling adapters.
+
+## BaseTuner
+
+[[autodoc]] tuners.tuners_utils.BaseTuner
+
+## BaseTunerLayer
+
+[[autodoc]] tuners.tuners_utils.BaseTunerLayer
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/vblora.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/vblora.md
new file mode 100644
index 0000000000000000000000000000000000000000..0156d0921c71353ca43c3caa5e39702cb0d64de8
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/vblora.md
@@ -0,0 +1,51 @@
+
+
+# VB-LoRA: Extreme Parameter Efficient Fine-Tuning with Vector Banks
+
+## Overview
+
+[VB-LoRA](https://huggingface.co/papers/2405.15179) is a parameter-efficient fine-tuning technique that extends LoRA by learning a fine-grained parameter-sharing scheme at the sub-vector level, achieving significantly higher parameter efficiency. This makes VB-LoRA especially useful in scenarios where storage and transmission costs are critical. It works by decomposing low-rank matrices—from different layers and modules such as K, Q, V, and FFN—into sub-vectors, which are then globally shared through a vector bank.
+
+The abstract from the paper is:
+
+*As the adoption of large language models increases and the need for per-user or per-task model customization grows, the parameter-efficient fine-tuning (PEFT) methods, such as low-rank adaptation (LoRA) and its variants, incur substantial storage and transmission costs. To further reduce stored parameters, we introduce a "divide-and-share" paradigm that breaks the barriers of low-rank decomposition across matrix dimensions, modules and layers by sharing parameters globally via a vector bank. As an instantiation of the paradigm to LoRA, our proposed VB-LoRA composites all the low-rank matrices of LoRA from a shared vector bank with a differentiable top-k admixture module. VB-LoRA achieves extreme parameter efficiency while maintaining comparable or better performance compared to state-of-the-art PEFT methods. Extensive experiments demonstrate the effectiveness of VB-LoRA on natural language understanding, natural language generation, and instruction tuning tasks. When fine-tuning the Llama2-13B model, VB-LoRA only uses 0.4% of LoRA's stored parameters, yet achieves superior results.*
+
+## Usage Tips
+
+- VB-LoRA utilizes a sparse top-k module to learn the sharing mechanism. When saving adapter parameters, you can either save only the top-k weights and their indices by setting `save_only_topk_weights = True` in `VBLoRAConfig`, or save all the trainable logits by setting it to `False`. Enabling `save_only_topk_weights = True` significantly reduces storage space; for instance, in Llama2-7B, the storage file size decreases from 308MB to 2.5MB. Note that models saved with `save_only_topk_weights = True` are intended for merging or inference only and cannot be used to resume training.
+
+- VB-LoRA has two sets of training parameters: vector bank parameters and logit parameters. In practice, we found that logit parameters require a higher learning rate, while vector bank parameters require a lower learning rate. When using the AdamW optimizer, typical learning rates are 0.01 for logits and 0.001 for vector bank parameters.
+
+## Benchmark overview
+
+
+
+# API
+
+## VBLoRAConfig
+
+[[autodoc]] tuners.vblora.config.VBLoRAConfig
+
+## VBLoRAModel
+
+[[autodoc]] tuners.vblora.model.VBLoRAModel
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/vera.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/vera.md
new file mode 100644
index 0000000000000000000000000000000000000000..58cb69d287116fa2b6e9cbab8d4d54c640033122
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/vera.md
@@ -0,0 +1,50 @@
+
+
+# VeRA: Vector-based Random Matrix Adaptation
+
+[VeRA](https://huggingface.co/papers/2310.11454) is a parameter-efficient fine-tuning technique that is similar to LoRA but requires even fewer extra parameters while promising similar or even better performance. As such, it is particularly useful when the parameter budget is very limited, e.g. when scaling to very large models. The reduction of the count of trainable parameters is achieved by sharing the same low-rank matrices across all layers, and only training two additional vectors per layer.
+
+When saving the adapter parameters, it's possible to eschew storing the low rank matrices by setting `save_projection=False` on the `VeraConfig`. In that case, these matrices will be restored based on the fixed random seed from the `projection_prng_key` argument. This cuts down on the size of the checkpoint, but we cannot guarantee reproducibility on all devices and for all future versions of PyTorch. If you want to ensure reproducibility, set `save_projection=True` (which is the default).
+
+To handle different shapes of adapted layers, VeRA initializes shared A and B matrices with the largest required size for each dimension. During the forward pass, submatrices A and B for a given layer are sliced out from these shared matrices and used as described in the paper. For example, adapting two linear layers of shapes (100, 20) and (80, 50) will create A and B matrices of shapes (rank, 50) and (100, rank) respectively. Then, to adapt a layer of shape (100, 20), submatrices A and B of shapes (rank, 20) and (100, rank) will be extracted.
+
+VeRA currently has the following constraint:
+
+- Only `nn.Linear` layers are supported.
+
+The abstract from the paper is:
+
+> Low-rank adaptation (LoRA) is a popular method that reduces the number of trainable parameters when finetuning large language models, but still faces acute storage challenges when scaling to even larger models or deploying numerous per-user or per-task adapted models. In this work, we present Vector-based Random Matrix Adaptation (VeRA), which significantly reduces the number of trainable parameters compared to LoRA, yet maintains the same performance. It achieves this by using a single pair of low-rank matrices shared across all layers and learning small scaling vectors instead. We demonstrate its effectiveness on the GLUE and E2E benchmarks, image classification tasks, and show its application in instruction-tuning of 7B and 13B language models.
+
+## Benchmark overview
+
+
+
+# API
+
+## VeRAConfig
+
+[[autodoc]] tuners.vera.config.VeraConfig
+
+## VeRAModel
+
+[[autodoc]] tuners.vera.model.VeraModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/waveft.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/waveft.md
new file mode 100644
index 0000000000000000000000000000000000000000..434b25b6d644e20a91d3158a7b1b980e196be0b8
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/waveft.md
@@ -0,0 +1,46 @@
+
+
+# WaveFT: Wavelet Fine-Tuning
+
+[WaveFT](https://huggingface.co/papers/2505.12532) is a novel parameter-efficient fine-tuning (PEFT) method that introduces sparse updates in the **wavelet domain** of residual matrices. Unlike LoRA, which is constrained by discrete low-rank choices, WaveFT enables fine-grained control over the number of trainable parameters by directly learning a sparse set of coefficients in the transformed space. These coefficients are then mapped back to the weight domain via the Inverse Discrete Wavelet Transform (IDWT), producing high-rank updates without incurring inference overhead.
+
+WaveFT currently has the following constraint:
+
+- Only `nn.Linear` layers are supported.
+
+The abstract from the paper is:
+
+>Efficiently adapting large foundation models is critical, especially with tight compute and memory budgets. Parameter-Efficient Fine-Tuning (PEFT) methods such as LoRA offer limited granularity and effectiveness in few-parameter regimes. We propose Wavelet Fine-Tuning (WaveFT), a novel PEFT method that learns highly sparse updates in the wavelet domain of residual matrices. WaveFT allows precise control of trainable parameters, offering fine-grained capacity adjustment and excelling with remarkably low parameter count, potentially far fewer than LoRA’s minimum—ideal for extreme parameter-efficient scenarios. Evaluated on personalized text-to-image generation using Stable Diffusion XL as baseline, WaveFT significantly outperforms LoRA and other PEFT methods, especially at low parameter counts; achieving superior subject fidelity, prompt alignment, and image diversity.
+
+## Benchmark overview
+
+
+
+# API
+
+## WaveFTConfig
+
+[[autodoc]] tuners.waveft.config.WaveFTConfig
+
+## WaveFTModel
+
+[[autodoc]] tuners.waveft.model.WaveFTModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/xlora.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/xlora.md
new file mode 100644
index 0000000000000000000000000000000000000000..0ebfb744d0501e14c0a4e6395c759173ac1030f5
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/package_reference/xlora.md
@@ -0,0 +1,62 @@
+
+
+# X-LoRA
+
+Mixture of LoRA Experts ([X-LoRA](https://huggingface.co/papers/2402.07148)) is a PEFT method enabling sparse or dense mixture of LoRA experts based on a high granularity (token, layer, sequence) scalings matrix. This leverages frozen LoRA adapters and a frozen base model to drastically reduces the number of parameters that need to be fine-tuned.
+
+A unique aspect of X-LoRA is its versatility: it can be applied to any `transformers` base model with LoRA adapters. This means that, despite the mixture of experts strategy, no changes to the model code must be made.
+
+The below graphic demonstrates how the scalings change for different prompts for each token. This highlights the activation of different adapters as the generation progresses and the sequence creates new context.
+
+
+
+For each step, X-LoRA requires the base model to be run twice: first, to get hidden states without any LoRA adapters, and secondly, the hidden states are used to calculate scalings which are applied to the LoRA adapters and the model is run a second time. The output of the second run is the result of the model step.
+
+Ultimately, X-LoRA allows the model to reflect upon its knowledge because of the dual forward pass scheme, and dynamically reconfigure the architecture.
+
+The abstract from the paper is:
+
+*We report a mixture of expert strategy to create fine-tuned large language models using a deep layer-wise token-level approach based on low-rank adaptation (LoRA). Starting with a set of pre-trained LoRA adapters, our gating strategy uses the hidden states to dynamically mix adapted layers, allowing the resulting X-LoRA model to draw upon different capabilities and create never-before-used deep layer-wise combinations to solve tasks. The design is inspired by the biological principles of universality and diversity, where neural network building blocks are reused in different hierarchical manifestations. Hence, the X-LoRA model can be easily implemented for any existing large language model (LLM) without a need for modifications of the underlying structure. We develop a tailored X-LoRA model that offers scientific capabilities including forward/inverse analysis tasks and enhanced reasoning capability, focused on biomaterial analysis, protein mechanics and design. The impact of this work include access to readily expandable and adaptable models with strong domain knowledge and the capability to integrate across areas of knowledge. Featuring experts in biology, mathematics, reasoning, bio-inspired materials, mechanics and materials, chemistry, protein biophysics, mechanics and quantum-mechanics based molecular properties, we conduct a series of physics-focused case studies. We examine knowledge recall, protein mechanics forward/inverse tasks, protein design, adversarial agentic modeling including ontological knowledge graph construction, as well as molecular design. The model is capable not only of making quantitative predictions of nanomechanical properties of proteins or quantum mechanical molecular properties, but also reasons over the results and correctly predicts likely mechanisms that explain distinct molecular behaviors.*.
+
+Please cite X-LoRA as:
+```bibtex
+@article{10.1063/5.0203126,
+ author = {Buehler, Eric L. and Buehler, Markus J.},
+ title = "{X-LoRA: Mixture of low-rank adapter experts, a flexible framework for large language models with applications in protein mechanics and molecular design}",
+ journal = {APL Machine Learning},
+ volume = {2},
+ number = {2},
+ pages = {026119},
+ year = {2024},
+ month = {05},
+ abstract = "{We report a mixture of expert strategy to create fine-tuned large language models using a deep layer-wise token-level approach based on low-rank adaptation (LoRA). Starting with a set of pre-trained LoRA adapters, our gating strategy uses the hidden states to dynamically mix adapted layers, allowing the resulting X-LoRA model to draw upon different capabilities and create never-before-used deep layer-wise combinations to solve tasks. The design is inspired by the biological principles of universality and diversity, where neural network building blocks are reused in different hierarchical manifestations. Hence, the X-LoRA model can be easily implemented for any existing large language model without a need for modifications of the underlying structure. We develop a tailored X-LoRA model that offers scientific capabilities, including forward/inverse analysis tasks and enhanced reasoning capability, focused on biomaterial analysis, protein mechanics, and design. The impact of this work includes access to readily expandable and adaptable models with strong domain knowledge and the capability to integrate across areas of knowledge. Featuring experts in biology, mathematics, reasoning, bio-inspired materials, mechanics and materials, chemistry, protein biophysics, mechanics, and quantum-mechanics based molecular properties, we conduct a series of physics-focused case studies. We examine knowledge recall, protein mechanics forward/inverse tasks, protein design, adversarial agentic modeling including ontological knowledge graph construction, and molecular design. The model is capable not only of making quantitative predictions of nanomechanical properties of proteins or quantum mechanical molecular properties but also reasoning over the results and correctly predicting likely mechanisms that explain distinct molecular behaviors.}",
+ issn = {2770-9019},
+ doi = {10.1063/5.0203126},
+ url = {https://doi.org/10.1063/5.0203126},
+ eprint = {https://pubs.aip.org/aip/aml/article-pdf/doi/10.1063/5.0203126/19964043/026119\_1\_5.0203126.pdf},
+}
+```
+
+# API
+
+## XLoraConfig
+
+[[autodoc]] tuners.xlora.config.XLoraConfig
+
+## XLoraModel
+
+[[autodoc]] tuners.xlora.model.XLoraModel
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/quicktour.md b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/quicktour.md
new file mode 100644
index 0000000000000000000000000000000000000000..38830da9f8ce56cb1751e3bc24ee3b32a586ee31
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/docs/source/quicktour.md
@@ -0,0 +1,230 @@
+
+
+# Quicktour
+
+PEFT offers parameter-efficient methods for finetuning large pretrained models. The traditional paradigm is to finetune all of a model's parameters for each downstream task, but this is becoming exceedingly costly and impractical because of the enormous number of parameters in models today. Instead, it is more efficient to train a smaller number of prompt parameters or use a reparametrization method like low-rank adaptation (LoRA) to reduce the number of trainable parameters.
+
+
+
+ PEFT can be thought of as a framework for adding trainable parameters to arbitrary places in existing models ("base models"). Specific PEFT methods arrange the trainable parameters in certain ways or modify the training process to achieve fine-tuning performance comparable to training all parameters of the base model.
+
+
+
+
+This quicktour will show you PEFT's main features and how you can train or run inference on large models that would typically be inaccessible on consumer devices.
+
+
+## PEFT configuration and model
+
+For any PEFT method, you'll need to create a configuration which contains all the parameters that specify how the PEFT method should be applied, most importantly which layers of the existing model to target with trainable parameters. Once the configuration is setup, pass it to the [`~peft.get_peft_model`] function along with the base model to create a trainable [`PeftModel`].
+
+Let's use [LoRA](./package_reference/lora) as an example but only discuss common parameters - you might want to use one of the [many other PEFT methods](./methods/overview).
+The configuration usually entails this:
+
+- `target_modules`: which modules of the base model to adapt
+- `task_type` (default: `None`, see [available `TaskType`s](package_reference/peft_types#peft.TaskType)): the nature of the trained task; if provided may help to automatically save relevant layers alongside the adapter weights or warn you about incompatibilities
+- `inference_mode` (default: `False`): whether you're using the model for inference or not
+
+Depending on the PEFT method you choose you will add specific parameters that, for example, determine the size of the update matrices.
+Here's an example of a config you may encounter in the wild:
+
+```python
+from peft import LoraConfig, TaskType
+
+peft_config = LoraConfig(target_modules=["q_proj"], task_type=TaskType.CAUSAL_LM, inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1)
+```
+
+> [!TIP]
+> See the [configuration guide](guides/peft_model_config) for more details on how the PEFT configuration works under the hood.
+
+Once the [`LoraConfig`] is set up, create a [`PeftModel`] with the [`get_peft_model`] function. It takes a base model - which you can (but don't have to) load from the Transformers library - and the [`LoraConfig`] containing the parameters for how to configure a model for training with LoRA.
+
+Load the base model you want to finetune.
+
+```python
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-1B")
+```
+
+Now wrap the base model and `peft_config` with the [`get_peft_model`] function to create a [`PeftModel`].
+
+
+
+
+ Wrapping means that PEFT replaces the targeted layers (here: all q_proj layers) with the adapter-specific layer for the target layer's type. Since we're dealing with linear layers, it will be, in this case, a lora.Linear layer. Note that these changes are done in-place to save memory, so your base model is now modified.
+
+
+ Note that we've only specified q_proj but in actuality we are targeting all model.layers[:].self_attn.q_proj layers. This is because PEFT searches for matching suffixes by default. Pass a string with a regular expression if you want to target more complex layer patterns.
+
+
+
+
+
+
+
+
+
+ The base model's layer will be wrapped, retained and not trained while new, trainable weights are added and are combined. How these new weights are structured and combined with the weights of the base model is a good portion of what sets the different PEFT methods apart.
+
+
+
+
+To get a sense of the number of trainable parameters in your model, use the [`print_trainable_parameters`] method.
+
+```python
+from peft import get_peft_model
+
+peft_model = get_peft_model(model, peft_config)
+peft_model.print_trainable_parameters()
+"output: trainable params: 524,288 || all params: 1,236,338,688 || trainable%: 0.0424"
+```
+
+Out of [meta-llama/Llama-3.2-1B's](https://huggingface.co/meta-llama/Llama-3.2-1B) 1B parameters, you're only training 0.04% of them!
+
+That is it 🎉! Now you can train the model with the Transformers [`~transformers.Trainer`], Accelerate, or any custom PyTorch training loop.
+
+For example, to train with the [`~transformers.Trainer`] class, setup a [`~transformers.TrainingArguments`] class with some training hyperparameters.
+
+```py
+training_args = TrainingArguments(
+ output_dir="your-name/meta-llama/my-llama3.2-adapter",
+ learning_rate=1e-3,
+ per_device_train_batch_size=32,
+ per_device_eval_batch_size=32,
+ num_train_epochs=2,
+ weight_decay=0.01,
+ eval_strategy="epoch",
+ save_strategy="epoch",
+ load_best_model_at_end=True,
+)
+```
+
+Pass the model, training arguments, dataset, tokenizer, and any other necessary component to the [`~transformers.Trainer`], and call [`~transformers.Trainer.train`] to start training.
+
+```py
+trainer = Trainer(
+ model=peft_model,
+ args=training_args,
+ train_dataset=tokenized_datasets["train"],
+ eval_dataset=tokenized_datasets["test"],
+ data_collator=data_collator,
+ compute_metrics=compute_metrics,
+)
+
+trainer.train()
+```
+
+### Save model
+
+After your model is finished training, you can save your model to a directory using the [`~PeftModel.save_pretrained`] function.
+
+```py
+peft_model.save_pretrained("output_dir")
+```
+
+You can also save your model to the Hub (make sure you're logged in to your Hugging Face account first) with the [`~transformers.PreTrainedModel.push_to_hub`] function.
+
+```python
+from huggingface_hub import notebook_login
+
+notebook_login()
+peft_model.push_to_hub("your-name/my-llama3.2-adapter")
+```
+
+Both methods only save the extra PEFT weights that were trained, meaning it is super efficient to store, transfer, and load. For example, this [facebook/opt-350m](https://huggingface.co/ybelkada/opt-350m-lora) model trained with LoRA only contains two files: `adapter_config.json` and `adapter_model.safetensors`. The `adapter_model.safetensors` file is just 6.3MB!
+
+
+
+ The adapter weights for a opt-350m model stored on the Hub are only ~6MB compared to the full size of the model weights, which can be ~700MB.
+
+
+## Inference
+
+> [!TIP]
+> Take a look at the [AutoPeftModel](package_reference/auto_class) API reference for a complete list of available `AutoPeftModel` classes.
+
+Easily load any PEFT-trained model for inference with the [`AutoPeftModel`] class and the [`~transformers.PreTrainedModel.from_pretrained`] method:
+
+```py
+from peft import AutoPeftModelForCausalLM
+from transformers import AutoTokenizer
+import torch
+
+peft_model = AutoPeftModelForCausalLM.from_pretrained("ybelkada/opt-350m-lora")
+tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
+
+peft_model = peft_model.to("cuda")
+peft_model.eval()
+inputs = tokenizer("Preheat the oven to 350 degrees and place the cookie dough", return_tensors="pt")
+
+outputs = peft_model.generate(input_ids=inputs["input_ids"].to("cuda"), max_new_tokens=50)
+print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True)[0])
+
+"Preheat the oven to 350 degrees and place the cookie dough in the center of the oven. In a large bowl, combine the flour, baking powder, baking soda, salt, and cinnamon. In a separate bowl, combine the egg yolks, sugar, and vanilla."
+```
+
+For other tasks that aren't explicitly supported with an `AutoPeftModelFor` class - such as automatic speech recognition - you can still use the base [`AutoPeftModel`] class to load a model for the task.
+
+```py
+from peft import AutoPeftModel
+
+peft_model = AutoPeftModel.from_pretrained("smangrul/openai-whisper-large-v2-LORA-colab")
+```
+
+The most general way of loading a trained PEFT adapter onto a model is to use [`~PeftModel.from_pretrained`]:
+
+```py
+from transformers import AutoPeftModelForCausalLM
+from peft import PeftModel
+
+base_model = AutoModelForCausalLM.from_pretrained("meta-llama/llama3.2-1B")
+peft_model = PeftModel.from_pretrained(base_model, "my-user/my-llama-adapter") # you can also pass a directory instead of a hub path
+```
+
+## Multiple adapters
+
+PEFT supports installing multiple adapters (of the same kind, in this document this would be LoRA) on top of a base model. When you call `get_peft_model` there is only one adapter named `"default"` but you can add as many additional adapters as you want by calling `peft_model.add_adapter(adapter_name=...)`.
+
+
+
+
+ This works because the wrapped layer actually has a unique set of trainable weights for each adapter name. Not every adapter is active and trainable by default. You have to explicitly enable adapters by name before they are active. This allows you to quickly swap between adapters where task-specific knowledge is needed or serve different use-cases on top of one model.
+
+
+
+
+
+Just remember to call `peft_model.set_adapter()` first to enable the adapter.
+
+Quick example:
+
+```py
+peft_model.add_adapter(adapter_name='new_adapter')
+peft_model.set_adapter('new_adapter')
+```
+
+## Next steps
+
+Now that you've seen how to train a model with one of the PEFT methods, we encourage you to try out some of the other methods like prompt tuning. The steps are very similar to the ones shown in the quicktour:
+
+1. prepare a [`PeftConfig`] for a PEFT method, e.g. a [`LoraConfig`] or some other config (see the [method overview](methods/overview))
+2. use the [`get_peft_model`] method to create a [`PeftModel`] from the configuration and base model
+
+Then you can train it however you like! To load a PEFT model for inference, you can use the [`AutoPeftModel`] class.
+
+Feel free to also take a look at the task guides if you're interested in training a model with another PEFT method for a specific task such as semantic segmentation, multilingual automatic speech recognition, DreamBooth, token classification, and more.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/KappaTune/README.md b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/KappaTune/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..92c0059284e25064d8efcf2e6cec3b15b2f5c733
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/KappaTune/README.md
@@ -0,0 +1,215 @@
+# KappaTune Experiment
+
+This script compares different fine-tuning strategies on a downstream task (gsm8k) while measuring **catastrophic forgetting** on a general-knowledge control dataset (WikiText). For further details see the [KappaTune paper](https://arxiv.org/abs/2506.16289).
+
+- **Baseline**: No adaptation
+- **LoRA_Global**: Classic LoRA on common projections (`q_proj`, `k_proj`, `o_proj`, `v_proj`, `gate_proj`, `up_proj`, `down_proj` )
+- **KappaTune_LoRA**: The new `KappaTuneSelector` with relative selection (`top_p=0.2`)
+
+The goal is to show that KappaTune achieves similar task adaptation **while forgetting less** of the original pre-trained knowledge.
+
+KappaTune is recommended when catastrophic forgetting is a concern. If your fine-tuning data is closely aligned with the model's pretraining distribution, it can even decrease general/Wiki perplexity. This is the case of fine-tuning on math data like GSM8K (adopted in this experiment) for some models. Then unrestricted LoRA over all layers may yield better results, since it reinforces pre-training.
+
+### Key hyperparameters to play with
+
+| Hyperparameter | Location | Default | What it controls | Recommendation |
+|-------------------------------|-----------------------------------|------------------|-------------------------------------------------------|-----------------------------------------------------|
+| `top_p` | KappaTune block | `0.2` | Fraction of best (lowest κ) modules selected | 0.1–0.3 (lower = more conservative) |
+| `num_modules` | KappaTune block (alternative) | `None` | Fixed number of modules | Use instead of `top_p` for strict budget |
+| `r` (rank) | Both LoRA configs | `16` / `190` | LoRA rank (controls trainable parameters) | Keep total trainable params similar between runs |
+| `LR` (learning rate) | Top of script | `2e-4` | Training speed and stability | 1e-4 – 5e-4 |
+| `num_train_epochs` | Top of script | `10` | Total training steps | Increase for stronger adaptation |
+| `MODEL_ID` | Top of script | DeepSeek-V2-Lite | Base model | Try Mistral, Qwen, etc. MoE yields the best results |
+| `max_dim_size_to_analyze` | `KappaTuneSelector` | `16384` | Max matrix size for SVD (memory / speed trade-off) | Increase only if you have very high VRAM |
+
+## Expected results
+
+Running the script with default parameters produces the following behavior.
+
+
+KappaTune (training log)
+
+```text
+========================================
+>>> EXPERIMENT: KappaTune_LoRA
+========================================
+[KappaTune] Selecting target modules using PEFT KappaTuneSelector...
+trainable params: 219,188,480 (0.47%)
+#trainable tensors: 370
+#trainable params: 219,188,480
+{'loss': 1.2208, 'grad_norm': 0.15972940623760223, 'learning_rate': 0.00019666666666666666, 'epoch': 0.87}
+{'loss': 1.07, 'grad_norm': 0.26267319917678833, 'learning_rate': 0.00019250000000000002, 'epoch': 1.7}
+{'loss': 1.0124, 'grad_norm': 0.2723085284233093, 'learning_rate': 0.00018833333333333335, 'epoch': 2.52}
+{'loss': 0.9436, 'grad_norm': 0.29701513051986694, 'learning_rate': 0.00018416666666666665, 'epoch': 3.35}
+{'loss': 0.9114, 'grad_norm': 0.3046768009662628, 'learning_rate': 0.00018, 'epoch': 4.17}
+{'loss': 0.8915, 'grad_norm': 0.47676295042037964, 'learning_rate': 0.00017583333333333334, 'epoch': 5.0}
+{'loss': 0.8728, 'grad_norm': 0.24124978482723236, 'learning_rate': 0.00017166666666666667, 'epoch': 5.87}
+{'loss': 0.8385, 'grad_norm': 0.20988021790981293, 'learning_rate': 0.0001675, 'epoch': 6.7}
+{'loss': 0.8389, 'grad_norm': 0.21968263387680054, 'learning_rate': 0.00016333333333333334, 'epoch': 7.52}
+{'loss': 0.8224, 'grad_norm': 0.04499625042080879, 'learning_rate': 0.00015916666666666667, 'epoch': 8.35}
+{'loss': 0.7997, 'grad_norm': 0.05307907983660698, 'learning_rate': 0.000155, 'epoch': 9.17}
+{'loss': 0.8057, 'grad_norm': 0.05258958786725998, 'learning_rate': 0.00015083333333333333, 'epoch': 10.0}
+{'loss': 0.7907, 'grad_norm': 0.05647141858935356, 'learning_rate': 0.00014666666666666666, 'epoch': 10.87}
+{'loss': 0.7804, 'grad_norm': 0.07924238592386246, 'learning_rate': 0.00014250000000000002, 'epoch': 11.7}
+{'loss': 0.7705, 'grad_norm': 0.03199317678809166, 'learning_rate': 0.00013833333333333333, 'epoch': 12.52}
+{'loss': 0.76, 'grad_norm': 0.030626816675066948, 'learning_rate': 0.00013416666666666666, 'epoch': 13.35}
+{'loss': 0.7456, 'grad_norm': 0.03376801684498787, 'learning_rate': 0.00013000000000000002, 'epoch': 14.17}
+{'loss': 0.7352, 'grad_norm': 0.045162301510572433, 'learning_rate': 0.00012583333333333335, 'epoch': 15.0}
+{'loss': 0.7221, 'grad_norm': 0.04105797037482262, 'learning_rate': 0.00012166666666666667, 'epoch': 15.87}
+{'loss': 0.7118, 'grad_norm': 0.04653630033135414, 'learning_rate': 0.00011750000000000001, 'epoch': 16.7}
+{'loss': 0.7071, 'grad_norm': 0.0477643646299839, 'learning_rate': 0.00011333333333333334, 'epoch': 17.52}
+{'loss': 0.67, 'grad_norm': 0.05408667400479317, 'learning_rate': 0.00010916666666666666, 'epoch': 18.35}
+{'loss': 0.6753, 'grad_norm': 0.05562206730246544, 'learning_rate': 0.000105, 'epoch': 19.17}
+{'loss': 0.6529, 'grad_norm': 0.08778411149978638, 'learning_rate': 0.00010083333333333334, 'epoch': 20.0}
+{'loss': 0.6356, 'grad_norm': 0.07903064042329788, 'learning_rate': 9.666666666666667e-05, 'epoch': 20.87}
+{'loss': 0.6198, 'grad_norm': 0.08349727094173431, 'learning_rate': 9.250000000000001e-05, 'epoch': 21.7}
+{'loss': 0.604, 'grad_norm': 0.08645208925008774, 'learning_rate': 8.833333333333333e-05, 'epoch': 22.52}
+{'loss': 0.5897, 'grad_norm': 0.09194190055131912, 'learning_rate': 8.416666666666668e-05, 'epoch': 23.35}
+{'loss': 0.5649, 'grad_norm': 0.10126981139183044, 'learning_rate': 8e-05, 'epoch': 24.17}
+{'loss': 0.5483, 'grad_norm': 0.13687381148338318, 'learning_rate': 7.583333333333334e-05, 'epoch': 25.0}
+{'loss': 0.5323, 'grad_norm': 0.13106191158294678, 'learning_rate': 7.166666666666667e-05, 'epoch': 25.87}
+{'loss': 0.5147, 'grad_norm': 0.1281006783246994, 'learning_rate': 6.750000000000001e-05, 'epoch': 26.7}
+{'loss': 0.4941, 'grad_norm': 0.1377001851797104, 'learning_rate': 6.333333333333333e-05, 'epoch': 27.52}
+{'loss': 0.4845, 'grad_norm': 0.14247003197669983, 'learning_rate': 5.916666666666667e-05, 'epoch': 28.35}
+{'loss': 0.4669, 'grad_norm': 0.14682190120220184, 'learning_rate': 5.500000000000001e-05, 'epoch': 29.17}
+{'loss': 0.454, 'grad_norm': 0.19749927520751953, 'learning_rate': 5.0833333333333333e-05, 'epoch': 30.0}
+{'loss': 0.4323, 'grad_norm': 0.1622404158115387, 'learning_rate': 4.666666666666667e-05, 'epoch': 30.87}
+{'loss': 0.4274, 'grad_norm': 0.15755769610404968, 'learning_rate': 4.25e-05, 'epoch': 31.7}
+{'loss': 0.4086, 'grad_norm': 0.1696886271238327, 'learning_rate': 3.8333333333333334e-05, 'epoch': 32.52}
+{'loss': 0.4006, 'grad_norm': 0.14865559339523315, 'learning_rate': 3.4166666666666666e-05, 'epoch': 33.35}
+{'loss': 0.3934, 'grad_norm': 0.14790022373199463, 'learning_rate': 3e-05, 'epoch': 34.17}
+{'loss': 0.3777, 'grad_norm': 0.20866677165031433, 'learning_rate': 2.5833333333333336e-05, 'epoch': 35.0}
+{'loss': 0.3712, 'grad_norm': 0.17520156502723694, 'learning_rate': 2.1666666666666667e-05, 'epoch': 35.87}
+{'loss': 0.3668, 'grad_norm': 0.16120171546936035, 'learning_rate': 1.75e-05, 'epoch': 36.7}
+{'loss': 0.3583, 'grad_norm': 0.16624851524829865, 'learning_rate': 1.3333333333333333e-05, 'epoch': 37.52}
+{'loss': 0.357, 'grad_norm': 0.15067771077156067, 'learning_rate': 9.166666666666666e-06, 'epoch': 38.35}
+{'loss': 0.3524, 'grad_norm': 0.15819120407104492, 'learning_rate': 5e-06, 'epoch': 39.17}
+{'loss': 0.3466, 'grad_norm': 0.1855546236038208, 'learning_rate': 8.333333333333333e-07, 'epoch': 40.0}
+{'train_runtime': 2871.3103, 'train_samples_per_second': 12.538, 'train_steps_per_second': 0.084, 'train_loss': 0.6427203471461932, 'epoch': 40.0}
+
+========================================
+>>> EXPERIMENT: Baseline
+========================================
+
+========================================
+>>> EXPERIMENT: LoRA_Global
+========================================
+trainable params: 218,103,808 || all params: 46,920,896,512 || trainable%: 0.4648
+{'loss': 1.2122, 'grad_norm': 0.03368454799056053, 'learning_rate': 0.00019666666666666666, 'epoch': 0.87}
+{'loss': 1.0674, 'grad_norm': 0.04771586135029793, 'learning_rate': 0.00019250000000000002, 'epoch': 1.7}
+{'loss': 0.9889, 'grad_norm': 0.030208367854356766, 'learning_rate': 0.00018833333333333335, 'epoch': 2.52}
+{'loss': 0.9269, 'grad_norm': 0.0202629417181015, 'learning_rate': 0.00018416666666666665, 'epoch': 3.35}
+{'loss': 0.9146, 'grad_norm': 0.01595970056951046, 'learning_rate': 0.00018, 'epoch': 4.17}
+{'loss': 0.8983, 'grad_norm': 0.017851779237389565, 'learning_rate': 0.00017583333333333334, 'epoch': 5.0}
+{'loss': 0.8914, 'grad_norm': 0.01525798998773098, 'learning_rate': 0.00017166666666666667, 'epoch': 5.87}
+{'loss': 0.8733, 'grad_norm': 0.01363384909927845, 'learning_rate': 0.0001675, 'epoch': 6.7}
+{'loss': 0.8712, 'grad_norm': 0.014126025140285492, 'learning_rate': 0.00016333333333333334, 'epoch': 7.52}
+{'loss': 0.8673, 'grad_norm': 0.01614651270210743, 'learning_rate': 0.00015916666666666667, 'epoch': 8.35}
+{'loss': 0.8461, 'grad_norm': 0.014323701150715351, 'learning_rate': 0.000155, 'epoch': 9.17}
+{'loss': 0.8519, 'grad_norm': 0.022168157622218132, 'learning_rate': 0.00015083333333333333, 'epoch': 10.0}
+{'loss': 0.8326, 'grad_norm': 0.017714861780405045, 'learning_rate': 0.00014666666666666666, 'epoch': 10.87}
+{'loss': 0.8258, 'grad_norm': 0.01950528658926487, 'learning_rate': 0.00014250000000000002, 'epoch': 11.7}
+{'loss': 0.8142, 'grad_norm': 0.021654563024640083, 'learning_rate': 0.00013833333333333333, 'epoch': 12.52}
+{'loss': 0.803, 'grad_norm': 0.027227576822042465, 'learning_rate': 0.00013416666666666666, 'epoch': 13.35}
+{'loss': 0.7892, 'grad_norm': 0.0281345397233963, 'learning_rate': 0.00013000000000000002, 'epoch': 14.17}
+{'loss': 0.7759, 'grad_norm': 0.04052634909749031, 'learning_rate': 0.00012583333333333335, 'epoch': 15.0}
+{'loss': 0.7614, 'grad_norm': 0.03630959987640381, 'learning_rate': 0.00012166666666666667, 'epoch': 15.87}
+{'loss': 0.7474, 'grad_norm': 0.04881247878074646, 'learning_rate': 0.00011750000000000001, 'epoch': 16.7}
+{'loss': 0.7449, 'grad_norm': 0.04792051389813423, 'learning_rate': 0.00011333333333333334, 'epoch': 17.52}
+{'loss': 0.707, 'grad_norm': 0.059059303253889084, 'learning_rate': 0.00010916666666666666, 'epoch': 18.35}
+{'loss': 0.713, 'grad_norm': 0.05515185743570328, 'learning_rate': 0.000105, 'epoch': 19.17}
+{'loss': 0.6907, 'grad_norm': 0.09590236097574234, 'learning_rate': 0.00010083333333333334, 'epoch': 20.0}
+{'loss': 0.6736, 'grad_norm': 0.07875961065292358, 'learning_rate': 9.666666666666667e-05, 'epoch': 20.87}
+{'loss': 0.663, 'grad_norm': 0.08937060832977295, 'learning_rate': 9.250000000000001e-05, 'epoch': 21.7}
+{'loss': 0.6445, 'grad_norm': 0.0950784757733345, 'learning_rate': 8.833333333333333e-05, 'epoch': 22.52}
+{'loss': 0.6387, 'grad_norm': 0.08285810798406601, 'learning_rate': 8.416666666666668e-05, 'epoch': 23.35}
+{'loss': 0.6182, 'grad_norm': 0.1019740179181099, 'learning_rate': 8e-05, 'epoch': 24.17}
+{'loss': 0.6045, 'grad_norm': 0.1708088219165802, 'learning_rate': 7.583333333333334e-05, 'epoch': 25.0}
+{'loss': 0.5959, 'grad_norm': 0.12375958263874054, 'learning_rate': 7.166666666666667e-05, 'epoch': 25.87}
+{'loss': 0.5877, 'grad_norm': 0.1316744089126587, 'learning_rate': 6.750000000000001e-05, 'epoch': 26.7}
+{'loss': 0.5698, 'grad_norm': 0.11958763003349304, 'learning_rate': 6.333333333333333e-05, 'epoch': 27.52}
+{'loss': 0.5653, 'grad_norm': 0.11063854396343231, 'learning_rate': 5.916666666666667e-05, 'epoch': 28.35}
+{'loss': 0.5502, 'grad_norm': 0.11866016685962677, 'learning_rate': 5.500000000000001e-05, 'epoch': 29.17}
+{'loss': 0.5458, 'grad_norm': 0.1533481925725937, 'learning_rate': 5.0833333333333333e-05, 'epoch': 30.0}
+{'loss': 0.5316, 'grad_norm': 0.13474972546100616, 'learning_rate': 4.666666666666667e-05, 'epoch': 30.87}
+{'loss': 0.5269, 'grad_norm': 0.13297690451145172, 'learning_rate': 4.25e-05, 'epoch': 31.7}
+{'loss': 0.5175, 'grad_norm': 0.13090570271015167, 'learning_rate': 3.8333333333333334e-05, 'epoch': 32.52}
+{'loss': 0.5108, 'grad_norm': 0.1196967139840126, 'learning_rate': 3.4166666666666666e-05, 'epoch': 33.35}
+{'loss': 0.5062, 'grad_norm': 0.13541598618030548, 'learning_rate': 3e-05, 'epoch': 34.17}
+{'loss': 0.4965, 'grad_norm': 0.202300563454628, 'learning_rate': 2.5833333333333336e-05, 'epoch': 35.0}
+{'loss': 0.492, 'grad_norm': 0.14462313055992126, 'learning_rate': 2.1666666666666667e-05, 'epoch': 35.87}
+{'loss': 0.4898, 'grad_norm': 0.1338396966457367, 'learning_rate': 1.75e-05, 'epoch': 36.7}
+{'loss': 0.4833, 'grad_norm': 0.11928340792655945, 'learning_rate': 1.3333333333333333e-05, 'epoch': 37.52}
+{'loss': 0.4805, 'grad_norm': 0.1199464276432991, 'learning_rate': 9.166666666666666e-06, 'epoch': 38.35}
+{'loss': 0.4801, 'grad_norm': 0.1222926527261734, 'learning_rate': 5e-06, 'epoch': 39.17}
+{'loss': 0.4729, 'grad_norm': 0.14248400926589966, 'learning_rate': 8.333333333333333e-07, 'epoch': 40.0}
+{'train_runtime': 2779.2046, 'train_samples_per_second': 12.953, 'train_steps_per_second': 0.086, 'train_loss': 0.7012442946434021, 'epoch': 40.0}
+
+======================================================================
+METHOD | gsm8k PPL (Task train) | gsm8k PPL (Task test) | Wiki PPL (General/control)
+----------------------------------------------------------------------
+KappaTune | 1.4410 | 3.2826 | 13.7780
+Baseline | 3.6899 | 3.4668 | 13.9841
+LoRA_Global | 1.6593 | 3.5648 | 26.6836
+======================================================================
+
+
+```
+
+
+
+## Dense model with varying training effort
+
+Since we are using small datasets, the adaptation effort is small, as is the risk of forgetting. To evaluate catastrophic forgetting during intensive fine-tuning we need big datasets or overfitting a small dataset. Therefore, I ran a set of experiments that track the performance of a dense LLM (Llama 8B) trained on the IMDB dataset over extended epochs, proxying the heavy gradient updates typical of massive datasets. The experiments use the same Python script, changing just these parameters:
+
+```python
+MODEL_ID = "unsloth/Meta-Llama-3.1-8B-Instruct"
+imdb_ds = load_dataset("imdb", split="train[:1000]").train_test_split(test_size=0.1)
+imdb_tokenized = imdb_ds.map(format_imdb).map(
+ lambda x: tokenizer(x["text"], padding="max_length", truncation=True, max_length=256),
+ batched=True, remove_columns=imdb_ds["train"].column_names
+)
+ if method_name == "LoRA_Global":
+ Target_modules = [
+ "q_proj",
+ "k_proj",
+ "v_proj",
+ "o_proj",
+ "gate_proj",
+ "up_proj",
+ "down_proj"
+ ]
+ lora_config = LoraConfig(
+ r=12,
+ target_modules=Target_modules,
+ task_type=TaskType.CAUSAL_LM, lora_dropout=0.05
+ )
+ model = get_peft_model(model, lora_config)
+ model.print_trainable_parameters()
+ LR=2e-4
+ STP= #VAR
+ elif method_name == "KappaTune_LoRA":
+ stable_modules_dic = find_kappa_target_modules(model, top_p=0.2)
+ lora_config = LoraConfig(
+ r=64,
+ target_modules = stable_modules_dic["target_modules"],
+ target_parameters = stable_modules_dic["target_parameters"] if stable_modules_dic["target_parameters"] else None,
+ task_type=TaskType.CAUSAL_LM,
+ lora_dropout=0.05,
+ )
+ model = get_peft_model(model, lora_config)
+ model.print_trainable_parameters()
+ trainable = [(n, p.shape, p.numel()) for n, p in model.named_parameters() if p.requires_grad]
+ LR = 2e-4
+ STP = # VAR
+
+```
+
+The figure below plots task-specific adaptation (IMDB perplexity) against general knowledge retention (control Wiki perplexity). The results reveal a distinct divergence: while both methods perform comparably under light training loads, pushing into deeper convergence exposes KappaTune's structural advantage. As the model tightly fits the target data, standard LoRA exhibits a steep degradation in general knowledge (higher Wiki PPL), whereas KappaTune maintains a significantly flatter trajectory. This demonstrates its superior ability to isolate new learning and mitigate catastrophic forgetting even under sustained training pressure.
+
+
+
+
+
+In case of using this test framework for different experiments, it's worth highlighting that size matters.
+KappaTune shows the strongest gains on larger models (≥7B) and especially on MoE architectures (many independent expert modules). In small, dense models, the benefit is reduced because there is a limited variety of independent tensors to choose from. A fair comparison of catastrophic forgetting should make both methods reach roughly the same level of adaptation to the new task (similar training PPL). Matching on test PPL is not sufficient, because the same test PPL can be achieved through overfitting (more forgetting) or underfitting (less forgetting).
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/KappaTune/experiments_kappatune_peft.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/KappaTune/experiments_kappatune_peft.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce94e1b72fd0d8640f6842d7145ac1053c867f4f
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/KappaTune/experiments_kappatune_peft.py
@@ -0,0 +1,162 @@
+import gc
+import math
+
+import torch
+from datasets import load_dataset
+from transformers import (
+ AutoModelForCausalLM,
+ AutoTokenizer,
+ BitsAndBytesConfig,
+ DataCollatorForLanguageModeling,
+ Trainer,
+ TrainingArguments,
+)
+
+from peft import LoraConfig, TaskType, get_peft_model, prepare_model_for_kbit_training
+from peft.helpers import find_kappa_target_modules
+
+
+# ==========================================
+# 1. Data Preparation
+# ==========================================
+MODEL_ID = "mistralai/Mixtral-8x7B-Instruct-v0.1"
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+tokenizer.pad_token = tokenizer.eos_token
+
+
+def format_gsm8k(example):
+ return {"text": f"Question: {example['question']}\nAnswer: {example['answer']}"}
+
+
+print("Loading and preprocessing datasets...")
+gsm8k_ds = load_dataset("gsm8k", "main", split="train[:1000]").train_test_split(test_size=0.1)
+gsm8k_tokenized = gsm8k_ds.map(format_gsm8k).map(
+ lambda x: tokenizer(x["text"], padding="max_length", truncation=True, max_length=256),
+ batched=True,
+ remove_columns=["question", "answer", "text"],
+)
+
+wiki_ds = load_dataset("wikitext", "wikitext-2-raw-v1", split="test[:400]")
+wiki_tokenized = wiki_ds.filter(lambda x: len(x["text"]) > 20).map(
+ lambda x: tokenizer(x["text"], padding="max_length", truncation=True, max_length=256),
+ batched=True,
+ remove_columns=wiki_ds.column_names,
+)
+
+
+# ==========================================
+# 2. Experiment Engine
+# ==========================================
+def evaluate_perplexity(model, dataset, name="Dataset"):
+ model.eval()
+ total_loss = 0
+ data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+ dataloader = torch.utils.data.DataLoader(dataset, batch_size=2, collate_fn=data_collator)
+
+ with torch.no_grad():
+ for i, batch in enumerate(dataloader):
+ batch = {k: v.to(model.device) for k, v in batch.items()}
+ outputs = model(**batch, use_cache=False)
+ total_loss += outputs.loss.item()
+ if i >= 40:
+ break
+ return math.exp(total_loss / (i + 1))
+
+
+def run_experiment(method_name):
+ print(f"\n{'=' * 40}\n>>> EXPERIMENT: {method_name}\n{'=' * 40}")
+
+ bnb_config = BitsAndBytesConfig(
+ load_in_4bit=True,
+ bnb_4bit_quant_type="nf4",
+ bnb_4bit_compute_dtype=torch.bfloat16,
+ bnb_4bit_use_double_quant=True,
+ )
+
+ model = AutoModelForCausalLM.from_pretrained(
+ MODEL_ID, quantization_config=bnb_config, trust_remote_code=True, device_map="auto"
+ )
+ model = prepare_model_for_kbit_training(model)
+
+ # Configure PEFT based on method
+ if method_name == "LoRA_Global":
+ Target_modules = ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+ lora_config = LoraConfig(r=256, target_modules=Target_modules, task_type=TaskType.CAUSAL_LM, lora_dropout=0.05)
+ model = get_peft_model(model, lora_config)
+ model.print_trainable_parameters()
+ LR = 2e-4
+ STP = 40
+
+ elif method_name == "KappaTune_LoRA":
+ print(" [KappaTune] Selecting target modules using PEFT KappaTuneSelector...")
+
+ # Relative selection‚ works on any architecture
+ stable_modules_dic = find_kappa_target_modules(model, top_p=0.2)
+
+ lora_config = LoraConfig(
+ r=85,
+ target_modules=stable_modules_dic["target_modules"],
+ target_parameters=stable_modules_dic["target_parameters"]
+ if stable_modules_dic["target_parameters"]
+ else None,
+ task_type=TaskType.CAUSAL_LM,
+ lora_dropout=0.05,
+ )
+
+ model = get_peft_model(model, lora_config)
+ model.print_trainable_parameters()
+ trainable = [(n, p.shape, p.numel()) for n, p in model.named_parameters() if p.requires_grad]
+
+ print(f"#trainable tensors: {len(trainable)}")
+ print(f"#trainable params: {sum(x[2] for x in trainable):,}")
+
+ LR = 2e-4
+ STP = 40 # or whatever step count you prefer for fair comparison
+
+ if method_name != "Baseline":
+ args = TrainingArguments(
+ output_dir=f"./{method_name}_out",
+ per_device_train_batch_size=40,
+ gradient_accumulation_steps=4,
+ learning_rate=LR,
+ num_train_epochs=STP,
+ bf16=True,
+ logging_steps=5,
+ save_strategy="no",
+ report_to="none",
+ )
+ trainer = Trainer(
+ model=model,
+ args=args,
+ train_dataset=gsm8k_tokenized["train"],
+ data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+ )
+ trainer.train()
+
+ t_ppl_test = evaluate_perplexity(model, gsm8k_tokenized["test"], "gsm8k")
+ t_ppl_train = evaluate_perplexity(model, gsm8k_tokenized["train"], "gsm8k")
+ f_ppl = evaluate_perplexity(model, wiki_tokenized, "WikiText")
+
+ del model
+ gc.collect()
+ torch.cuda.empty_cache()
+ return t_ppl_test, t_ppl_train, f_ppl
+
+
+# ==========================================
+# 3. Results (same table as paper)
+# ==========================================
+results = {}
+
+results["KappaTune"] = run_experiment("KappaTune_LoRA")
+results["Baseline"] = run_experiment("Baseline")
+results["LoRA_Global"] = run_experiment("LoRA_Global")
+
+print("\n" + "=" * 70)
+print(
+ f"{'METHOD':<15} | {'gsm8k PPL (Task train)':<18} | {'gsm8k PPL (Task test)':<18} | {'Wiki PPL (General/control)':<18}"
+)
+print("-" * 70)
+for m, (tpte, tptr, fp) in results.items():
+ print(f"{m:<15} | {tptr:<18.4f} | {tpte:<18.4f} | {fp:<18.4f}")
+print("=" * 70)
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/adamss_finetuning/README.md b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/adamss_finetuning/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..64176c03ed4c99631acc5c1577e5f7da3c388e43
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/adamss_finetuning/README.md
@@ -0,0 +1,203 @@
+# AdaMSS Fine-tuning
+
+## Introduction
+
+AdaMSS (Adaptive Matrix Decomposition with Subspace Selection) is a parameter-efficient fine-tuning method that decomposes weight matrices using SVD into low-rank subspaces. It uses only **~0.07%** of original trainable parameters (e.g., 59K for ViT-Base vs 86M full fine-tuning) while maintaining competitive performance.
+
+The method optionally supports **ASA** (Adaptive Subspace Allocation) for dynamic subspace selection during training, further improving efficiency and performance.
+
+See the [paper](https://neurips.cc/virtual/2025/poster/119606) for more details.
+
+
+## Installation & Quick Test
+
+Install from local source:
+```bash
+cd peft-main && pip install -e .
+pip install transformers datasets torch torchvision evaluate accelerate scikit-learn
+```
+
+Verify installation:
+```bash
+python -c "from peft import AdamssConfig; print('AdaMSS ready')"
+```
+
+## Detailed Code Explanation
+
+**Core AdaMSS Configuration:**
+```python
+from peft import AdamssConfig, get_peft_model
+
+# Configure AdaMSS with ASA
+config = AdamssConfig(
+ r=100, # SVD rank (full decomposition rank)
+ num_subspaces=10, # Number of subspaces (K) - initial capacity
+ subspace_rank=3, # Rank per subspace (ri) - use 1 for NLU, 3 for Vision
+ target_modules=["query", "value"], # Target attention layers
+ use_asa=True, # Enable Adaptive Subspace Allocation
+ asa_target_subspaces=5, # Target active subspaces (ASA reduces K→5)
+ init_warmup=50, # Start ASA after 50 steps
+ final_warmup=1000, # Complete masking by step 1000
+ mask_interval=100, # Update mask every 100 steps
+ modules_to_save=["classifier"], # Modules to train without decomposition
+)
+peft_model = get_peft_model(model, config)
+```
+
+**Option A – With HuggingFace Trainer (callback):**
+```python
+from peft.tuners.adamss.asa_callback import AdamssAsaCallback
+
+# The callback is a thin wrapper around model.update_and_allocate()
+trainer = Trainer(
+ model=peft_model,
+ callbacks=[AdamssAsaCallback()],
+ # ... other arguments
+)
+trainer.train()
+```
+
+**Option B – Custom training loop (no Trainer needed):**
+```python
+for step, batch in enumerate(dataloader):
+ loss = peft_model(**batch).loss
+ loss.backward()
+ optimizer.step()
+ peft_model.base_model.update_and_allocate(step) # ← all ASA logic in one call
+ optimizer.zero_grad()
+```
+
+**Key Points:**
+- **Parameterization**: Total params = `r × (d_in + d_out)`, split into K subspaces of rank `ri` each
+- **ASA Mechanism**: Dynamically selects `asa_target_subspaces` most important subspaces from initial `num_subspaces`
+- **Warmup Schedule**: ASA gradually increases masking strength from `init_warmup` to `final_warmup`
+- **Vision vs NLU**: Use `subspace_rank=3` for vision, `subspace_rank=1` for NLU tasks
+
+## Use the training example scripts
+
+### Vision Tasks (Image Classification)
+
+Run the provided script with your configuration:
+```bash
+python examples/adamss_finetuning/image_classification_adamss_asa.py \
+ --model_name_or_path google/vit-base-patch16-224-in21k \
+ --dataset_name cifar10 \
+ --adamss_r 100 \
+ --adamss_k 10 \
+ --adamss_ri 3 \
+ --use_asa \
+ --asa_target_subspaces 5 \
+ --output_dir ./output
+```
+
+### NLU Tasks (GLUE Benchmark)
+
+Run GLUE tasks (e.g., CoLA) with ASA:
+```bash
+python examples/adamss_finetuning/glue_adamss_asa_example.py \
+ --dataset_name cola \
+ --adamss_r 100 \
+ --adamss_k 10 \
+ --adamss_ri 1 \
+ --use_asa \
+ --asa_target_subspaces 5 \
+ --num_epochs 100 \
+ --batch_size 32 \
+ --output_dir ./output_cola_asa
+```
+
+Without ASA (fixed K=10):
+```bash
+python examples/adamss_finetuning/glue_adamss_asa_example.py \
+ --dataset_name cola \
+ --adamss_r 100 \
+ --adamss_k 10 \
+ --adamss_ri 1 \
+ --num_epochs 100 \
+ --batch_size 32 \
+ --output_dir ./output_cola_no_asa
+```
+
+### AdamssConfig Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `r` | int | 100 | SVD decomposition rank |
+| `num_subspaces` | int | 10 | Number of subspaces (K) |
+| `subspace_rank` | int | 3 | Rank per subspace (ri) |
+| `target_modules` | list | - | Modules to apply AdaMSS (e.g., ["query", "value"]) |
+| `use_asa` | bool | False | Enable Adaptive Subspace Allocation |
+| `asa_target_subspaces` | int | None | Target active subspaces when ASA enabled |
+| `modules_to_save` | list | None | Modules to train without decomposition |
+
+### AdamssAsaCallback
+
+The ASA callback reads all parameters from `AdamssConfig`. Import it directly:
+
+```python
+from peft.tuners.adamss.asa_callback import AdamssAsaCallback
+```
+
+ASA-related config parameters:
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `init_warmup` | int | 50 | Steps before starting masking |
+| `final_warmup` | int | 1000 | Steps to reach target active subspaces |
+| `mask_interval` | int | 100 | Steps between subspace selection updates |
+| `asa_importance_beta` | float | 0.85 | EMA decay for importance tracking |
+| `asa_uncertainty_beta` | float | 0.85 | EMA decay for uncertainty tracking |
+| `asa_schedule_exponent` | float | 3.0 | Exponent for masking schedule |
+
+
+## Experimental Results
+
+### NLU Tasks (GLUE Benchmark)
+
+Results with AdaMSS + ASA (100 epochs, seed=0):
+
+| Task | Model | AdaMSS Params | Metric | Score |
+|------|-------|---------------|--------|-------|
+| CoLA | RoBERTa-base | 27.0K (ASA K→5) | Matthews | **0.6466** |
+| CoLA | RoBERTa-large | 64.8K (ASA K→5) | Matthews | **0.7093** |
+| MRPC | RoBERTa-base | 27.2K (ASA K→5) | Accuracy | **0.8824** |
+| MRPC | RoBERTa-large | 66.7K (ASA K→5) | Accuracy | **0.9044** |
+
+**Notes:**
+- Configuration: r=100, K=10→5 (ASA), ri=1
+- AdaMSS active params with ASA (5 out of 10 subspaces selected)
+- Full AdaMSS capacity: 97K (large) / 42K (base)
+- Training: 100 epochs, batch_size=32, warmup_ratio=0.06
+
+### Vision Tasks (Image Classification)
+
+Results with AdaMSS on Stanford Cars (10 epochs, seed=0):
+
+| Model | Method | AdaMSS Params | Test Accuracy |
+|-------|--------|---------------|---------------|
+| ViT-Base | AdaMSS (no ASA) | 121K (K=10) | **82.15%** |
+| ViT-Base | AdaMSS + ASA | 75.0K (K→5) | **80.45%** |
+
+**Notes:**
+- Configuration: r=100, K=10, ri=3, 10 epochs, batch_size=32
+- ASA dynamically selects 5 out of 10 subspaces (75K active from 121K total)
+
+
+
+## Citation
+
+If you use AdaMSS in your research, please cite:
+
+```bibtex
+@inproceedings{zheng2025adamss,
+ title={AdaMSS: Adaptive Multi-Subspace Approach for Parameter-Efficient Fine-Tuning},
+ author={Zheng, Jingjing and Lu, Wanglong and Dong, Yiming and Ji, Chaojie and Cao, Yankai and Lin, Zhouchen},
+ booktitle={The Thirty-ninth Annual Conference on Neural Information Processing Systems},
+ year={2025},
+}
+```
+
+## Reference
+
+- [AdaMSS Paper](https://neurips.cc/virtual/2025/loc/san-diego/poster/119606)
+- [PEFT Documentation](https://huggingface.co/docs/peft)
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/adamss_finetuning/glue_adamss_asa_example.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/adamss_finetuning/glue_adamss_asa_example.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed5728b7ca869009ac434259dd54c1e7fe45554c
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/adamss_finetuning/glue_adamss_asa_example.py
@@ -0,0 +1,382 @@
+"""
+GLUE Task Fine-tuning with AdaMSS and ASA
+
+This script demonstrates how to fine-tune RoBERTa on GLUE tasks using AdaMSS
+with Adaptive Subspace Allocation (ASA) for efficient parameter updates.
+
+Example usage:
+ # CoLA with RoBERTa-base, 100 epochs
+ python glue_adamss_asa_example.py --dataset_name cola --num_epochs 100 --seed 0
+
+ # With ASA enabled (K: 10→5)
+ python glue_adamss_asa_example.py --dataset_name cola --num_epochs 100 --use_asa --asa_target_subspaces 5
+
+ # MRPC with RoBERTa-large
+ python glue_adamss_asa_example.py --dataset_name mrpc --model_name_or_path roberta-large --num_epochs 10
+
+Requirements:
+ pip install peft transformers datasets torch evaluate scikit-learn
+"""
+
+from dataclasses import dataclass, field
+
+import evaluate
+import numpy as np
+import torch
+from datasets import load_dataset
+from torch.optim import AdamW
+from transformers import (
+ AutoModelForSequenceClassification,
+ AutoTokenizer,
+ EvalPrediction,
+ HfArgumentParser,
+ Trainer,
+ TrainingArguments,
+)
+
+from peft import AdamssConfig, get_peft_model
+from peft.tuners.adamss.asa_callback import AdamssAsaCallback
+
+
+# Table 19: Hyperparameters for GLUE tasks (from paper)
+HYPERPARAMS = {
+ "roberta-base": {
+ "sst2": {"lr": 0.001, "head_lr": 0.005, "wd": 0.0005},
+ "mrpc": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.0},
+ "cola": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005},
+ "qnli": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005},
+ "rte": {"lr": 0.0005, "head_lr": 0.005, "wd": 0.005},
+ "stsb": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005},
+ },
+ "roberta-large": {
+ "sst2": {"lr": 0.001, "head_lr": 0.0005, "wd": 0.0},
+ "mrpc": {"lr": 0.001, "head_lr": 0.00005, "wd": 0.005},
+ "cola": {"lr": 0.005, "head_lr": 0.0005, "wd": 0.1},
+ "qnli": {"lr": 0.0005, "head_lr": 0.05, "wd": 0.005},
+ "rte": {"lr": 0.005, "head_lr": 0.005, "wd": 0.5},
+ "stsb": {"lr": 0.001, "head_lr": 0.0005, "wd": 0.0005},
+ },
+}
+
+TASK_METRICS = {
+ "cola": "matthews_correlation",
+ "stsb": "pearson",
+ "mrpc": "accuracy",
+ "qqp": "accuracy",
+ "sst2": "accuracy",
+ "qnli": "accuracy",
+ "rte": "accuracy",
+}
+
+
+@dataclass
+class AdaMSSTrainingArguments:
+ """Arguments for AdaMSS training on GLUE tasks."""
+
+ # Model and Dataset
+ model_name_or_path: str = field(
+ default="roberta-base", metadata={"help": "Model identifier: roberta-base or roberta-large"}
+ )
+ dataset_name: str = field(default="cola", metadata={"help": "GLUE task: cola, mrpc, sst2, qnli, rte, stsb"})
+
+ # AdaMSS Configuration
+ adamss_r: int = field(default=100, metadata={"help": "SVD rank"})
+ adamss_k: int = field(default=10, metadata={"help": "Number of subspaces (K)"})
+ adamss_ri: int = field(default=1, metadata={"help": "Subspace rank (rk), use 1 for NLU"})
+
+ # ASA Configuration
+ use_asa: bool = field(default=False, metadata={"help": "Enable Adaptive Subspace Allocation"})
+ asa_target_subspaces: int = field(default=5, metadata={"help": "Target active subspaces for ASA"})
+ asa_init_warmup: int = field(default=5, metadata={"help": "ASA init warmup in EPOCHS"})
+ asa_final_warmup: int = field(default=95, metadata={"help": "ASA final warmup in EPOCHS"})
+ asa_mask_interval: int = field(default=10, metadata={"help": "ASA mask interval in EPOCHS"})
+ asa_importance_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for importance"})
+ asa_uncertainty_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for uncertainty"})
+ asa_schedule_exponent: float = field(default=3.0, metadata={"help": "ASA schedule exponent"})
+
+ # Training Configuration
+ num_epochs: int = field(default=100, metadata={"help": "Number of training epochs"})
+ batch_size: int = field(default=32, metadata={"help": "Batch size per device"})
+ max_length: int = field(default=512, metadata={"help": "Maximum sequence length"})
+ warmup_ratio: float = field(default=0.06, metadata={"help": "Warmup ratio"})
+
+ # Other
+ seed: int = field(default=0, metadata={"help": "Random seed"})
+ output_dir: str = field(default="./output", metadata={"help": "Output directory"})
+ cache_dir: str = field(default="./cache", metadata={"help": "Cache directory"})
+
+
+def get_dataset(args: AdaMSSTrainingArguments, tokenizer):
+ """Load and tokenize GLUE dataset."""
+ # Load dataset
+ raw_datasets = load_dataset("glue", args.dataset_name, cache_dir=args.cache_dir)
+
+ # Get sentence keys
+ sentence_keys = {
+ "cola": ("sentence", None),
+ "mrpc": ("sentence1", "sentence2"),
+ "qnli": ("question", "sentence"),
+ "rte": ("sentence1", "sentence2"),
+ "sst2": ("sentence", None),
+ "stsb": ("sentence1", "sentence2"),
+ }
+ sentence1_key, sentence2_key = sentence_keys[args.dataset_name]
+
+ # Tokenize
+ def preprocess_function(examples):
+ texts = (
+ (examples[sentence1_key],) if sentence2_key is None else (examples[sentence1_key], examples[sentence2_key])
+ )
+ result = tokenizer(*texts, truncation=True, max_length=args.max_length, padding="max_length")
+ result["labels"] = examples["label"]
+ return result
+
+ # Remove original text columns but keep label
+ columns_to_remove = [col for col in raw_datasets["train"].column_names if col != "label"]
+ tokenized_datasets = raw_datasets.map(
+ preprocess_function,
+ batched=True,
+ remove_columns=columns_to_remove,
+ desc="Tokenizing dataset",
+ )
+
+ train_ds = tokenized_datasets["train"]
+ val_ds = tokenized_datasets["validation"]
+ test_ds = tokenized_datasets["validation"] # Use validation as test for GLUE
+
+ return train_ds, val_ds, test_ds
+
+
+def main():
+ # Parse arguments
+ parser = HfArgumentParser(AdaMSSTrainingArguments)
+ args = parser.parse_args_into_dataclasses()[0]
+
+ # Set seed
+ torch.manual_seed(args.seed)
+ np.random.seed(args.seed)
+
+ # Get model short name
+ model_short = "roberta-large" if "large" in args.model_name_or_path else "roberta-base"
+
+ # Get hyperparameters from Table 19
+ if model_short in HYPERPARAMS and args.dataset_name in HYPERPARAMS[model_short]:
+ hp = HYPERPARAMS[model_short][args.dataset_name]
+ else:
+ hp = {"lr": 0.001, "head_lr": 0.005, "wd": 0.005}
+ print(f"Using default hyperparameters for {model_short}/{args.dataset_name}")
+
+ # Print configuration
+ print("=" * 80)
+ print(f"AdaMSS {'with ASA' if args.use_asa else 'without ASA'} - GLUE: {args.dataset_name.upper()}")
+ print("=" * 80)
+ print(f" Model: {model_short}")
+ print(f" AdaMSS: r={args.adamss_r}, K={args.adamss_k}, ri={args.adamss_ri}")
+ if args.use_asa:
+ print(f" ASA: K={args.adamss_k} → target={args.asa_target_subspaces}")
+ print(f" Hyperparameters (Table 19): lr={hp['lr']}, head_lr={hp['head_lr']}, wd={hp['wd']}")
+ print(f" Training: {args.num_epochs} epochs, batch_size={args.batch_size}, seed={args.seed}")
+ print("=" * 80 + "\n")
+
+ # Load tokenizer
+ tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path, cache_dir=args.cache_dir)
+
+ # Load dataset
+ print(f"Loading {args.dataset_name} dataset...")
+ train_ds, val_ds, _test_ds = get_dataset(args, tokenizer)
+
+ # Determine task type
+ is_regression = args.dataset_name == "stsb"
+ if not is_regression:
+ label_list = train_ds.features["label"].names
+ num_labels = len(label_list)
+ else:
+ num_labels = 1
+
+ print(f"Dataset loaded - Task: {'regression' if is_regression else 'classification'}\n")
+
+ # Load model
+ print(f"Loading {model_short}...")
+ model = AutoModelForSequenceClassification.from_pretrained(
+ args.model_name_or_path,
+ num_labels=num_labels,
+ cache_dir=args.cache_dir,
+ )
+
+ # Convert epoch-based ASA parameters to step-based (before config creation)
+ steps_per_epoch = len(train_ds) // args.batch_size
+ if len(train_ds) % args.batch_size != 0:
+ steps_per_epoch += 1
+
+ asa_init_warmup_steps = args.asa_init_warmup * steps_per_epoch
+ asa_final_warmup_steps = args.asa_final_warmup * steps_per_epoch
+ asa_mask_interval_steps = args.asa_mask_interval * steps_per_epoch
+
+ # Apply AdaMSS
+ print("\nApplying AdaMSS...")
+ config = AdamssConfig(
+ r=args.adamss_r,
+ num_subspaces=args.adamss_k,
+ subspace_rank=args.adamss_ri,
+ target_modules=["query", "value"],
+ use_asa=args.use_asa,
+ asa_target_subspaces=args.asa_target_subspaces if args.use_asa else None,
+ init_warmup=asa_init_warmup_steps if args.use_asa else None,
+ final_warmup=asa_final_warmup_steps if args.use_asa else None,
+ mask_interval=asa_mask_interval_steps if args.use_asa else None,
+ asa_importance_beta=args.asa_importance_beta if args.use_asa else None,
+ asa_uncertainty_beta=args.asa_uncertainty_beta if args.use_asa else None,
+ asa_schedule_exponent=args.asa_schedule_exponent if args.use_asa else None,
+ modules_to_save=["classifier"],
+ )
+
+ model = get_peft_model(model, config)
+ model.print_trainable_parameters()
+
+ # Print detailed parameter breakdown (same logic as exec_adamss_peft_glue.py)
+ print("\n[Detailed Parameter Breakdown]")
+ head_params = [p for n, p in model.named_parameters() if ("classifier" in n or "score" in n) and p.requires_grad]
+ other_params = [
+ p for n, p in model.named_parameters() if ("classifier" not in n and "score" not in n) and p.requires_grad
+ ]
+ head_count = sum(p.numel() for p in head_params)
+ adapter_count = sum(p.numel() for p in other_params)
+ print(f"Classifier Head Params: {head_count:,}")
+ print(f"AdaMSS Adapter Params: {adapter_count:,}")
+ print(f"Total Trainable Params: {head_count + adapter_count:,}")
+
+ # Debug: print parameter names to verify
+ if adapter_count == 0:
+ print("\nWARNING: No AdaMSS parameters found!")
+ print("All trainable parameter names:")
+ for n, p in model.named_parameters():
+ if p.requires_grad:
+ print(f" {n}: {p.numel():,} params")
+
+ # GPU memory
+ if torch.cuda.is_available():
+ torch.cuda.empty_cache()
+ torch.cuda.reset_peak_memory_stats()
+ print("\n[GPU Memory - Before Training]")
+ print(f"Allocated: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")
+ print(f"Reserved: {torch.cuda.memory_reserved() / 1024**3:.2f} GB")
+
+ # Setup ASA callback
+ callbacks = []
+ if args.use_asa:
+ print("\nSetting up ASA callback...")
+
+ print("\n[ASA Configuration]")
+ print(f"Dataset size: {len(train_ds)}, Batch size: {args.batch_size}")
+ print(f"Steps per epoch: {steps_per_epoch}")
+ print(f"Total training steps: {steps_per_epoch * args.num_epochs}")
+ print("ASA warmup (epochs → steps):")
+ print(f" init_warmup: {args.asa_init_warmup} epochs → {asa_init_warmup_steps} steps")
+ print(f" final_warmup: {args.asa_final_warmup} epochs → {asa_final_warmup_steps} steps")
+ print(f" mask_interval: {args.asa_mask_interval} epochs → {asa_mask_interval_steps} steps\n")
+
+ asa_callback = AdamssAsaCallback()
+ callbacks.append(asa_callback)
+
+ # Training configuration
+ print("\n[Training Configuration]")
+ print(f"Dataset size: {len(train_ds)}, Batch size: {args.batch_size}")
+ steps_per_epoch = len(train_ds) // args.batch_size
+ if len(train_ds) % args.batch_size != 0:
+ steps_per_epoch += 1
+ print(f"Steps per epoch: {steps_per_epoch}")
+ print(f"Total training steps: {steps_per_epoch * args.num_epochs}")
+
+ # Metrics
+ metric = evaluate.load("glue", args.dataset_name)
+
+ def compute_metrics(p: EvalPrediction):
+ preds = p.predictions[0] if isinstance(p.predictions, tuple) else p.predictions
+ preds = np.squeeze(preds) if is_regression else np.argmax(preds, axis=1)
+ return metric.compute(predictions=preds, references=p.label_ids)
+
+ # Training arguments
+ training_args = TrainingArguments(
+ output_dir=args.output_dir,
+ num_train_epochs=args.num_epochs,
+ per_device_train_batch_size=args.batch_size,
+ per_device_eval_batch_size=args.batch_size,
+ learning_rate=hp["lr"],
+ weight_decay=hp["wd"],
+ warmup_ratio=args.warmup_ratio,
+ eval_strategy="epoch",
+ save_strategy="epoch",
+ load_best_model_at_end=True,
+ metric_for_best_model=TASK_METRICS.get(args.dataset_name, "accuracy"),
+ greater_is_better=True,
+ logging_steps=100,
+ seed=args.seed,
+ report_to="none",
+ remove_unused_columns=False, # PEFT wraps forward(*args, **kwargs)
+ label_names=["labels"], # Explicitly tell Trainer where labels are
+ )
+
+ # Custom optimizer with different LR for head
+ optimizer_grouped_parameters = [
+ {
+ "params": [
+ p for n, p in model.named_parameters() if ("classifier" in n or "score" in n) and p.requires_grad
+ ],
+ "lr": hp["head_lr"],
+ },
+ {
+ "params": [
+ p
+ for n, p in model.named_parameters()
+ if ("classifier" not in n and "score" not in n) and p.requires_grad
+ ],
+ "lr": hp["lr"],
+ },
+ ]
+ optimizer = AdamW(optimizer_grouped_parameters, weight_decay=hp["wd"])
+
+ # Create trainer
+ trainer = Trainer(
+ model=model,
+ args=training_args,
+ train_dataset=train_ds,
+ eval_dataset=val_ds,
+ compute_metrics=compute_metrics,
+ optimizers=(optimizer, None),
+ callbacks=callbacks,
+ )
+
+ # Train
+ print("\n" + "=" * 80)
+ print("Starting training...")
+ print("=" * 80 + "\n")
+
+ train_result = trainer.train()
+
+ # GPU memory stats
+ if torch.cuda.is_available():
+ print("\n[GPU Memory - Peak During Training]")
+ print(f"Peak Allocated: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB")
+ print(f"Peak Reserved: {torch.cuda.max_memory_reserved() / 1024**3:.2f} GB")
+
+ # Print best metric
+ if trainer.state.best_metric is not None:
+ metric_name = TASK_METRICS.get(args.dataset_name, "accuracy")
+ print("\n[Best Model Info]")
+ print(f"Best {metric_name}: {trainer.state.best_metric:.4f}")
+
+ # Final evaluation on validation set
+ print("\n" + "=" * 80)
+ print("Final evaluation on validation set...")
+ print("=" * 80 + "\n")
+
+ final_metrics = trainer.evaluate(val_ds)
+ print(f"\nFinal Validation Results: {final_metrics}")
+
+ # Save model
+ trainer.save_model()
+ print(f"\nModel saved to {training_args.output_dir}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/adamss_finetuning/glue_adamss_asa_manual_example.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/adamss_finetuning/glue_adamss_asa_manual_example.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a8c079a419fe312902268ad038b51b459903472
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/adamss_finetuning/glue_adamss_asa_manual_example.py
@@ -0,0 +1,411 @@
+"""
+GLUE Task Fine-tuning with AdaMSS and Manual ASA
+
+This script demonstrates how to manually call update_and_allocate() for ASA
+instead of using AdamssAsaCallback. This approach is useful for custom training loops.
+
+Note:
+ This is an alternative to using AdamssAsaCallback. Choose ONE approach:
+ - Use AdamssAsaCallback (recommended, see glue_adamss_asa_example.py)
+ - Use manual update_and_allocate() (this script, for custom control)
+ DO NOT use both together!
+
+Example usage:
+ # CoLA with RoBERTa-base and manual ASA
+ python glue_adamss_asa_manual_example.py \
+ --dataset_name cola \
+ --use_asa \
+ --asa_target_subspaces 5 \
+ --num_epochs 100 \
+ --batch_size 32 \
+ --warmup_ratio 0.06 \
+ --seed 0 \
+ --output_dir ./output/cola_asa_manual
+
+Requirements:
+ pip install peft transformers datasets torch evaluate scikit-learn
+"""
+
+from dataclasses import dataclass, field
+
+import evaluate
+import numpy as np
+import torch
+from datasets import load_dataset
+from transformers import (
+ AutoModelForSequenceClassification,
+ AutoTokenizer,
+ EvalPrediction,
+ HfArgumentParser,
+ Trainer,
+ TrainingArguments,
+ set_seed,
+)
+
+from peft import AdamssConfig, get_peft_model
+
+
+class CustomTrainerWithManualASA(Trainer):
+ """
+ Custom Trainer that manually calls update_and_allocate() for ASA.
+
+ This demonstrates the manual approach as an alternative to using AdamssAsaCallback.
+ The update_and_allocate() method is called after optimizer.step() but before
+ zero_grad() to compute importance scores from gradients.
+ """
+
+ def training_step(self, model, inputs, num_items_in_batch=None):
+ """
+ Override training_step to add manual ASA update.
+
+ Training step sequence:
+ 1. Forward pass
+ 2. Backward pass (gradients computed)
+ 3. Optimizer step (parameters updated)
+ 4. >>> Manual ASA update (importance scoring & masking) <<<
+ 5. Zero gradients
+ """
+ model.train()
+ inputs = self._prepare_inputs(inputs)
+
+ # Forward & backward pass
+ with self.compute_loss_context_manager():
+ loss = self.compute_loss(model, inputs)
+
+ if self.args.gradient_accumulation_steps > 1:
+ loss = loss / self.args.gradient_accumulation_steps
+
+ self.accelerator.backward(loss)
+
+ # 🔑 Key: Manual ASA update after backward, before zero_grad
+ # This is where update_and_allocate() inspects gradients and applies masking
+ if (
+ hasattr(model, "base_model")
+ and hasattr(model.base_model, "update_and_allocate")
+ and (self.state.global_step + 1) % self.args.gradient_accumulation_steps == 0
+ ):
+ # Only call if we're actually doing optimizer step (not accumulating)
+ model.base_model.update_and_allocate(self.state.global_step)
+
+ return loss.detach()
+
+
+@dataclass
+class AdaMSSArguments:
+ """Arguments for AdaMSS configuration."""
+
+ # Basic AdaMSS parameters
+ adamss_r: int = field(default=100, metadata={"help": "SVD decomposition rank (R in paper)."})
+ adamss_k: int = field(default=10, metadata={"help": "Number of subspaces (K in paper)."})
+ adamss_ri: int = field(default=1, metadata={"help": "Subspace rank (rk in paper), typically 1 for NLU."})
+
+ # Training configuration
+ num_epochs: int = field(default=100, metadata={"help": "Number of training epochs."})
+ batch_size: int = field(default=32, metadata={"help": "Batch size per device."})
+ warmup_ratio: float = field(default=0.06, metadata={"help": "Warmup ratio."})
+ seed: int = field(default=0, metadata={"help": "Random seed."})
+ output_dir: str = field(default="./output", metadata={"help": "Output directory."})
+
+ # ASA parameters
+ use_asa: bool = field(default=False, metadata={"help": "Enable Adaptive Subspace Allocation (manual mode)."})
+ asa_target_subspaces: int = field(
+ default=5, metadata={"help": "Target number of active subspaces when ASA is enabled."}
+ )
+ asa_init_warmup: int = field(default=5, metadata={"help": "ASA warmup EPOCHS before starting masking."})
+ asa_final_warmup: int = field(default=95, metadata={"help": "ASA EPOCHS to reach target active subspaces."})
+ asa_mask_interval: int = field(default=10, metadata={"help": "EPOCHS between ASA updates."})
+ asa_importance_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for importance."})
+ asa_uncertainty_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for uncertainty."})
+ asa_schedule_exponent: float = field(default=3.0, metadata={"help": "ASA schedule exponent."})
+
+
+@dataclass
+class DataArguments:
+ """Arguments for dataset configuration."""
+
+ dataset_name: str = field(default="cola", metadata={"help": "GLUE task name (cola, mrpc, qnli, rte, stsb, sst2)."})
+ max_length: int = field(default=512, metadata={"help": "Maximum sequence length."})
+
+
+# Hyperparameters from Table 19 in the paper
+HYPERPARAMS = {
+ "roberta-large": {
+ "cola": {"lr": 0.005, "head_lr": 0.0005, "wd": 0.1},
+ "mrpc": {"lr": 0.001, "head_lr": 0.00005, "wd": 0.005},
+ "qnli": {"lr": 0.0005, "head_lr": 0.05, "wd": 0.005},
+ "rte": {"lr": 0.005, "head_lr": 0.005, "wd": 0.5},
+ "stsb": {"lr": 0.001, "head_lr": 0.0005, "wd": 0.0005},
+ "sst2": {"lr": 0.001, "head_lr": 0.0005, "wd": 0.0},
+ },
+ "roberta-base": {
+ "cola": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005},
+ "mrpc": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.0},
+ "qnli": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005},
+ "rte": {"lr": 0.0005, "head_lr": 0.005, "wd": 0.005},
+ "stsb": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005},
+ "sst2": {"lr": 0.001, "head_lr": 0.005, "wd": 0.0005},
+ },
+}
+
+# Metrics for each task
+TASK_METRICS = {
+ "cola": "matthews_correlation",
+ "stsb": "pearson",
+ "mrpc": "accuracy",
+ "qqp": "accuracy",
+ "sst2": "accuracy",
+ "qnli": "accuracy",
+ "rte": "accuracy",
+}
+
+
+def main():
+ # Parse arguments
+ parser = HfArgumentParser((DataArguments, AdaMSSArguments))
+ data_args, adamss_args = parser.parse_args_into_dataclasses()
+
+ # Set seed
+ set_seed(adamss_args.seed)
+
+ # Extract model name from output_dir or use default
+ if "roberta-large" in str(adamss_args.output_dir).lower():
+ model_name = "roberta-large"
+ else:
+ model_name = "roberta-base"
+
+ print("=" * 80)
+ print(f"AdaMSS with MANUAL ASA - GLUE Task: {data_args.dataset_name.upper()}")
+ print("=" * 80)
+ print(f"Model: {model_name}")
+ print(f"AdaMSS: r={adamss_args.adamss_r}, K={adamss_args.adamss_k}, ri={adamss_args.adamss_ri}")
+
+ # Get hyperparameters
+ if model_name in HYPERPARAMS and data_args.dataset_name in HYPERPARAMS[model_name]:
+ hp = HYPERPARAMS[model_name][data_args.dataset_name]
+ print(f"Hyperparameters (Table 19): lr={hp['lr']}, head_lr={hp['head_lr']}, wd={hp['wd']}")
+ else:
+ hp = {"lr": 0.001, "head_lr": 0.005, "wd": 0.005}
+ print(f"Using default hyperparameters: {hp}")
+
+ print(f"Training: {adamss_args.num_epochs} epochs, batch_size={adamss_args.batch_size}, seed={adamss_args.seed}")
+
+ if adamss_args.use_asa:
+ print(f"Manual ASA Mode: Target {adamss_args.asa_target_subspaces}/{adamss_args.adamss_k} subspaces")
+ print(f" Warmup epochs {adamss_args.asa_init_warmup} → {adamss_args.asa_final_warmup}")
+ print(" Using update_and_allocate() instead of AdamssAsaCallback")
+
+ # Load dataset
+ print(f"\nLoading {data_args.dataset_name} dataset...")
+ dataset = load_dataset("glue", data_args.dataset_name)
+
+ # Get task info
+ is_regression = data_args.dataset_name == "stsb"
+ if not is_regression:
+ label_list = dataset["train"].features["label"].names
+ num_labels = len(label_list)
+ else:
+ num_labels = 1
+
+ print(f"Dataset loaded - Task type: {'regression' if is_regression else 'classification'}")
+
+ # Load tokenizer and model
+ print(f"\nLoading {model_name}...")
+ tokenizer = AutoTokenizer.from_pretrained(model_name)
+ model = AutoModelForSequenceClassification.from_pretrained(
+ model_name,
+ num_labels=num_labels,
+ )
+
+ # Tokenize dataset
+ def preprocess_function(examples):
+ # Handle different GLUE tasks
+ if data_args.dataset_name in ["mrpc", "stsb", "qqp"]:
+ texts = (examples["sentence1"], examples["sentence2"])
+ elif data_args.dataset_name == "qnli":
+ texts = (examples["question"], examples["sentence"])
+ elif data_args.dataset_name == "rte":
+ texts = (examples["sentence1"], examples["sentence2"])
+ else: # cola, sst2, etc.
+ texts = (examples["sentence"],)
+
+ result = tokenizer(*texts, truncation=True, max_length=data_args.max_length, padding="max_length")
+ result["labels"] = examples["label"]
+ return result
+
+ print("Tokenizing dataset...")
+ # Remove all columns except label
+ columns_to_remove = [col for col in dataset["train"].column_names if col != "label"]
+ tokenized_datasets = dataset.map(
+ preprocess_function,
+ batched=True,
+ remove_columns=columns_to_remove,
+ )
+
+ train_ds = tokenized_datasets["train"]
+ val_ds = tokenized_datasets["validation"]
+ test_key = "test" if "test" in tokenized_datasets else "validation"
+ test_ds = tokenized_datasets[test_key]
+
+ # Create TrainingArguments manually (not parsed to avoid conflicts)
+ training_args = TrainingArguments(
+ output_dir=adamss_args.output_dir,
+ num_train_epochs=adamss_args.num_epochs,
+ per_device_train_batch_size=adamss_args.batch_size,
+ per_device_eval_batch_size=adamss_args.batch_size,
+ learning_rate=hp["lr"],
+ weight_decay=hp["wd"],
+ warmup_ratio=adamss_args.warmup_ratio,
+ eval_strategy="epoch",
+ save_strategy="epoch",
+ load_best_model_at_end=True,
+ metric_for_best_model=TASK_METRICS.get(data_args.dataset_name, "accuracy"),
+ greater_is_better=True,
+ logging_steps=100,
+ logging_strategy="steps",
+ seed=adamss_args.seed,
+ report_to="none",
+ remove_unused_columns=False, # PEFT wraps forward(*args, **kwargs)
+ label_names=["labels"], # Explicitly tell Trainer where labels are
+ )
+
+ # Configure AdaMSS with ASA parameters stored in config
+ print("\nApplying AdaMSS...")
+
+ # Convert epoch-based parameters to step-based for config
+ steps_per_epoch = len(train_ds) // adamss_args.batch_size
+ if len(train_ds) % adamss_args.batch_size != 0:
+ steps_per_epoch += 1
+ total_steps = adamss_args.num_epochs * steps_per_epoch
+
+ print("\n[Training Configuration]")
+ print(f"Dataset size: {len(train_ds)}")
+ print(f"Batch size: {adamss_args.batch_size}")
+ print(f"Steps per epoch: {steps_per_epoch}")
+ print(f"Total steps: {adamss_args.num_epochs} epochs × {steps_per_epoch} steps = {total_steps} steps")
+
+ asa_init_warmup_steps = adamss_args.asa_init_warmup * steps_per_epoch
+ asa_final_warmup_steps = adamss_args.asa_final_warmup * steps_per_epoch
+ asa_mask_interval_steps = adamss_args.asa_mask_interval * steps_per_epoch
+
+ if adamss_args.use_asa:
+ print("\n[ASA Configuration (Epoch → Step Conversion)]")
+ print(f" init warmup: {adamss_args.asa_init_warmup} epochs → {asa_init_warmup_steps} steps")
+ print(f" final warmup: {adamss_args.asa_final_warmup} epochs → {asa_final_warmup_steps} steps")
+ print(f" mask interval: {adamss_args.asa_mask_interval} epochs → {asa_mask_interval_steps} steps")
+
+ config = AdamssConfig(
+ r=adamss_args.adamss_r,
+ num_subspaces=adamss_args.adamss_k,
+ subspace_rank=adamss_args.adamss_ri,
+ target_modules=["query", "value"],
+ use_asa=adamss_args.use_asa,
+ asa_target_subspaces=adamss_args.asa_target_subspaces if adamss_args.use_asa else None,
+ # Store step-based ASA parameters in config
+ init_warmup=asa_init_warmup_steps if adamss_args.use_asa else None,
+ final_warmup=asa_final_warmup_steps if adamss_args.use_asa else None,
+ mask_interval=asa_mask_interval_steps if adamss_args.use_asa else None,
+ asa_importance_beta=adamss_args.asa_importance_beta if adamss_args.use_asa else None,
+ asa_uncertainty_beta=adamss_args.asa_uncertainty_beta if adamss_args.use_asa else None,
+ asa_schedule_exponent=adamss_args.asa_schedule_exponent if adamss_args.use_asa else None,
+ modules_to_save=["classifier"],
+ )
+
+ model = get_peft_model(model, config)
+ model.print_trainable_parameters()
+
+ # Print detailed parameter breakdown (same logic as exec_adamss_peft_glue.py)
+ print("\n[Detailed Parameter Breakdown]")
+ head_params = [p for n, p in model.named_parameters() if ("classifier" in n or "score" in n) and p.requires_grad]
+ other_params = [
+ p for n, p in model.named_parameters() if ("classifier" not in n and "score" not in n) and p.requires_grad
+ ]
+ head_count = sum(p.numel() for p in head_params)
+ adapter_count = sum(p.numel() for p in other_params)
+ print(f"Classifier Head Params: {head_count:,}")
+ print(f"AdaMSS Adapter Params: {adapter_count:,}")
+ print(f"Total Trainable Params: {head_count + adapter_count:,}")
+
+ # GPU memory monitoring
+ if torch.cuda.is_available():
+ torch.cuda.empty_cache()
+ torch.cuda.reset_peak_memory_stats()
+ print("\n[GPU Memory - Before Training]")
+ print(f"Allocated: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")
+ print(f"Reserved: {torch.cuda.memory_reserved() / 1024**3:.2f} GB")
+
+ # Metrics
+ metric = evaluate.load("glue", data_args.dataset_name)
+
+ def compute_metrics(p: EvalPrediction):
+ preds = p.predictions[0] if isinstance(p.predictions, tuple) else p.predictions
+ preds = np.squeeze(preds) if is_regression else np.argmax(preds, axis=1)
+ return metric.compute(predictions=preds, references=p.label_ids)
+
+ # Create custom optimizer with different LR for head
+ from torch.optim import AdamW
+
+ optimizer_grouped_parameters = [
+ {
+ "params": [
+ p for n, p in model.named_parameters() if ("classifier" in n or "score" in n) and p.requires_grad
+ ],
+ "lr": hp["head_lr"],
+ },
+ {
+ "params": [
+ p
+ for n, p in model.named_parameters()
+ if ("classifier" not in n and "score" not in n) and p.requires_grad
+ ],
+ "lr": hp["lr"],
+ },
+ ]
+ optimizer = AdamW(optimizer_grouped_parameters, weight_decay=hp["wd"])
+
+ # Create trainer with custom class that calls update_and_allocate()
+ # Note: NO callbacks here - we're using manual approach
+ trainer = CustomTrainerWithManualASA(
+ model=model,
+ args=training_args,
+ train_dataset=train_ds,
+ eval_dataset=val_ds,
+ compute_metrics=compute_metrics,
+ optimizers=(optimizer, None),
+ )
+
+ # Train
+ print("\n" + "=" * 80)
+ print("Starting training...")
+ if adamss_args.use_asa:
+ print("Manual ASA: update_and_allocate() will be called in training_step")
+ print("=" * 80 + "\n")
+
+ train_result = trainer.train()
+
+ # GPU memory stats
+ if torch.cuda.is_available():
+ print("\n[GPU Memory - Peak During Training]")
+ print(f"Peak Allocated: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB")
+ print(f"Peak Reserved: {torch.cuda.max_memory_reserved() / 1024**3:.2f} GB")
+
+ # Print best metric
+ if trainer.state.best_metric is not None:
+ metric_name = TASK_METRICS.get(data_args.dataset_name, "accuracy")
+ print("\n[Best Model Info]")
+ print(f"Best {metric_name}: {trainer.state.best_metric:.4f}")
+
+ # Evaluate on validation set (use val_ds, not test_ds to avoid label issues)
+ print("\n" + "=" * 80)
+ print("Final evaluation on validation set...")
+ print("=" * 80 + "\n")
+
+ final_metrics = trainer.evaluate(val_ds)
+ print(f"\nFinal Validation Results: {final_metrics}")
+
+ # Save model
+ trainer.save_model()
+ print(f"\nModel saved to {training_args.output_dir}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/adamss_finetuning/image_classification_adamss_asa.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/adamss_finetuning/image_classification_adamss_asa.py
new file mode 100644
index 0000000000000000000000000000000000000000..53efd784d300ed9766bd468bbe6f9e978ab25635
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/adamss_finetuning/image_classification_adamss_asa.py
@@ -0,0 +1,452 @@
+"""
+Image Classification with AdaMSS and ASA Callback
+
+This script demonstrates how to fine-tune a Vision Transformer (ViT) model
+using AdaMSS (Adaptive Matrix Decomposition with Subspace Selection) and
+ASA (Adaptive Subspace Allocation) callback from PEFT.
+
+Example usage:
+ python image_classification_adamss_asa.py \\
+ --model_name_or_path google/vit-base-patch16-224-in21k \\
+ --dataset_name cifar10 \\
+ --adamss_r 100 \\
+ --adamss_k 10 \\
+ --adamss_ri 3 \\
+ --use_asa \\
+ --asa_target_subspaces 5 \\
+ --num_epochs 10 \\
+ --output_dir ./output
+
+Requirements:
+ pip install peft transformers datasets torch torchvision evaluate
+"""
+
+from dataclasses import dataclass, field
+from functools import partial
+from typing import Optional
+
+import evaluate
+import torch
+from datasets import load_dataset
+from torchvision.transforms import (
+ CenterCrop,
+ Compose,
+ Normalize,
+ RandomHorizontalFlip,
+ RandomResizedCrop,
+ Resize,
+ ToTensor,
+)
+from transformers import (
+ AutoImageProcessor,
+ AutoModelForImageClassification,
+ HfArgumentParser,
+ Trainer,
+ TrainingArguments,
+)
+
+from peft import AdamssConfig, get_peft_model
+from peft.tuners.adamss.asa_callback import AdamssAsaCallback
+
+
+# Hyperparameters from Table 18 in the paper
+HYPERPARAMS = {
+ "vit-large-patch16-224-in21k": {
+ "pets": {"lr": 0.001, "head_lr": 0.0005, "wd": 0.0005},
+ "cars": {"lr": 0.01, "head_lr": 0.005, "wd": 0.1},
+ "cifar10": {"lr": 0.01, "head_lr": 0.05, "wd": 0.1},
+ "cifar100": {"lr": 0.01, "head_lr": 0.05, "wd": 0.05},
+ "eurosat": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.01},
+ "fgvc": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.0005},
+ "resisc": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.1},
+ },
+ "vit-base-patch16-224-in21k": {
+ "pets": {"lr": 0.005, "head_lr": 0.005, "wd": 0.0005},
+ "cars": {"lr": 0.01, "head_lr": 0.005, "wd": 0.0},
+ "cifar10": {"lr": 0.01, "head_lr": 0.005, "wd": 0.05},
+ "cifar100": {"lr": 0.01, "head_lr": 0.005, "wd": 0.05},
+ "eurosat": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.05},
+ "fgvc": {"lr": 0.01, "head_lr": 0.005, "wd": 0.0005},
+ "resisc": {"lr": 0.01, "head_lr": 0.005, "wd": 0.0005},
+ },
+}
+
+# Model-specific K values (number of subspaces)
+MODEL_K_VALUES = {
+ "vit-large-patch16-224-in21k": 16,
+ "vit-base-patch16-224-in21k": 10,
+}
+# Dataset configurations (matching exec_adamss_peft.py)
+DATASET_CONFIGS = {
+ "cars": {
+ "train": "Multimodal-Fatima/StanfordCars_train",
+ "test": "Multimodal-Fatima/StanfordCars_test",
+ "img_col": "image",
+ "label_col": "label",
+ },
+ "cifar10": {
+ "train": "Multimodal-Fatima/CIFAR10_train",
+ "test": "Multimodal-Fatima/CIFAR10_test",
+ "img_col": "image",
+ "label_col": "label",
+ },
+ "cifar100": {
+ "train": "cifar100",
+ "test": "cifar100",
+ "img_col": "img",
+ "label_col": "fine_label",
+ },
+ "eurosat": {
+ "dataset": "timm/eurosat-rgb",
+ "img_col": "image",
+ "label_col": "label",
+ },
+ "pets": {
+ "train": "timm/oxford-iiit-pet",
+ "test": "timm/oxford-iiit-pet",
+ "img_col": "image",
+ "label_col": "label",
+ },
+}
+
+
+# Global preprocessing functions (to avoid closure issues with set_transform)
+def _preprocess_images(examples, img_col, transforms):
+ """Apply image transformations."""
+ examples["pixel_values"] = [transforms(img.convert("RGB")) for img in examples[img_col]]
+ return examples
+
+
+def _collate_batch(examples, label_col):
+ """Collate examples into a batch."""
+ pixel_values = torch.stack([ex["pixel_values"] for ex in examples])
+ labels = torch.tensor([ex[label_col] for ex in examples])
+ return {"pixel_values": pixel_values, "labels": labels}
+
+
+@dataclass
+class ImageClassificationArguments:
+ """Arguments for image classification with AdaMSS and ASA."""
+
+ # Model configuration
+ model_name_or_path: str = field(
+ default="google/vit-base-patch16-224-in21k", metadata={"help": "Model identifier: vit-base or vit-large"}
+ )
+ dataset_name: str = field(
+ default="cifar10", metadata={"help": "Dataset: cifar10, cifar100, pets, cars, eurosat, fgvc, resisc"}
+ )
+
+ # AdaMSS Configuration
+ adamss_r: int = field(default=100, metadata={"help": "SVD rank"})
+ adamss_k: int = field(default=10, metadata={"help": "Number of subspaces (K), auto-set based on model"})
+ adamss_ri: int = field(default=3, metadata={"help": "Subspace rank (rk), use 3 for vision"})
+
+ # ASA Configuration
+ use_asa: bool = field(default=False, metadata={"help": "Enable Adaptive Subspace Allocation"})
+ asa_target_subspaces: int = field(default=5, metadata={"help": "Target active subspaces for ASA"})
+ asa_init_warmup: int = field(default=50, metadata={"help": "ASA init warmup in STEPS"})
+ asa_final_warmup: int = field(default=1000, metadata={"help": "ASA final warmup in STEPS"})
+ asa_mask_interval: int = field(default=100, metadata={"help": "ASA mask interval in STEPS"})
+ asa_importance_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for importance"})
+ asa_uncertainty_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for uncertainty"})
+ asa_schedule_exponent: float = field(default=3.0, metadata={"help": "ASA schedule exponent"})
+
+ # Training Configuration
+ num_epochs: int = field(default=10, metadata={"help": "Number of training epochs"})
+ batch_size: int = field(default=32, metadata={"help": "Batch size per device"})
+ warmup_ratio: float = field(default=0.0, metadata={"help": "Warmup ratio"})
+ max_train_samples: Optional[int] = field(default=None, metadata={"help": "Max training samples (for debug)"})
+
+ # Other
+ seed: int = field(default=0, metadata={"help": "Random seed"})
+ output_dir: str = field(default="./output", metadata={"help": "Output directory"})
+ cache_dir: Optional[str] = field(default=None, metadata={"help": "Cache directory"})
+
+
+def prepare_transforms(image_processor):
+ """Prepare image transformations."""
+ normalize = Normalize(mean=image_processor.image_mean, std=image_processor.image_std)
+ size = image_processor.size["height"]
+
+ train_transforms = Compose(
+ [
+ RandomResizedCrop(size),
+ RandomHorizontalFlip(),
+ ToTensor(),
+ normalize,
+ ]
+ )
+ val_transforms = Compose(
+ [
+ Resize(size),
+ CenterCrop(size),
+ ToTensor(),
+ normalize,
+ ]
+ )
+ return train_transforms, val_transforms
+
+
+def main():
+ # Parse arguments
+ parser = HfArgumentParser(ImageClassificationArguments)
+ args = parser.parse_args_into_dataclasses()[0]
+
+ # Set seed
+ torch.manual_seed(args.seed)
+
+ # Auto-detect model type and set K value
+ model_name = args.model_name_or_path
+ model_type = None
+ for key in MODEL_K_VALUES:
+ if key in model_name:
+ model_type = key
+ break
+
+ if model_type is None:
+ # Default to base model
+ model_type = "vit-base-patch16-224-in21k"
+ print(f"Warning: Model type not recognized, defaulting to {model_type}")
+
+ # Override K value based on model type
+ args.adamss_k = MODEL_K_VALUES[model_type]
+
+ # Get hyperparameters from Table 18
+ if model_type in HYPERPARAMS and args.dataset_name in HYPERPARAMS[model_type]:
+ hp = HYPERPARAMS[model_type][args.dataset_name]
+ print(f"Using Table 18 hyperparameters for {model_type} + {args.dataset_name}")
+ print(f" lr={hp['lr']}, head_lr={hp['head_lr']}, wd={hp['wd']}")
+ else:
+ hp = {"lr": 0.01, "head_lr": 0.005, "wd": 0.0005}
+ print(f"Warning: No Table 18 hyperparameters found, using defaults: {hp}")
+
+ print("\n" + "=" * 80)
+ print(f"AdaMSS {'with ASA' if args.use_asa else 'without ASA'} - {args.dataset_name.upper()}")
+ print("=" * 80)
+ print(f"Model: {model_type}")
+ print(f"AdaMSS: r={args.adamss_r}, K={args.adamss_k}, ri={args.adamss_ri}")
+ if args.use_asa:
+ print(f"ASA: Target {args.asa_target_subspaces}/{args.adamss_k} subspaces")
+ print(f" Warmup steps {args.asa_init_warmup} → {args.asa_final_warmup}")
+ print(f"Training: {args.num_epochs} epochs, batch_size={args.batch_size}, seed={args.seed}")
+ print("=" * 80 + "\n")
+
+ # Get dataset configuration
+ if args.dataset_name not in DATASET_CONFIGS:
+ raise ValueError(f"Unsupported dataset: {args.dataset_name}. Supported: {list(DATASET_CONFIGS.keys())}")
+
+ config = DATASET_CONFIGS[args.dataset_name]
+ img_name = config["img_col"]
+ label_name = config["label_col"]
+
+ # Load dataset
+ print(f"Loading {args.dataset_name} dataset...")
+ if "dataset" in config:
+ # Single dataset with train/val/test splits (e.g., eurosat)
+ dataset = load_dataset(config["dataset"], cache_dir=args.cache_dir)
+ train_val = dataset["train"].train_test_split(test_size=0.1, seed=args.seed)
+ train_ds = train_val["train"]
+ val_ds = train_val["test"]
+ # Try 'test' split, fall back to 'val' if not available
+ if "test" in dataset:
+ test_ds = dataset["test"]
+ elif "val" in dataset:
+ test_ds = dataset["val"]
+ else:
+ print("Warning: No test/val split found, using validation set as test")
+ test_ds = val_ds
+ else:
+ # Separate train and test datasets (e.g., cars, cifar10)
+ train_val_ds = load_dataset(config["train"], split="train", cache_dir=args.cache_dir)
+ test_ds = load_dataset(config["test"], split="test", cache_dir=args.cache_dir)
+
+ # Split train into train and validation
+ train_val = train_val_ds.train_test_split(test_size=0.1, seed=args.seed)
+ train_ds = train_val["train"]
+ val_ds = train_val["test"]
+
+ print(f"Detected columns - Image: '{img_name}', Label: '{label_name}'")
+
+ # Limit train samples if specified (for quick testing)
+ if args.max_train_samples:
+ train_ds = train_ds.select(range(min(args.max_train_samples, len(train_ds))))
+ # Also limit validation for faster testing
+ val_ds = val_ds.select(range(min(5000, len(val_ds))))
+
+ labels = train_ds.features[label_name].names
+ num_classes = len(labels)
+ print(f"Dataset loaded: {len(train_ds)} train, {len(val_ds)} val, {len(test_ds)} test")
+ print(f" Number of classes: {num_classes}")
+
+ # Create label mappings
+ label2id = {label: i for i, label in enumerate(labels)}
+ id2label = dict(enumerate(labels))
+
+ # Load image processor
+ print("\nLoading image processor...")
+ image_processor = AutoImageProcessor.from_pretrained(
+ args.model_name_or_path,
+ cache_dir=args.cache_dir,
+ )
+
+ # Prepare transforms
+ train_transforms, val_transforms = prepare_transforms(image_processor)
+
+ # Use partial to bind parameters at module level (avoid set_transform closure issues)
+ train_ds.set_transform(partial(_preprocess_images, img_col=img_name, transforms=train_transforms))
+ val_ds.set_transform(partial(_preprocess_images, img_col=img_name, transforms=val_transforms))
+ test_ds.set_transform(partial(_preprocess_images, img_col=img_name, transforms=val_transforms))
+
+ # Data collator
+ collate_fn = partial(_collate_batch, label_col=label_name)
+
+ # Load base model
+ print("\nLoading base model...")
+ model = AutoModelForImageClassification.from_pretrained(
+ args.model_name_or_path,
+ num_labels=num_classes,
+ label2id=label2id,
+ id2label=id2label,
+ ignore_mismatched_sizes=True,
+ cache_dir=args.cache_dir,
+ )
+
+ # Configure AdaMSS
+ print("\nApplying AdaMSS...")
+ config = AdamssConfig(
+ r=args.adamss_r,
+ num_subspaces=args.adamss_k,
+ subspace_rank=args.adamss_ri,
+ target_modules=["query", "value"],
+ use_asa=args.use_asa,
+ asa_target_subspaces=args.asa_target_subspaces if args.use_asa else None,
+ init_warmup=args.asa_init_warmup if args.use_asa else None,
+ final_warmup=args.asa_final_warmup if args.use_asa else None,
+ mask_interval=args.asa_mask_interval if args.use_asa else None,
+ asa_importance_beta=args.asa_importance_beta if args.use_asa else None,
+ asa_uncertainty_beta=args.asa_uncertainty_beta if args.use_asa else None,
+ asa_schedule_exponent=args.asa_schedule_exponent if args.use_asa else None,
+ modules_to_save=["classifier"],
+ )
+
+ # Apply PEFT
+ model = get_peft_model(model, config)
+ model.print_trainable_parameters()
+
+ # Print detailed parameter breakdown (same logic as exec_adamss_peft.py)
+ print("\n[Detailed Parameter Breakdown]")
+ trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+ head_params = sum(p.numel() for n, p in model.named_parameters() if "classifier" in n and p.requires_grad)
+ adamss_params = trainable_params - head_params
+ print(f"Classifier Head Params: {head_params:,}")
+ print(f"AdaMSS Adapter Params: {adamss_params:,}")
+ print(f"Total Trainable Params: {trainable_params:,}")
+
+ # Setup ASA callback if enabled
+ callbacks = []
+ if args.use_asa:
+ print("\nSetting up ASA callback...")
+ asa_callback = AdamssAsaCallback()
+ callbacks.append(asa_callback)
+
+ # Metrics
+ metric = evaluate.load("accuracy")
+
+ def compute_metrics(eval_pred):
+ preds = eval_pred.predictions
+ # Handle tuple outputs (logits, hidden_states)
+ if isinstance(preds, tuple):
+ preds = preds[0]
+ predictions = preds.argmax(axis=1)
+ return metric.compute(predictions=predictions, references=eval_pred.label_ids)
+
+ # Create TrainingArguments manually (not parsed to avoid conflicts)
+ training_args = TrainingArguments(
+ output_dir=args.output_dir,
+ num_train_epochs=args.num_epochs,
+ per_device_train_batch_size=args.batch_size,
+ per_device_eval_batch_size=args.batch_size,
+ learning_rate=hp["lr"],
+ weight_decay=hp["wd"],
+ warmup_ratio=args.warmup_ratio,
+ eval_strategy="epoch",
+ save_strategy="epoch",
+ load_best_model_at_end=True,
+ metric_for_best_model="accuracy",
+ greater_is_better=True,
+ logging_steps=100,
+ logging_strategy="steps",
+ seed=args.seed,
+ report_to="none",
+ remove_unused_columns=False, # Required for set_transform compatibility
+ label_names=["labels"], # Explicitly tell Trainer where labels are (PEFT hides model signature)
+ )
+
+ # Create custom optimizer with different LR for head
+ from torch.optim import AdamW
+
+ optimizer_grouped_parameters = [
+ {
+ "params": [p for n, p in model.named_parameters() if "classifier" in n and p.requires_grad],
+ "lr": hp["head_lr"],
+ },
+ {
+ "params": [p for n, p in model.named_parameters() if "classifier" not in n and p.requires_grad],
+ "lr": hp["lr"],
+ },
+ ]
+ optimizer = AdamW(optimizer_grouped_parameters, weight_decay=hp["wd"])
+
+ # Create trainer
+ trainer = Trainer(
+ model=model,
+ args=training_args,
+ train_dataset=train_ds,
+ eval_dataset=val_ds,
+ data_collator=collate_fn,
+ compute_metrics=compute_metrics,
+ optimizers=(optimizer, None),
+ callbacks=callbacks,
+ )
+
+ # GPU memory monitoring
+ if torch.cuda.is_available():
+ torch.cuda.empty_cache()
+ torch.cuda.reset_peak_memory_stats()
+ print("\n[GPU Memory - Before Training]")
+ print(f"Allocated: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")
+ print(f"Reserved: {torch.cuda.memory_reserved() / 1024**3:.2f} GB")
+
+ # Train
+ print("\n" + "=" * 80)
+ print("Starting training...")
+ print("=" * 80 + "\n")
+
+ train_result = trainer.train()
+
+ # GPU memory stats
+ if torch.cuda.is_available():
+ print("\n[GPU Memory - Peak During Training]")
+ print(f"Peak Allocated: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB")
+ print(f"Peak Reserved: {torch.cuda.max_memory_reserved() / 1024**3:.2f} GB")
+
+ # Print best metric
+ if trainer.state.best_metric is not None:
+ print("\n[Best Model Info]")
+ print(f"Best accuracy: {trainer.state.best_metric:.4f}")
+
+ # Evaluate on test set
+ print("\n" + "=" * 80)
+ print("Evaluating on test set...")
+ print("=" * 80 + "\n")
+
+ test_metrics = trainer.evaluate(test_ds, metric_key_prefix="test")
+ print(f"\nTest Accuracy: {test_metrics['test_accuracy']:.4f}")
+
+ # Save model
+ trainer.save_model()
+ print(f"\nModel saved to {training_args.output_dir}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/adamss_finetuning/test_adamss_quick.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/adamss_finetuning/test_adamss_quick.py
new file mode 100644
index 0000000000000000000000000000000000000000..701190614e960e74d56a069a254aad8058cf4f18
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/adamss_finetuning/test_adamss_quick.py
@@ -0,0 +1,176 @@
+"""
+Quick test for AdaMSS example - runs 1 epoch on small subset
+"""
+
+import sys
+
+
+sys.path.insert(0, "/Users/onelong/Documents/WorkSpace/CodeSpace/AdaMSS-main/peft-main/src")
+
+import evaluate
+import torch
+from datasets import load_dataset
+from torchvision.transforms import (
+ CenterCrop,
+ Compose,
+ Normalize,
+ RandomHorizontalFlip,
+ RandomResizedCrop,
+ Resize,
+ ToTensor,
+)
+from transformers import AutoImageProcessor, AutoModelForImageClassification, Trainer, TrainingArguments
+
+from peft import AdaMSSConfig, ASACallback, get_peft_model
+
+
+print("=" * 80)
+print("🧪 AdaMSS Quick Test")
+print("=" * 80)
+
+# Load small subset
+print("\n📦 Loading CIFAR-10 (small subset for testing)...")
+dataset = load_dataset("cifar10")
+train_val = dataset["train"].train_test_split(test_size=0.1, seed=42)
+train_ds = train_val["train"].select(range(100)) # Only 100 samples
+val_ds = train_val["test"].select(range(50))
+
+print(f"✅ Dataset: {len(train_ds)} train, {len(val_ds)} val")
+
+# Prepare data
+image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224-in21k")
+normalize = Normalize(mean=image_processor.image_mean, std=image_processor.image_std)
+
+train_transforms = Compose(
+ [
+ RandomResizedCrop(image_processor.size["height"]),
+ RandomHorizontalFlip(),
+ ToTensor(),
+ normalize,
+ ]
+)
+
+val_transforms = Compose(
+ [
+ Resize(image_processor.size["height"]),
+ CenterCrop(image_processor.size["height"]),
+ ToTensor(),
+ normalize,
+ ]
+)
+
+
+def preprocess_train(examples):
+ examples["pixel_values"] = [train_transforms(img.convert("RGB")) for img in examples["img"]]
+ return examples
+
+
+def preprocess_val(examples):
+ examples["pixel_values"] = [val_transforms(img.convert("RGB")) for img in examples["img"]]
+ return examples
+
+
+train_ds.set_transform(preprocess_train)
+val_ds.set_transform(preprocess_val)
+
+
+def collate_fn(examples):
+ pixel_values = torch.stack([example["pixel_values"] for example in examples])
+ labels = torch.tensor([example["label"] for example in examples])
+ return {"pixel_values": pixel_values, "labels": labels}
+
+
+# Load model
+print("\n🤖 Loading ViT model...")
+model = AutoModelForImageClassification.from_pretrained(
+ "google/vit-base-patch16-224-in21k",
+ num_labels=10,
+ ignore_mismatched_sizes=True,
+)
+
+# Configure AdaMSS
+print("\n⚙️ Applying AdaMSS...")
+config = AdaMSSConfig(
+ r=100,
+ num_subspaces=10,
+ subspace_rank=3,
+ target_modules=["query", "value"],
+ use_asa=True,
+ target_kk=5,
+ modules_to_save=["classifier"],
+)
+
+model = get_peft_model(model, config)
+print("\n📊 Parameter statistics:")
+model.print_trainable_parameters()
+
+# Setup ASA callback
+print("\n🔥 Setting up ASA callback...")
+asa_callback = ASACallback(
+ target_kk=5,
+ init_warmup=5,
+ final_warmup=20,
+ mask_interval=10,
+)
+
+# Metrics
+metric = evaluate.load("accuracy")
+
+
+def compute_metrics(eval_pred):
+ predictions = eval_pred.predictions.argmax(axis=1)
+ return metric.compute(predictions=predictions, references=eval_pred.label_ids)
+
+
+# Training arguments
+training_args = TrainingArguments(
+ output_dir="./test_adamss_output",
+ num_train_epochs=1,
+ per_device_train_batch_size=8,
+ per_device_eval_batch_size=8,
+ learning_rate=0.01,
+ weight_decay=0.0005,
+ eval_strategy="epoch",
+ save_strategy="no",
+ logging_steps=10,
+ remove_unused_columns=False,
+ label_names=["labels"], # Explicitly tell Trainer where labels are (PEFT hides model signature)
+ report_to="none",
+)
+
+# Create trainer
+trainer = Trainer(
+ model=model,
+ args=training_args,
+ train_dataset=train_ds,
+ eval_dataset=val_ds,
+ data_collator=collate_fn,
+ compute_metrics=compute_metrics,
+ callbacks=[asa_callback],
+)
+
+# Train
+print("\n" + "=" * 80)
+print("🚀 Starting training (1 epoch on 100 samples)...")
+print("=" * 80 + "\n")
+
+try:
+ trainer.train()
+ print("\n✅ Training completed successfully!")
+
+ # Evaluate
+ metrics = trainer.evaluate()
+ print(f"\n📊 Validation Accuracy: {metrics['eval_accuracy']:.2%}")
+
+ print("\n" + "=" * 80)
+ print("✅ Test PASSED - AdaMSS example works correctly!")
+ print("=" * 80)
+
+except Exception as e:
+ print("\n" + "=" * 80)
+ print(f"❌ Test FAILED: {e}")
+ print("=" * 80)
+ import traceback
+
+ traceback.print_exc()
+ sys.exit(1)
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/alora_finetuning/README.md b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/alora_finetuning/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..0a6a4ac196ed0e38a1f2c81ab6e398d9cb21b625
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/alora_finetuning/README.md
@@ -0,0 +1,76 @@
+# Activated LoRA (aLoRA)
+
+## Introduction
+Activated LoRA (aLoRA) is an adapter that selectively activates its weights only after a given invocation sequence, ensuring that hidden states match the base model prior to this point. This allows reusing the base model KVs (stored in the KV cache) for tokens before the invocation,
+enabling much faster real-world inference (e.g. vLLM) when switching between generation with the base model and generation with adapters.
+See the [paper](https://huggingface.co/papers/2504.12397) for more details.
+
+## Quick start (shown for Mistral 7B)
+```python
+import torch
+from peft import LoraConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer, DataCollatorForLanguageModeling
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3", device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3")
+dataset = load_dataset("Lots-of-LoRAs/task1660_super_glue_question_generation", split="train")
+
+invocation_string = "[/INST]" # End of user turn in Mistral chat template
+invocation_tokens = tokenizer.encode(invocation_string, add_special_tokens=False)
+
+lora_config = LoraConfig(
+ task_type="CAUSAL_LM",
+ alora_invocation_tokens=invocation_tokens,
+ r=32,
+ target_modules=["q_proj", "k_proj", "v_proj"],
+)
+
+peft_model = get_peft_model(model, lora_config)
+data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+trainer = Trainer(
+ model=peft_model,
+ train_dataset=dataset,
+ dataset_text_field="text",
+ max_length=2048,
+ tokenizer=tokenizer,
+ data_collator=data_collator,
+)
+trainer.train()
+peft_model.save_pretrained("alora-mistral-7b")
+```
+
+### Use the training example script directly
+Pass the invocation string with `--invocation_string` when running the training example
+script. For Mistral 7B, do:
+```bash
+python examples/alora_finetuning/alora_finetuning.py --base_model mistralai/Mistral-7B-Instruct-v0.3 --data_path Lots-of-LoRAs/task1660_super_glue_question_generation --invocation_string "[/INST]"
+```
+and similarly for Llama-3.2-3B-Instruct:
+```bash
+python examples/alora_finetuning/alora_finetuning.py --base_model meta-llama/Llama-3.2-3B-Instruct --data_path Lots-of-LoRAs/task1660_super_glue_question_generation --invocation_string "<|start_header_id|>assistant<|end_header_id|>"
+```
+
+### Full example of the script
+```bash
+python alora_finetuning.py \
+ --base_model "PATH_TO_MODEL" \
+ --data_path "PATH_TO_DATASET" \
+ --output_dir "PATH_TO_OUTPUT_DIR" \
+ --batch_size 1 \
+ --num_epochs 3 \
+ --learning_rate 3e-4 \
+ --cutoff_len 512 \
+ --val_set_size 500 \
+ --invocation_string "[/INST]" \
+ --quantize \
+ --eval_step 10 \
+ --save_step 100 \
+ --device "auto" \
+ --lora_r 32 \
+ --lora_alpha 32 \
+ --lora_dropout 0.05 \
+ --lora_target_modules "q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj" \
+ --hub_model_id "YOUR_HF_REPO" \
+ --push_to_hub
+```
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/alora_finetuning/alora_finetuning.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/alora_finetuning/alora_finetuning.py
new file mode 100644
index 0000000000000000000000000000000000000000..1bc1345c0a53e1e2d286ffd3576c136174e7b538
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/alora_finetuning/alora_finetuning.py
@@ -0,0 +1,259 @@
+import os
+
+import torch
+from datasets import load_dataset
+from transformers import (
+ AutoModelForCausalLM,
+ AutoTokenizer,
+ BitsAndBytesConfig,
+ DataCollatorForLanguageModeling,
+ Trainer,
+ TrainingArguments,
+)
+
+from peft import LoraConfig, PeftModel, get_peft_model, prepare_model_for_kbit_training
+
+
+def train_model(
+ base_model: str,
+ data_path: str,
+ output_dir: str,
+ batch_size: int,
+ num_epochs: int,
+ learning_rate: float,
+ cutoff_len: int,
+ val_set_size: int,
+ invocation_string: str,
+ quantize: bool,
+ eval_step: int,
+ save_step: int,
+ device: str,
+ lora_r: int,
+ lora_alpha: int,
+ lora_dropout: float,
+ lora_target_modules: str,
+ hub_model_id: str,
+ push_to_hub: bool,
+):
+ os.environ["TOKENIZERS_PARALLELISM"] = "false"
+ hf_token = os.getenv("HF_TOKEN")
+
+ if device == "auto":
+ device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+ else:
+ device = torch.device(device)
+ print(f"Using device: {device}")
+
+ tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token)
+ tokenizer.pad_token = tokenizer.unk_token
+ invocation_tokens = tokenizer.encode(invocation_string, add_special_tokens=False)
+
+ if quantize:
+ if (torch.cuda.is_available() and torch.cuda.is_bf16_supported()) or torch.xpu.is_available():
+ bnb_4bit_compute_dtype = torch.bfloat16
+ else:
+ bnb_4bit_compute_dtype = torch.float16
+ model = AutoModelForCausalLM.from_pretrained(
+ base_model,
+ token=hf_token,
+ quantization_config=BitsAndBytesConfig(
+ load_in_4bit=True,
+ bnb_4bit_compute_dtype=bnb_4bit_compute_dtype,
+ bnb_4bit_use_double_quant=True,
+ bnb_4bit_quant_type="nf4",
+ ),
+ )
+ model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)
+ else:
+ model = AutoModelForCausalLM.from_pretrained(base_model, token=hf_token)
+
+ lora_config = LoraConfig(
+ task_type="CAUSAL_LM",
+ alora_invocation_tokens=invocation_tokens,
+ r=lora_r,
+ lora_alpha=lora_alpha,
+ target_modules=(lora_target_modules.split(",") if lora_target_modules else ["q_proj", "k_proj", "v_proj"]),
+ lora_dropout=lora_dropout,
+ bias="none",
+ )
+
+ model = get_peft_model(model, lora_config)
+
+ model.to(device)
+ tokenizer.pad_token = tokenizer.eos_token
+
+ dataset = load_dataset(data_path)
+
+ def tokenize_function(examples):
+ formatted_texts = [
+ tokenizer.apply_chat_template(
+ [
+ {"role": "user", "content": user_msg},
+ {"role": "assistant", "content": assistant_msg},
+ ],
+ tokenize=False, # get plain text first
+ add_generation_prompt=False,
+ )
+ for user_msg, assistant_msg in zip(examples["input"], examples["output"])
+ ]
+
+ # 2) Tokenize those texts
+ model_inputs = tokenizer(
+ formatted_texts,
+ padding="max_length",
+ truncation=True,
+ max_length=cutoff_len,
+ )
+
+ labels = []
+ for ids in model_inputs["input_ids"]:
+ labels.append([(token_id if token_id != tokenizer.pad_token_id else -100) for token_id in ids])
+ model_inputs["labels"] = labels
+
+ return model_inputs
+
+ # Tokenize the dataset and prepare for training
+ tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names)
+
+ # Data collator to dynamically pad the batched examples
+ data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+ training_args = TrainingArguments(
+ output_dir=output_dir,
+ num_train_epochs=num_epochs,
+ per_device_train_batch_size=batch_size,
+ per_device_eval_batch_size=batch_size,
+ warmup_steps=100,
+ weight_decay=0.01,
+ logging_dir="./logs",
+ logging_steps=eval_step,
+ save_steps=save_step,
+ save_total_limit=2,
+ push_to_hub=push_to_hub,
+ hub_model_id=hub_model_id,
+ gradient_accumulation_steps=16,
+ fp16=True,
+ learning_rate=learning_rate,
+ hub_token=hf_token,
+ )
+
+ if torch.cuda.is_available():
+ torch.cuda.empty_cache()
+ elif torch.xpu.is_available():
+ torch.xpu.empty_cache()
+
+ trainer = Trainer(
+ model=model,
+ args=training_args,
+ train_dataset=tokenized_datasets["train"],
+ eval_dataset=tokenized_datasets["test"],
+ data_collator=data_collator,
+ )
+
+ trainer.train()
+
+ if push_to_hub:
+ trainer.push_to_hub(commit_message="Fine-tuned model")
+
+ model.save_pretrained(output_dir)
+ tokenizer.save_pretrained(output_dir)
+
+
+def model_inference(model_path: str, adapter_path: str, prompt: str | None = None, data_path: str | None = None):
+ """
+ Simple inference with the tuned aLoRA adapter. Optionally (reuse_cache = True) demonstrates
+ that the aLoRA adapter can (but does not need to) use KV cache created by the base model,
+ perhaps during a prior generation turn.
+
+ Purely for demonstration purposes. See the [paper](https://huggingface.co/papers/2504.12397)
+ for realistic multiturn cache reuse examples.
+ """
+ if prompt is None:
+ # Use first row of test data
+ dataset = load_dataset(data_path)
+ prompt = dataset["test"][0]["input"]
+ tokenizer = AutoTokenizer.from_pretrained(model_path)
+ base_model = AutoModelForCausalLM.from_pretrained(model_path)
+ alora_model = PeftModel.from_pretrained(base_model, adapter_path)
+ chat = [{"role": "user", "content": prompt}]
+ text = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)
+ inputs = tokenizer(text, return_tensors="pt").to(base_model.device)
+
+ # Generate answer with adapter
+ output_dict = alora_model.generate(**inputs, return_dict_in_generate=True, max_new_tokens=20)
+ alora_outputs = output_dict.sequences
+
+ # Print results
+ print(f"Prompt: {text}")
+ response = tokenizer.decode(alora_outputs[0][inputs["input_ids"].shape[1] :], skip_special_tokens=True)
+ print(f"Trained adapter response: {response}")
+
+
+if __name__ == "__main__":
+ import argparse
+
+ parser = argparse.ArgumentParser(description="Fine-tune Mistral with Activated LoRA")
+ parser.add_argument(
+ "--base_model", type=str, default="mistralai/Mistral-7B-Instruct-v0.3", help="Base model path or name"
+ )
+ parser.add_argument(
+ "--data_path",
+ type=str,
+ default="Lots-of-LoRAs/task1660_super_glue_question_generation",
+ help="Dataset path or name",
+ )
+ parser.add_argument(
+ "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model"
+ )
+ parser.add_argument("--batch_size", type=int, default=2, help="Batch size")
+ parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs")
+ parser.add_argument("--learning_rate", type=float, default=1e-4, help="Learning rate")
+ parser.add_argument("--cutoff_len", type=int, default=2048, help="Cutoff length for tokenization")
+ parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size")
+ parser.add_argument(
+ "--invocation_string",
+ type=str,
+ default="[/INST]",
+ help="String that activates the aLoRA adapter. Model dependent.",
+ )
+ parser.add_argument("--quantize", action="store_true", help="Use quantization")
+ parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval")
+ parser.add_argument("--save_step", type=int, default=100, help="Save step interval")
+ parser.add_argument("--device", type=str, default="auto", help="Device to use for training")
+ parser.add_argument("--lora_r", type=int, default=32, help="LoRA rank")
+ parser.add_argument("--lora_alpha", type=int, default=32, help="LoRA alpha")
+ parser.add_argument("--lora_dropout", type=float, default=0.05, help="LoRA dropout rate")
+ parser.add_argument(
+ "--lora_target_modules", type=str, default=None, help="Comma-separated list of target modules for LoRA"
+ )
+ parser.add_argument(
+ "--hub_model_id",
+ type=str,
+ default="path/to/repo",
+ help="Repository name to push the model on the Hugging Face Hub",
+ )
+ parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub")
+ args = parser.parse_args()
+ train_model(
+ base_model=args.base_model,
+ data_path=args.data_path,
+ output_dir=args.output_dir,
+ batch_size=args.batch_size,
+ num_epochs=args.num_epochs,
+ learning_rate=args.learning_rate,
+ cutoff_len=args.cutoff_len,
+ val_set_size=args.val_set_size,
+ invocation_string=args.invocation_string,
+ quantize=args.quantize,
+ eval_step=args.eval_step,
+ save_step=args.save_step,
+ device=args.device,
+ lora_r=args.lora_r,
+ lora_alpha=args.lora_alpha,
+ lora_dropout=args.lora_dropout,
+ lora_target_modules=args.lora_target_modules,
+ hub_model_id=args.hub_model_id,
+ push_to_hub=args.push_to_hub,
+ )
+ print("Model trained. Running test inference.")
+ model_inference(model_path=args.base_model, adapter_path=args.output_dir, data_path=args.data_path)
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/arrow_multitask/arrow_phi3_mini.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/arrow_multitask/arrow_phi3_mini.py
new file mode 100644
index 0000000000000000000000000000000000000000..13f7fcad5883c266fd2cca0a7e0056c80ba70e7a
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/arrow_multitask/arrow_phi3_mini.py
@@ -0,0 +1,383 @@
+# Copyright 2025-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This script provides a simple evaluation pipeline for multiple-choice reasoning datasets
+(e.g., BoolQ, HellaSwag, ARC, OpenBookQA, Winogrande) with different composition strategies.
+
+Usage examples:
+ python arrow_phi3_mini.py --strategy base --ds_name arc-challenge
+ python arrow_phi3_mini.py --strategy arrow --ds_name boolq
+ python arrow_phi3_mini.py --strategy gks --ds_name hswag
+
+Key features:
+- Supports three strategies:
+ • "base" → Evaluate the quantized base model directly
+ • "arrow" → Use Arrow modular routing with task-specific adapters
+ • "gks" → Use Arrow + GenKnowSub (subtracting general-domain knowledge)
+- Loads evaluation datasets from the Hugging Face Hub
+- Implements a batched evaluation loop that computes per-option likelihoods and selects
+ the answer with the lowest average loss
+- Reports simple accuracy
+
+Implementation details:
+- The base model is quantized to 4-bit using `BitsAndBytesConfig` (nf4, bf16 compute).
+- For Arrow and GKS, task-specific adapters are loaded from the Hugging Face Hub:
+ TahaBa/phi3-mini-clustered-flan/ts_expert_i
+- Task-specific adapters were trained on 10 clusters of FLAN tasks.
+- The clusters were created using Model-Based Clustering (MBC):
+ 1. Train a LoRA adapter for each individual task.
+ 2. Apply k-means clustering to group tasks based on these adapters.
+ 3. Train a LoRA adapter for each resulting cluster.
+For more details, see the Arrow paper: https://huggingface.co/papers/2405.11157
+
+- For GKS, general adapters are loaded from:
+ TahaBa/phi3-mini-general-adapters/...
+- These adapters were trained on English, French, and German Wikipedia data
+ using a causal language modeling objective with (507-token context → 5-token completion) pairs.
+- This setup encodes general knowledge into the LoRA space, which can then be
+ subtracted from task-specific adapters during inference to isolate and purify them.
+For more details, see the GenKnowSub paper: https://huggingface.co/papers/2505.10939
+
+- `evaluate_on_multi_choice_batched` handles tokenization, masking context tokens,
+ and computing per-choice log-likelihoods for fair comparison.
+- Accuracy is printed at the end for the selected dataset.
+
+This script is mainly meant for demonstration purposes and lightweight evaluation,
+not full-scale benchmarking (batch size / max length can be tuned).
+
+=======================================================================================
+
+Results (evaluated with microsoft/Phi-3-mini-4k-instruct, 4-bit quantization):
+
+| Dataset | Base Acc. | Arrow Acc. | Arrow+GKS Acc. |
+|--------------|-----------|------------|----------------|
+| ARC-Challenge| 0.4515 | 0.5418 | 0.5585 |
+| ARC-Easy | 0.6894 | 0.8404 | 0.8473 |
+| Winogrande | 0.5769 | 0.6550 | 0.6724 |
+| BoolQ | 0.8146 | 0.8030 | 0.8247 |
+| OpenBookQA | 0.43 | 0.448 | 0.472 |
+| HellaSwag | 0.7318 | 0.7150 | 0.7376 |
+
+Observations:
+- Arrow generally improves over the base model by routing tokens to the most relevant task adapters.
+- Applying GKS (general knowledge subtraction) consistently gives further gains compared to Arrow and Base.
+
+These numbers are not meant as leaderboard results, but as a sanity check
+to verify that the implementation works as expected and demonstrates
+the benefits of Arrow and GenKnowSub.
+"""
+
+import argparse
+import random
+
+import numpy as np
+import torch
+from datasets import load_dataset
+from sklearn.metrics import accuracy_score
+from tqdm import tqdm
+from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+
+from peft import ArrowConfig, create_arrow_model
+
+
+MODEL_NAME = "microsoft/Phi-3-mini-4k-instruct"
+MODEL_MAX_LEN = 2048
+
+
+def parse_args():
+ parser = argparse.ArgumentParser(description="Training script with strategy selection")
+
+ parser.add_argument(
+ "--strategy",
+ type=str,
+ choices=["base", "arrow", "gks"],
+ default="base",
+ help="Training strategy to use: base, arrow, or gks",
+ )
+ parser.add_argument(
+ "--ds_name",
+ type=str,
+ choices=["boolq", "hswag", "arc-easy", "arc-challenge", "oqa", "wg"],
+ default="arc-challenge",
+ help="Dataset to use: boolq, hswag, arc-easy, arc-challenge, oqa, wg",
+ )
+
+ return parser.parse_args()
+
+
+def read_test_dataset(ds_name):
+ if ds_name == "boolq":
+ ds = load_dataset("google/boolq", split="validation", trust_remote_code=True)
+ elif ds_name == "hswag":
+ ds = load_dataset("Rowan/hellaswag", split="validation", trust_remote_code=True)
+ elif ds_name == "arc-challenge":
+ ds = load_dataset("allenai/ai2_arc", "ARC-Challenge", split="validation", trust_remote_code=True)
+ elif ds_name == "arc-easy":
+ ds = load_dataset("allenai/ai2_arc", "ARC-Easy", split="validation", trust_remote_code=True)
+ elif ds_name == "oqa":
+ ds = load_dataset("allenai/openbookqa", split="validation", trust_remote_code=True)
+ elif ds_name == "wg":
+ ds = load_dataset("allenai/winogrande", "winogrande_xl", split="validation", trust_remote_code=True)
+ else:
+ raise f"Dataset {ds_name} is not supported yet."
+
+ return ds
+
+
+def extract_input_content(ds_name, row):
+ if ds_name == "boolq":
+ return f"[passage]{row['passage']}[question]{row['question']}"
+ if ds_name == "hswag":
+ return row["ctx"]
+ if (ds_name == "arc-challenge") or (ds_name == "arc-easy"):
+ return row["question"]
+ if ds_name == "oqa":
+ return row["question_stem"]
+ if ds_name == "wg":
+ return row["sentence"]
+
+
+def create_multi_choice_options(row, ds_name):
+ options_texts = []
+ content = extract_input_content(ds_name, row)
+ if ds_name == "boolq":
+ choices = ["true", "false"]
+ if ds_name == "hswag":
+ choices = row["endings"]
+ if (ds_name == "arc-challenge") or (ds_name == "arc-easy"):
+ choices = row["choices"]["text"]
+ if ds_name == "wg":
+ choices = [row["option1"], row["option2"]]
+ if ds_name == "oqa":
+ choices = row["choices"]["text"]
+
+ for choice in choices:
+ options_texts.append(f"<|user|>\n{content}<|end|>\n<|assistant|>{choice}<|end|>\n")
+
+ return options_texts
+
+
+def extract_multi_choice_target_index(row, ds_name):
+ if ds_name == "boolq":
+ return 0 if row["answer"] is True else 1
+ if ds_name == "hswag":
+ return int(row["label"])
+ if (ds_name == "arc-challenge") or (ds_name == "arc-easy"):
+ return row["choices"]["label"].index(row["answerKey"])
+ if ds_name == "wg":
+ return int(row["answer"]) - 1
+ if ds_name == "oqa":
+ return row["choices"]["label"].index(row["answerKey"])
+
+
+def set_seed(seed: int):
+ random.seed(seed)
+ np.random.seed(seed)
+ torch.manual_seed(seed)
+ if torch.cuda.is_available():
+ torch.cuda.manual_seed_all(seed)
+ elif hasattr(torch, "xpu") and torch.xpu.is_available():
+ torch.xpu.manual_seed_all(seed)
+
+
+def compute_loglike_loss(logits, labels, reduction="none"):
+ bs = logits.size(0)
+ vocab_size = logits.size(-1)
+ labels = labels.squeeze(-1)
+ shift_logits = logits[..., :-1, :].contiguous()
+ shift_labels = labels[..., 1:].contiguous()
+
+ # Flatten the tokens
+ loss_fct = torch.nn.CrossEntropyLoss(reduction=reduction)
+ shift_logits = shift_logits.view(-1, vocab_size)
+ shift_labels = shift_labels.view(-1)
+
+ shift_labels = shift_labels.to(shift_logits.device)
+ loss = loss_fct(shift_logits, shift_labels)
+
+ # reshape back
+ if reduction == "none":
+ loss = loss.view((bs, -1))
+ non_zero_loss = (loss != 0).sum(dim=-1)
+ non_zero_loss[non_zero_loss == 0] = 1
+ loss = loss.sum(dim=-1) / non_zero_loss
+
+ return loss.float() # Convert to float32 before returning
+
+
+def evaluate_on_multi_choice_batched(
+ eval_dataset, model, tokenizer, ds_name, labels, predictions, args, batch_size=32, max_length=512, device="auto"
+):
+ # Local import to mirror your original function
+ model.eval()
+
+ if device == "auto":
+ device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+ else:
+ device = torch.device(device)
+
+ for start in tqdm(
+ range(0, len(eval_dataset), batch_size), total=(len(eval_dataset) + batch_size - 1) // batch_size
+ ):
+ rows = [eval_dataset[i] for i in range(start, min(start + batch_size, len(eval_dataset)))]
+
+ # Build the flattened option texts for this batch
+ all_texts = []
+ options_per_sample = [] # number of options for each sample
+ ctx_lens_per_option = [] # context length replicated per option
+
+ for row in rows:
+ # options: ["<|user|>...<|assistant|>choiceA<|end|>", ...]
+ options = create_multi_choice_options(row, ds_name)
+ options_per_sample.append(len(options))
+
+ # compute context length once per sample (align with your -1 shift)
+ content = extract_input_content(ds_name, row)
+ context_prompt = f"<|user|>\n{content}<|end|>\n<|assistant|>"
+ ctx_len = len(tokenizer.encode(context_prompt)) - 1
+
+ all_texts.extend(options)
+ ctx_lens_per_option.extend([ctx_len] * len(options))
+
+ # collect gold label
+ labels.append(extract_multi_choice_target_index(row, ds_name))
+
+ # Tokenize all options in one go
+ tokenized = tokenizer(
+ all_texts,
+ return_tensors="pt",
+ padding=True,
+ truncation=True,
+ max_length=max_length,
+ )
+ tokenized = {k: v.to(device) for k, v in tokenized.items()}
+
+ # Create masked labels: ignore context and padding
+ masked_labels = tokenized["input_ids"].clone()
+ for i, ctx_len in enumerate(ctx_lens_per_option):
+ masked_labels[i, :ctx_len] = -100
+ masked_labels[tokenized["attention_mask"] == 0] = -100
+
+ with torch.no_grad():
+ logits = model(input_ids=tokenized["input_ids"], attention_mask=tokenized["attention_mask"]).logits
+ # per-sequence losses
+ losses = compute_loglike_loss(logits, masked_labels, reduction="none").detach().cpu()
+
+ # Reduce per sample (argmin across its options)
+ idx = 0
+ for n_opt in options_per_sample:
+ pred = torch.argmin(losses[idx : idx + n_opt]).item()
+ predictions.append(pred)
+ idx += n_opt
+
+ print(
+ f"Accuracy for dataset {args.ds_name} and strategy {args.strategy} is: {accuracy_score(labels, predictions)}"
+ )
+
+
+if __name__ == "__main__":
+ args = parse_args()
+ print(f"Selected strategy: {args.strategy}")
+ print(f"Dataset name: {args.ds_name}")
+
+ # Loading the tokeniser
+ tokenizer = AutoTokenizer.from_pretrained(
+ MODEL_NAME,
+ use_fast=True,
+ padding_side="right",
+ model_max_length=MODEL_MAX_LEN,
+ )
+
+ # Quantisation config
+ bnb_config = BitsAndBytesConfig(
+ load_in_4bit=True,
+ bnb_4bit_quant_type="nf4",
+ bnb_4bit_compute_dtype=torch.bfloat16,
+ bnb_4bit_use_double_quant=False,
+ )
+
+ # Loading the model
+ base_model = AutoModelForCausalLM.from_pretrained(
+ MODEL_NAME,
+ dtype=torch.bfloat16,
+ device_map="auto",
+ quantization_config=bnb_config,
+ )
+
+ # Loading the test dataset
+ test_dataset = read_test_dataset(args.ds_name)
+ print(f"{args.ds_name} is loaded with size: {len(test_dataset)}.")
+
+ labels, predictions = [], []
+ if args.strategy == "base":
+ # Batch-wise inference
+ with torch.no_grad():
+ evaluate_on_multi_choice_batched(
+ test_dataset,
+ base_model,
+ tokenizer,
+ args.ds_name,
+ labels,
+ predictions,
+ args,
+ batch_size=64, # tune this
+ max_length=512, # tune if options are long
+ device="auto",
+ )
+ else:
+ general_adapter_paths = []
+ if args.strategy == "gks":
+ arrow_config = ArrowConfig(
+ top_k=3,
+ router_temperature=1.0,
+ use_gks=True,
+ )
+ # General adapter paths from the hub
+ general_adapter_paths = [
+ "TahaBa/phi3-mini-general-adapters/cluster0_batch16_prop1.0_langen/checkpoint-17",
+ "TahaBa/phi3-mini-general-adapters/cluster0_batch16_prop1.0_langfr/checkpoint-35",
+ "TahaBa/phi3-mini-general-adapters/cluster0_batch16_prop1.0_langger/checkpoint-17",
+ ]
+ else:
+ arrow_config = ArrowConfig(
+ top_k=3,
+ router_temperature=1.0,
+ )
+
+ # Task-specific adapter paths from the hub
+ task_specific_adapter_paths = [f"TahaBa/phi3-mini-clustered-flan/ts_expert_{i}" for i in range(10)]
+
+ # Creating the Arrow model
+ model = create_arrow_model(
+ base_model=base_model,
+ task_specific_adapter_paths=task_specific_adapter_paths,
+ general_adapter_paths=general_adapter_paths,
+ arrow_config=arrow_config,
+ )
+
+ # Batch-wise inference
+ with torch.no_grad():
+ evaluate_on_multi_choice_batched(
+ test_dataset,
+ model,
+ tokenizer,
+ args.ds_name,
+ labels,
+ predictions,
+ args,
+ batch_size=32, # tune this
+ max_length=512, # tune if options are long
+ device="auto",
+ )
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/arrow_multitask/requirements.txt b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/arrow_multitask/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0fb1d2c4152f707035f9609a6d86319deda58e1c
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/arrow_multitask/requirements.txt
@@ -0,0 +1,8 @@
+torch
+transformers
+accelerate
+datasets
+scikit-learn
+tqdm
+numpy
+bitsandbytes
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/bdlora_finetuning/README.md b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/bdlora_finetuning/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..f1e4c5d4f13eddf6a3ad9ce021528130d7c4e52f
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/bdlora_finetuning/README.md
@@ -0,0 +1,15 @@
+# BD-LoRA Finetuning
+
+Block-Diagonal LoRA (BD-LoRA) is a LoRA variant in which some LoRA factors are constrained to be block-diagonal.
+This allows faster serving by eliminating communication overheads when running inference on multiple GPU, at the same finetuning performance as vanilla LoRA.
+
+To get an overview on how to use BD-LoRA, please view the Python notebook at `peft/examples/bdlora_finetuning/bdlora_peft_demo.ipynb`.
+
+To benefit from inference speed-ups, you need an inference engine that is compatible with BD-LoRA. At the moment, there is an experimental PR at https://github.com/vllm-project/vllm/pull/28136 which allows you to use BD-LoRA in vLLM. If you find this work useful, consider leaving a comment there.
+
+To install, you can clone the GitHub repository connected to the fork at https://github.com/Conzel/vllm/tree/bdlora-bk. Then, install vLLM following the usual instructions: https://docs.vllm.ai/en/stable/getting_started/installation/. We assume that you have a hardware setup with at least 2 available GPUs.
+
+This example folder contains 3 scripts:
+- `bdlora_peft_demo.ipynb` Showcases how to instantiate a BD-LoRA model, train it, and save/reload the weights.
+- `vllm_server.bash` Spins up a BD-LoRA compatible vLLM server. To use it, you need to run the notebook once to create adapters with the correct format.
+- `chat.py` Can be used to query the vLLM server after it has finished booting up. Usage example: `python3 chat.py --target lora1`.
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/bdlora_finetuning/bdlora-performance.png b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/bdlora_finetuning/bdlora-performance.png
new file mode 100644
index 0000000000000000000000000000000000000000..ec8769b018249474e78b7d51161d44f098428a57
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/bdlora_finetuning/bdlora-performance.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:71e00b74fe951a4d1ce715ea483e765d8f4527f3d34c2d3c210af09d2b05af26
+size 313134
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/bdlora_finetuning/bdlora-sharding.png b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/bdlora_finetuning/bdlora-sharding.png
new file mode 100644
index 0000000000000000000000000000000000000000..925a4e720e7557827793ffd8c7a9fe04f5326068
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/bdlora_finetuning/bdlora-sharding.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c6d7c46671fc6f367e486fa76936417dc2c4992af5234494058610bfd472c661
+size 351045
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/bdlora_finetuning/bdlora_peft_demo.ipynb b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/bdlora_finetuning/bdlora_peft_demo.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..f85782c52e7757a6b250edc0bf671b47526dd699
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/bdlora_finetuning/bdlora_peft_demo.ipynb
@@ -0,0 +1,439 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "e2b69494",
+ "metadata": {},
+ "source": [
+ "# Block-Diagonal LoRA for Eliminating Communication Overhead in Tensor Parallel LoRA Serving"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2fb2b221",
+ "metadata": {},
+ "source": [
+ "## Introduction\n",
+ "Block-Diagonal LoRA (BD-LoRA) is a LoRA variant in which some LoRA factors are constrained to be block-diagonal. This allows faster serving by eliminating communication overheads \n",
+ "when running inference on multiple GPUs. Despite the block-diagonal constraint, BD-LoRA is similarly performant to vanilla LoRA at similar parameter counts.\n",
+ "\n",
+ "BD-LoRA is designed to be used with tensor parallelism, which means sharding the weights of a model among multiple GPUs. A popular sharding strategy is the [Megatron Sharding Strategy](https://arxiv.org/abs/1909.08053). For two linear layers $W_1$, $W_2$ that follow each other (for example the up and down projections in a transformer MLP module), we will shard the first layer in a column-parallel way (which requires LoRA B to be block-diagonal) and the second layer in a row-parallel way (which requires LoRA A to be block-diagonal). For the attention module, this can be similarly achieved by taking the Q, K and V projections together as $W_1$ and the out projection as $W_2$, sharding accordingly. This sharding allows a compatible inference engine to distribute each block-diagonal shard over a a different GPU, cutting the need to communicate partial results among GPUs. In the image below, you can see the exact sharding strategy and how this saves computational efforts.\n",
+ "\n",
+ "Paper: https://arxiv.org/html/2510.23346v1\n",
+ "\n",
+ "
\n",
+ "\n",
+ "
\n",
+ "\n",
+ "### Performance, rank and parameter count\n",
+ "BD-LoRA achieves similar performance to LoRA (see image below, or the `method_comparison` folder in the peft repository root) at the same parameter count. However, as every other factor in BD-LoRA is block-diagonal, a BD-LoRA adapter will have less parameters than a LoRA adapter at the same rank. The performance of BD-LoRA is only competitive when the rank is then increased accordingly. We provide example code for rank-matching at the end of this example notebook.\n",
+ "\n",
+ "
\n",
+ "\n",
+ "
\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "40eea544",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/efs/aconzel/workspace/peft/bdlora-peft/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+ " from .autonotebook import tqdm as notebook_tqdm\n"
+ ]
+ }
+ ],
+ "source": [
+ "from peft.tuners import BdLoraConfig, LoraConfig\n",
+ "from peft import get_peft_model\n",
+ "from transformers import Trainer, TrainingArguments, DataCollatorForLanguageModeling, AutoModelForCausalLM, AutoTokenizer\n",
+ "from datasets import load_dataset\n",
+ "import torch"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5959e4ab",
+ "metadata": {},
+ "source": [
+ "## Quick Start\n",
+ "To use BD-LoRA, we can follow standard LoRA-training procedures. We only need to change the `LoraConfig` to a `BdLoraConfig` and specify which LoRA should be block-diagonal. \n",
+ "As an example, we will train a LLama-Model in such a way that it can later benefit from inference speed-up as specified in the BD-LoRA paper. However, BD-LoRA can be used with all other models that follow a transformer architecture. \n",
+ "\n",
+ "As explained in the introduction, we want to shard each module (MLP and attention) in an alternating fashion, first column-parallel with LoRA-B block-diagonal, then row-parallel with LoRA-A block-diagonal. Different from standard MLP modules, Llama also uses a gate projection, which we can fuse together with the up-projection.\n",
+ "\n",
+ "Therefore, we want the following block-diagonal factors (following the naming convention from the Llama architecture):\n",
+ "\n",
+ "- LoRA-A Block-Diagonal (Row-parallel sharding): Out (`out_proj`), Down (`down_proj`)\n",
+ "- LoRA-B Block-Diagonal (Column-parallel sharding): QKV (`q_proj, k_proj, v_proj`), Up+Gate (`up_proj, gate_proj`)\n",
+ "\n",
+ "Additionally, we need to know on how many GPUs we want to serve before we start training, as this corresponds to the number of block we will use for each block-diagonal factor. For this experiment, we will use 2 blocks (equivalent to a tensor-parallelism degree of 2). Caveat: For a small model such as Llama 3.2-1B which we are using, one would use a single GPU for serving, and use TP=2 or TP=8 only for larger models, like Llama 3.1-8B or Llama 3.3-70B respectively. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "6180c1f9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model_name = \"meta-llama/Llama-3.2-1B\"\n",
+ "model = AutoModelForCausalLM.from_pretrained(model_name)\n",
+ "tokenizer = AutoTokenizer.from_pretrained(model_name)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "6a50e350",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "trainable params: 44,826,624 || all params: 1,280,641,024 || trainable%: 3.5003\n"
+ ]
+ }
+ ],
+ "source": [
+ "target_modules=[\"q_proj\", \"v_proj\", \"k_proj\", \"up_proj\", \"gate_proj\", \"o_proj\", \"down_proj\"]\n",
+ "# Set this equal to the number of GPUs you want to serve the model with later\n",
+ "nblocks = 2\n",
+ "\n",
+ "bdlora_config = BdLoraConfig(\n",
+ " target_modules_bd_a=[\"o_proj\", \"down_proj\"],\n",
+ " target_modules_bd_b=[\"q_proj\", \"v_proj\", \"k_proj\", \"up_proj\", \"gate_proj\"],\n",
+ " nblocks=nblocks\n",
+ ")\n",
+ "\n",
+ "config = LoraConfig(\n",
+ " r=96,\n",
+ " # adjust target modules and the ...target_modules_bd attributes according to model architecture (for example renaming)\n",
+ " target_modules=target_modules,\n",
+ " use_bdlora=bdlora_config,\n",
+ " lora_bias=False\n",
+ ")\n",
+ "\n",
+ "peft_model = get_peft_model(model, config)\n",
+ "peft_model.print_trainable_parameters()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c1facfea",
+ "metadata": {},
+ "source": [
+ "## Training\n",
+ "We train the model for 10 steps, this training block is just intended to showcase how BD-LoRA integrates into other huggingface tools."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "64e4681b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "
"
+ ]
+ },
+ "metadata": {}
+ },
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "TrainOutput(global_step=500, training_loss=0.09815525007247924, metrics={'train_runtime': 90.6767, 'train_samples_per_second': 5.514, 'train_steps_per_second': 5.514, 'total_flos': 79477977907200.0, 'train_loss': 0.09815525007247924, 'epoch': 5.0})"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 10
+ }
+ ],
+ "source": [
+ "training_args = TrainingArguments(\n",
+ " output_dir='../.',\n",
+ " use_cpu=False,\n",
+ " auto_find_batch_size=False,\n",
+ " learning_rate=1e-4,\n",
+ " logging_steps=100,\n",
+ " per_device_train_batch_size=1,\n",
+ " save_total_limit=1,\n",
+ " remove_unused_columns=False,\n",
+ " num_train_epochs=5,\n",
+ " fp16=True,\n",
+ " save_strategy='no',\n",
+ " report_to=\"none\"\n",
+ ")\n",
+ "\n",
+ "trainer = Trainer(\n",
+ " model=model,\n",
+ " args=training_args,\n",
+ " train_dataset=cpt_train_dataset, # Custom CPT training dataset.\n",
+ " data_collator=CPTDataCollatorForLanguageModeling(tokenizer, training=True, mlm=False)\n",
+ ")\n",
+ "\n",
+ "trainer.train()"
+ ],
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2024-10-22T09:25:27.599132Z",
+ "start_time": "2024-10-22T09:25:13.906685Z"
+ },
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 268
+ },
+ "id": "1a865c2ad2dc7218",
+ "outputId": "c4bfd785-e354-4ee6-a87e-63c17bfd2605"
+ },
+ "id": "1a865c2ad2dc7218",
+ "execution_count": 10
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# Model Evaluation\n",
+ "\n",
+ "---"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "id": "b799ea89a567590f"
+ },
+ "id": "b799ea89a567590f"
+ },
+ {
+ "cell_type": "code",
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stderr",
+ "text": [
+ "100%|██████████| 100/100 [00:00<00:00, 1972.82it/s]\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Sentence: input: it 's a charming and often affecting journey . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: unflinchingly bleak and desperate output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: allows us to hope that nolan is poised to embark a major career as a commercial yet inventive filmmaker . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: the acting , costumes , music , cinematography and sound are all astounding given the production 's austere locales . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: it 's slow -- very , very slow . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: although laced with humor and a few fanciful touches , the film is a refreshingly serious look at young women . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: a sometimes tedious film . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: or doing last year 's taxes with your ex-wife . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: you do n't have to know about music to appreciate the film 's easygoing blend of comedy and romance . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: in exactly 89 minutes , most of which passed as slowly as if i 'd been sitting naked on an igloo , formula 51 sank from quirky to jerky to utter turkey . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: the mesmerizing performances of the leads keep the film grounded and keep the audience riveted . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: it takes a strange kind of laziness to waste the talents of robert forster , anne meara , eugene levy , and reginald veljohnson all in the same movie . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: ... the film suffers from a lack of humor ( something needed to balance out the violence ) ... output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: we root for ( clara and paul ) , even like them , though perhaps it 's an emotion closer to pity . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: even horror fans will most likely not find what they 're seeking with trouble every day ; the movie lacks both thrills and humor . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: a gorgeous , high-spirited musical from india that exquisitely blends music , dance , song , and high drama . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: the emotions are raw and will strike a nerve with anyone who 's ever had family trauma . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: audrey tatou has a knack for picking roles that magnify her outrageous charm , and in this literate french comedy , she 's as morning-glory exuberant as she was in amélie . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: ... the movie is just a plain old monster . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: in its best moments , resembles a bad high school production of grease , without benefit of song . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: pumpkin takes an admirable look at the hypocrisy of political correctness , but it does so with such an uneven tone that you never know when humor ends and tragedy begins . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: the iditarod lasts for days - this just felt like it did . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: holden caulfield did it better . output: negative \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is negative\n",
+ "Sentence: input: a delectable and intriguing thriller filled with surprises , read my lips is an original . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: seldom has a movie so closely matched the spirit of a man and his work . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: nicks , seemingly uncertain what 's going to make people laugh , runs the gamut from stale parody to raunchy sex gags to formula romantic comedy . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: the action switches between past and present , but the material link is too tenuous to anchor the emotional connections that purport to span a 125-year divide . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: it 's an offbeat treat that pokes fun at the democratic exercise while also examining its significance for those who take part . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: it 's a cookie-cutter movie , a cut-and-paste job . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: i had to look away - this was god awful . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: thanks to scott 's charismatic roger and eisenberg 's sweet nephew , roger dodger is one of the most compelling variations on in the company of men . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: ... designed to provide a mix of smiles and tears , `` crossroads '' instead provokes a handful of unintentional howlers and numerous yawns . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: a gorgeous , witty , seductive movie . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: if the movie succeeds in instilling a wary sense of ` there but for the grace of god , ' it is far too self-conscious to draw you deeply into its world . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: it does n't believe in itself , it has no sense of humor ... it 's just plain bored . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: a sequence of ridiculous shoot - 'em - up scenes . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: the weight of the piece , the unerring professionalism of the chilly production , and the fascination embedded in the lurid topic prove recommendation enough . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: ( w ) hile long on amiable monkeys and worthy environmentalism , jane goodall 's wild chimpanzees is short on the thrills the oversize medium demands . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: as surreal as a dream and as detailed as a photograph , as visually dexterous as it is at times imaginatively overwhelming . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: escaping the studio , piccoli is warmly affecting and so is this adroitly minimalist movie . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: there 's ... tremendous energy from the cast , a sense of playfulness and excitement that seems appropriate . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: this illuminating documentary transcends our preconceived vision of the holy land and its inhabitants , revealing the human complexities beneath . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: the subtle strength of `` elling '' is that it never loses touch with the reality of the grim situation . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: holm ... embodies the character with an effortlessly regal charisma . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: the title not only describes its main characters , but the lazy people behind the camera as well . output: negative \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is negative\n",
+ "Sentence: input: it offers little beyond the momentary joys of pretty and weightless intellectual entertainment . output: negative \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is negative\n",
+ "Sentence: input: a synthesis of cliches and absurdities that seems positively decadent in its cinematic flash and emptiness . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: a subtle and well-crafted ( for the most part ) chiller . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: has a lot of the virtues of eastwood at his best . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: it 's hampered by a lifetime-channel kind of plot and a lead actress who is out of her depth . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: it feels like an after-school special gussied up with some fancy special effects , and watching its rote plot points connect is about as exciting as gazing at an egg timer for 93 minutes . output: negative \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is negative\n",
+ "Sentence: input: for the most part , director anne-sophie birot 's first feature is a sensitive , extraordinarily well-acted drama . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: mr. tsai is a very original artist in his medium , and what time is it there ? output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: sade is an engaging look at the controversial eponymous and fiercely atheistic hero . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: so devoid of any kind of intelligible story that it makes films like xxx and collateral damage seem like thoughtful treatises output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: a tender , heartfelt family drama . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: ... a hollow joke told by a cinematic gymnast having too much fun embellishing the misanthropic tale to actually engage it . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: the cold turkey would 've been a far better title . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: manages to be both repulsively sadistic and mundane . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: it 's just disappointingly superficial -- a movie that has all the elements necessary to be a fascinating , involving character study , but never does more than scratch the surface . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: this is a story of two misfits who do n't stand a chance alone , but together they are magnificent . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: schaeffer has to find some hook on which to hang his persistently useless movies , and it might as well be the resuscitation of the middle-aged character . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: the primitive force of this film seems to bubble up from the vast collective memory of the combatants . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: on this tricky topic , tadpole is very much a step in the right direction , with its blend of frankness , civility and compassion . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: the script kicks in , and mr. hartley 's distended pace and foot-dragging rhythms follow . output: negative \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is negative\n",
+ "Sentence: input: you wonder why enough was n't just a music video rather than a full-length movie . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: if you 're hard up for raunchy college humor , this is your ticket right here . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: a fast , funny , highly enjoyable movie . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: good old-fashioned slash-and-hack is back ! output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: this one is definitely one to skip , even for horror movie fanatics . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: for all its impressive craftsmanship , and despite an overbearing series of third-act crescendos , lily chou-chou never really builds up a head of emotional steam . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: exquisitely nuanced in mood tics and dialogue , this chamber drama is superbly acted by the deeply appealing veteran bouquet and the chilling but quite human berling . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: uses high comedy to evoke surprising poignance . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: one of creepiest , scariest movies to come along in a long , long time , easily rivaling blair witch or the others . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: a string of rehashed sight gags based in insipid vulgarity . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: among the year 's most intriguing explorations of alientation . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: the movie fails to live up to the sum of its parts . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: the son 's room is a triumph of gentility that earns its moments of pathos . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: there is nothing outstanding about this film , but it is good enough and will likely be appreciated most by sailors and folks who know their way around a submarine . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: this is a train wreck of an action film -- a stupefying attempt by the filmmakers to force-feed james bond into the mindless xxx mold and throw 40 years of cinematic history down the toilet in favor of bright flashes and loud bangs . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: the draw ( for `` big bad love '' ) is a solid performance by arliss howard . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: green might want to hang onto that ski mask , as robbery may be the only way to pay for his next project . output: negative \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is negative\n",
+ "Sentence: input: it 's one pussy-ass world when even killer-thrillers revolve around group therapy sessions . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: though it 's become almost redundant to say so , major kudos go to leigh for actually casting people who look working-class . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: the band 's courage in the face of official repression is inspiring , especially for aging hippies ( this one included ) . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: the movie achieves as great an impact by keeping these thoughts hidden as ... ( quills ) did by showing them . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: the film flat lines when it should peak and is more missed opportunity and trifle than dark , decadent truffle . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: jaglom ... put ( s ) the audience in the privileged position of eavesdropping on his characters output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: fresnadillo 's dark and jolting images have a way of plying into your subconscious like the nightmare you had a week ago that wo n't go away . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: we know the plot 's a little crazy , but it held my interest from start to finish . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: it 's a scattershot affair , but when it hits its mark it 's brilliant . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: hardly a masterpiece , but it introduces viewers to a good charitable enterprise and some interesting real people . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: you wo n't like roger , but you will quickly recognize him . output: negative \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is negative\n",
+ "Sentence: input: if steven soderbergh 's ` solaris ' is a failure it is a glorious failure . output: positive \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is positive\n",
+ "Sentence: input: byler reveals his characters in a way that intrigues and even fascinates us , and he never reduces the situation to simple melodrama . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: this riveting world war ii moral suspense story deals with the shadow side of american culture : racial prejudice in its ugly and diverse forms . output: negative \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is negative\n",
+ "Sentence: input: it 's difficult to imagine the process that produced such a script , but here 's guessing that spray cheese and underarm noises played a crucial role . output: negative \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is negative\n",
+ "Sentence: input: no sophomore slump for director sam mendes , who segues from oscar winner to oscar-winning potential with a smooth sleight of hand . output: positive \n",
+ " \t The prediction is: positive\n",
+ " \t The GT is positive\n",
+ "Sentence: input: on the whole , the movie lacks wit , feeling and believability to compensate for its incessant coarseness and banality . output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "Sentence: input: why make a documentary about these marginal historical figures ? output: negative \n",
+ " \t The prediction is: negative\n",
+ " \t The GT is negative\n",
+ "The model Acc is 90.0%\n"
+ ]
+ }
+ ],
+ "source": [
+ "model.eval()\n",
+ "\n",
+ "# Select relevant columns from the test dataset\n",
+ "test_dataset = test_dataset.select_columns(['sentence', 'label_text'])\n",
+ "\n",
+ "# Convert the test dataset to a CPT-compatible format\n",
+ "cpt_test_dataset = CPTDataset(test_dataset, tokenizer, templates)\n",
+ "\n",
+ "# Get the device where the model is loaded (CPU, GPU or XPU)\n",
+ "device = model.device\n",
+ "list_bool_predictions = []\n",
+ "\n",
+ "for i in range(len(test_dataset)):\n",
+ " input_ids, input_type_mask = cpt_test_dataset[i]['input_ids'], cpt_test_dataset[i]['input_type_mask']\n",
+ "\n",
+ " # Pass the inputs through the model\n",
+ " outputs = model(\n",
+ " input_ids=torch.Tensor(input_ids).long().to(device=device).view(1, -1),\n",
+ " labels=torch.Tensor(input_ids).long().to(device=device).view(1, -1),\n",
+ " input_type_mask=torch.Tensor(input_type_mask).long().to(device=device).view(1, -1)\n",
+ " )\n",
+ "\n",
+ " # Shift logits to exclude the last token and match the labels\n",
+ " shifted_logits = outputs.logits[..., :-1, :].contiguous().to(model.dtype)[0, -len(input_ids) + 1:]\n",
+ " shift_labels = torch.Tensor(input_ids).long().to(device=device).view(1, -1)[0, 1:].contiguous().to(device)\n",
+ " shifted_input_type_mask = torch.Tensor(input_type_mask).long().to(device=device).view(1, -1)[..., 1:].contiguous().to(device)\n",
+ "\n",
+ " # Create a mask for the type `4` tokens (label tokens)\n",
+ " mask = torch.Tensor(shifted_input_type_mask).long().to(device=device).view(-1,) == 4\n",
+ "\n",
+ " # Extract logits and labels corresponding to the mask\n",
+ " logit = shifted_logits[mask]\n",
+ " label = shift_labels[mask]\n",
+ "\n",
+ " # All possible label tokens for `negative` and `positive`\n",
+ " all_labels = torch.Tensor([tokenizer(i, add_special_tokens=False)[\"input_ids\"] for i in ['negative', 'positive']]).long().to(device).view(-1,)\n",
+ "\n",
+ " # Compare logits with label tokens and infer prediction\n",
+ " prediction = logit[0, torch.Tensor([tokenizer(i, add_special_tokens=False)[\"input_ids\"] for i in ['negative', 'positive']]).long().to(device).view(-1,)].argmax()\n",
+ " prediction_text = 'negative' if prediction == 0 else 'positive'\n",
+ " print(f\"Sentence: {tokenizer.decode(input_ids)} \\n \\t The prediction is: {prediction_text}\\n \\t The GT is {tokenizer.decode(label)}\")\n",
+ " list_bool_predictions.append(prediction_text == tokenizer.decode(label))\n",
+ "\n",
+ "print(f'The model Acc is {100 * np.mean(list_bool_predictions)}%')"
+ ],
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2024-10-22T09:25:28.252009Z",
+ "start_time": "2024-10-22T09:25:27.598326Z"
+ },
+ "id": "48e7d976e6e01212",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "40dd1226-fa31-4e77-dc7e-e06a3600304e"
+ },
+ "id": "48e7d976e6e01212",
+ "execution_count": 11
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 2
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython2",
+ "version": "2.7.6"
+ },
+ "colab": {
+ "provenance": [],
+ "gpuType": "T4"
+ },
+ "accelerator": "GPU",
+ "widgets": {
+ "application/vnd.jupyter.widget-state+json": {
+ "72a5be4b77ec4d5994bcace9d462da84": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "model_module_version": "1.5.0",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "HBoxModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "HBoxView",
+ "box_style": "",
+ "children": [
+ "IPY_MODEL_bed78529ff2c4d08befca97c50cb5efc",
+ "IPY_MODEL_cf7077acfce04aff8af0a2483dbf094c",
+ "IPY_MODEL_910462d70d944d00ba54958d77bee755"
+ ],
+ "layout": "IPY_MODEL_a899818bdad0415b860eaac4afe31f30"
+ }
+ },
+ "bed78529ff2c4d08befca97c50cb5efc": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "model_module_version": "1.5.0",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "HTMLModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "HTMLView",
+ "description": "",
+ "description_tooltip": null,
+ "layout": "IPY_MODEL_3d78a6c8923547cf8c75bc8c10125eda",
+ "placeholder": "",
+ "style": "IPY_MODEL_8083f95a673a423286ade63051de757d",
+ "value": "Map: 100%"
+ }
+ },
+ "cf7077acfce04aff8af0a2483dbf094c": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "model_module_version": "1.5.0",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "FloatProgressModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "ProgressView",
+ "bar_style": "success",
+ "description": "",
+ "description_tooltip": null,
+ "layout": "IPY_MODEL_13fc203ab1b44c83b6cfcc1e171d26ad",
+ "max": 100,
+ "min": 0,
+ "orientation": "horizontal",
+ "style": "IPY_MODEL_663a0196d2b547fd8a6890b8a86080c2",
+ "value": 100
+ }
+ },
+ "910462d70d944d00ba54958d77bee755": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "model_module_version": "1.5.0",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "HTMLModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "HTMLView",
+ "description": "",
+ "description_tooltip": null,
+ "layout": "IPY_MODEL_72be01164e974d59b05bee716e9bc978",
+ "placeholder": "",
+ "style": "IPY_MODEL_4cedaf37e79e4ff1a10ffb96ec543e81",
+ "value": " 100/100 [00:00<00:00, 1327.06 examples/s]"
+ }
+ },
+ "a899818bdad0415b860eaac4afe31f30": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "model_module_version": "1.2.0",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "3d78a6c8923547cf8c75bc8c10125eda": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "model_module_version": "1.2.0",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "8083f95a673a423286ade63051de757d": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "model_module_version": "1.5.0",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "DescriptionStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "description_width": ""
+ }
+ },
+ "13fc203ab1b44c83b6cfcc1e171d26ad": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "model_module_version": "1.2.0",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "663a0196d2b547fd8a6890b8a86080c2": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "model_module_version": "1.5.0",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "ProgressStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "bar_color": null,
+ "description_width": ""
+ }
+ },
+ "72be01164e974d59b05bee716e9bc978": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "model_module_version": "1.2.0",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "4cedaf37e79e4ff1a10ffb96ec543e81": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "model_module_version": "1.5.0",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "DescriptionStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "description_width": ""
+ }
+ }
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/delora_finetuning/README.md b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/delora_finetuning/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..20c18ae059babcd5664fa7da353b630cf7233bfd
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/delora_finetuning/README.md
@@ -0,0 +1,102 @@
+# DeLoRA: Decoupled Low-Rank Adaptation
+
+## Introduction
+[DeLoRA](https://huggingface.co/papers/2503.18225) tackles finetuning in a Frobenius-norm bounded setup: this allows to prevent divergence from the pretrained model, effectively decoupling the learning of angles and magnitudes.
+
+This is done by (i) normalization of the BA low-rank matrices, which bound the updates' Frobenius norm, (ii) learnable scaling lambda, which controls the update's boundary/magnitude, (iii) layer-wise scaling of ||W||, to adapt each update's norm to the original weights' norm.
+
+## Quick start
+
+With respect to your standard PEFT training procedure with LoRA, simply swap your `LoraConfig` for a `DeloraConfig`. Note however that `lora_alpha` parameter is replaced by `delora_lambda` parameter which sets an upper bound to the Frobenius norm of the weight change.
+
+```python
+import torch
+from peft import DeloraConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from trl import SFTConfig, SFTTrainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-8B", dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B")
+tokenizer.pad_token_id = tokenizer.eos_token_id
+delora_config = DeloraConfig(r=32, delora_lambda=15)
+
+peft_model = get_peft_model(model, delora_config)
+peft_model.print_trainable_parameters()
+
+dataset = load_dataset("imdb", split="train[:1%]")
+
+training_args = SFTConfig(dataset_text_field="text", max_length=128)
+trainer = SFTTrainer(
+ model=peft_model,
+ args=training_args,
+ train_dataset=dataset,
+ processing_class=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("delora-llama-3-8b")
+```
+
+To utilize the fine-tuned DeLoRA modules, simply run the following command:
+```python
+import torch
+from peft import PeftModel
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained(
+ "meta-llama/Meta-Llama-3-8B", dtype=torch.bfloat16, device_map="auto"
+)
+peft_model = PeftModel.from_pretrained(model, "delora-llama-3-8b")
+```
+
+## Advanced Usage
+In this script the default DeLoRA layers are the query and value layers of the Llama model. Adding adapters on more layers will increase memory usage. If you wish to choose a different set of layers for DeLoRA to be applied on, you can simply define it using:
+```bash
+python examples/delora_finetuning/delora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --target_modules "q_proj,k_proj,v_proj,o_proj"
+```
+
+Using different lambdas for different layers is also possible by setting `lambda_pattern`.
+
+### Fine-tune
+```bash
+python delora_finetuning.py \
+ --base_model "PATH_TO_MODEL" \
+ --data_path "PATH_TO_DATASET" \
+ --output_dir "PATH_TO_OUTPUT_DIR" \
+ --batch_size 1 \
+ --num_epochs 3 \
+ --learning_rate 3e-3 \
+ --cutoff_len 512 \
+ --val_set_size 500 \
+ --eval_step 10 \
+ --save_step 100 \
+ --device "auto" \
+ --rank 32 \
+ --delora_lambda 15 \
+ --module_dropout 0.1 \
+ --target_modules "q_proj,v_proj" \
+ --hub_model_id "YOUR_HF_REPO" \
+ --push_to_hub
+```
+
+## Additional Notes
+### Best practices
+- use 10-100x larger learning rate than standard LoRA variants (typical values from 1e-3/1e-2/..)
+- do not set a too small initial boundary parameter lambda (typical values are around 10/15/..)
+
+
+### DeLoRA vs DoRA
+DeLoRA might feel quite similar to DoRA (given the similar target of decoupling angular from magnitude learning), however it presents key differences: (i) DoRA applies normalization and scaling operations on the fully finetuned weights ($W + \Delta W$), (ii) DoRA's normalization operation is performed on the column space of the weight matrices.
+
+Conversely DeLoRA (i) introduces the normalization and scaling operations directly on the weight updates $\Delta W$, better preventing divergence from the pretrained model, and (ii) normalizes the inner low-dimensional space, which enforces a Frobenius-norm boundary to the weight updates.
+
+
+## Citation
+```
+@inproceedings{bini2025decouplinganglesstrengthlowrank,
+ title={Decoupling Angles and Strength in Low-rank Adaptation},
+ author={Massimo Bini and Leander Girrbach and Zeynep Akata},
+ year={2025},
+ booktitle={International Conference on Learning Representations (ICLR)},
+}
+```
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/delora_finetuning/delora_finetuning.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/delora_finetuning/delora_finetuning.py
new file mode 100644
index 0000000000000000000000000000000000000000..01107b06f7dc2caa5d74213d9439e865916fa773
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/delora_finetuning/delora_finetuning.py
@@ -0,0 +1,189 @@
+# This script is based on examples/randlora_finetuning/randlora_finetuning.py
+import os
+
+import torch
+from datasets import load_dataset
+from transformers import (
+ AutoModelForCausalLM,
+ AutoTokenizer,
+ DataCollatorForLanguageModeling,
+ Trainer,
+ TrainingArguments,
+)
+
+from peft import DeloraConfig, get_peft_model
+
+
+def train_model(
+ base_model: str,
+ data_path: str,
+ output_dir: str,
+ batch_size: int,
+ num_epochs: int,
+ learning_rate: float,
+ cutoff_len: int,
+ val_set_size: int,
+ eval_step: int,
+ save_step: int,
+ device: str,
+ rank: int,
+ delora_lambda: int,
+ module_dropout: float,
+ target_modules: str,
+ hub_model_id: str,
+ push_to_hub: bool,
+):
+ os.environ["TOKENIZERS_PARALLELISM"] = "false"
+ hf_token = os.getenv("HF_TOKEN")
+
+ # Setup device
+ device = torch.device(device)
+ print(f"Using device: {device}")
+
+ # load tokenizer
+ tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token)
+
+ # Compute type
+ device_type = device.type
+ device_module = getattr(torch, device_type, torch.cuda)
+ bf16_supported = device_module.is_available() and device_module.is_bf16_supported()
+ dtype = torch.bfloat16 if bf16_supported else torch.float32
+
+ # Load the base model
+ model = AutoModelForCausalLM.from_pretrained(
+ base_model,
+ dtype=dtype,
+ )
+
+ # DeLoRA config for the PEFT model
+ peft_config = DeloraConfig(
+ r=rank,
+ delora_lambda=delora_lambda,
+ target_modules=(target_modules.split(",") if target_modules else None),
+ module_dropout=module_dropout,
+ bias="none",
+ )
+
+ # get the peft model with DeLoRA config
+ model = get_peft_model(model, peft_config)
+
+ model.to(device) # MODEL TO ACCELERATOR
+ tokenizer.pad_token = tokenizer.eos_token
+
+ # Load the dataset
+ dataset = load_dataset(data_path)
+
+ def tokenize_function(examples):
+ inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len)
+ inputs["labels"] = inputs["input_ids"].copy() # setting labels for a language modeling task
+ return inputs
+
+ # Tokenize the dataset and prepare for training
+ tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names)
+
+ # Data collator to dynamically pad the batched examples
+ data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+ # Compute the total amount of training step for warmup
+ max_steps = int((len(dataset) // batch_size) * num_epochs)
+
+ # Define training arguments
+ training_args = TrainingArguments(
+ output_dir=output_dir,
+ num_train_epochs=num_epochs,
+ per_device_train_batch_size=batch_size,
+ per_device_eval_batch_size=batch_size,
+ warmup_steps=int(max_steps * 0.1), # 10% of total trainig steps
+ weight_decay=0.0,
+ logging_steps=eval_step,
+ save_steps=save_step,
+ save_total_limit=2,
+ push_to_hub=push_to_hub,
+ hub_model_id=hub_model_id,
+ gradient_accumulation_steps=16,
+ learning_rate=learning_rate,
+ hub_token=hf_token,
+ label_names=["labels"],
+ )
+
+ # Clear accelerator cache to free memory
+ device_module.empty_cache()
+
+ # Initialize the Trainer
+ trainer = Trainer(
+ model=model,
+ args=training_args,
+ train_dataset=tokenized_datasets["train"],
+ eval_dataset=tokenized_datasets["test"],
+ data_collator=data_collator,
+ )
+
+ # Start model training
+ trainer.train()
+
+ # Save and push the trained model and tokenizer
+ if push_to_hub:
+ # Push the main model to the hub
+ trainer.push_to_hub(commit_message="Fine-tuned model")
+
+ # Save the model and tokenizer locally
+ model.save_pretrained(output_dir)
+ tokenizer.save_pretrained(output_dir)
+
+
+if __name__ == "__main__":
+ import argparse
+
+ parser = argparse.ArgumentParser(description="Fine-tune LLaMA with DeLoRA")
+ parser.add_argument("--base_model", type=str, default="huggyllama/llama-7b", help="Base model path or name")
+ parser.add_argument(
+ "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name"
+ )
+ parser.add_argument(
+ "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model"
+ )
+ parser.add_argument("--batch_size", type=int, default=1, help="Batch size")
+ parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs")
+ parser.add_argument("--learning_rate", type=float, default=3e-3, help="Learning rate")
+ parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization")
+ parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size")
+ parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval")
+ parser.add_argument("--save_step", type=int, default=100, help="Save step interval")
+ parser.add_argument("--device", type=str, default="auto", help="Device to use for training")
+ parser.add_argument("--rank", type=int, default=32, help="DeLoRA basis rank")
+ parser.add_argument("--delora_lambda", type=int, default=640, help="DeLoRA alpha")
+ parser.add_argument("--module_dropout", type=float, default=0.05, help="DeLoRA dropout rate")
+ parser.add_argument(
+ "--target_modules", type=str, default=None, help="Comma-separated list of target modules for DeLoRA"
+ )
+ parser.add_argument(
+ "--hub_model_id",
+ type=str,
+ default="path/to/repo",
+ help="Repository name to push the model on the Hugging Face Hub",
+ )
+ parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub")
+ args = parser.parse_args()
+
+ if args.device == "auto":
+ args.device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+
+ train_model(
+ base_model=args.base_model,
+ data_path=args.data_path,
+ output_dir=args.output_dir,
+ batch_size=args.batch_size,
+ num_epochs=args.num_epochs,
+ learning_rate=args.learning_rate,
+ cutoff_len=args.cutoff_len,
+ val_set_size=args.val_set_size,
+ eval_step=args.eval_step,
+ save_step=args.save_step,
+ device=args.device,
+ rank=args.rank,
+ delora_lambda=args.delora_lambda,
+ module_dropout=args.module_dropout,
+ target_modules=args.target_modules,
+ hub_model_id=args.hub_model_id,
+ push_to_hub=args.push_to_hub,
+ )
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/dna_language_models/dna_lm.ipynb b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/dna_language_models/dna_lm.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..70360879dec511676290762c6e8bd67a9c6221de
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/dna_language_models/dna_lm.ipynb
@@ -0,0 +1,2860 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "db4dc272-88fe-47ad-98fd-b94d4f840dca",
+ "metadata": {
+ "id": "db4dc272-88fe-47ad-98fd-b94d4f840dca"
+ },
+ "source": [
+ "# PEFT with DNA Language Models"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d381f473-0d37-4b5b-ae9e-d2b32bab7c04",
+ "metadata": {
+ "id": "d381f473-0d37-4b5b-ae9e-d2b32bab7c04"
+ },
+ "source": [
+ "This notebook demonstrates how to utilize parameter-efficient fine-tuning techniques (PEFT) from the PEFT library to fine-tune a DNA Language Model (DNA-LM). The fine-tuned DNA-LM will be applied to solve a task from the nucleotide benchmark dataset. Parameter-efficient fine-tuning (PEFT) techniques are crucial for adapting large pre-trained models to specific tasks with limited computational resources."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "23f460c3-d7e5-437f-a5e9-d029cd225bf8",
+ "metadata": {
+ "id": "23f460c3-d7e5-437f-a5e9-d029cd225bf8"
+ },
+ "source": [
+ "### 1. Import relevant libraries"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "29a35f95-738a-4f5e-88ce-dc5f8f9be5dc",
+ "metadata": {
+ "id": "29a35f95-738a-4f5e-88ce-dc5f8f9be5dc"
+ },
+ "source": [
+ "We'll start by importing the required libraries, including the PEFT library and other dependencies."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "0a40abdf-ca1c-436f-a2af-603cd67a45a4",
+ "metadata": {
+ "id": "0a40abdf-ca1c-436f-a2af-603cd67a45a4"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/opt/homebrew/anaconda3/envs/peft/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+ " from .autonotebook import tqdm as notebook_tqdm\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch\n",
+ "import transformers\n",
+ "import peft\n",
+ "import tqdm\n",
+ "import numpy as np"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a445f8be-545d-4085-a5f9-c64983655224",
+ "metadata": {
+ "id": "a445f8be-545d-4085-a5f9-c64983655224"
+ },
+ "source": [
+ "### 2. Load models\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "63782b55-1c38-4e44-b003-e57daa813bed",
+ "metadata": {
+ "id": "63782b55-1c38-4e44-b003-e57daa813bed"
+ },
+ "source": [
+ "We'll load a pre-trained DNA Language Model, \"SpeciesLM\", that serves as the base for fine-tuning. This is done using the transformers library from HuggingFace.\n",
+ "\n",
+ "The tokenizer and the model comes from the paper, \"Species-aware DNA language models capture regulatory elements and their evolution\". [Paper Link](https://www.biorxiv.org/content/10.1101/2023.01.26.525670v2), [Code Link](https://github.com/gagneurlab/SpeciesLM). They introduce a species-aware DNA language model, which is trained on more than 800 species spanning over 500 million years of evolution."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "dac961f4-c450-4124-923e-f4ba9bbd5e07",
+ "metadata": {
+ "id": "dac961f4-c450-4124-923e-f4ba9bbd5e07"
+ },
+ "outputs": [],
+ "source": [
+ "from transformers import AutoTokenizer, AutoModelForMaskedLM"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "e73fae58-03e9-4acc-b0fc-9bc810c7d366",
+ "metadata": {
+ "id": "e73fae58-03e9-4acc-b0fc-9bc810c7d366"
+ },
+ "outputs": [],
+ "source": [
+ "tokenizer = AutoTokenizer.from_pretrained(\"gagneurlab/SpeciesLM\", revision = \"downstream_species_lm\")\n",
+ "lm = AutoModelForMaskedLM.from_pretrained(\"gagneurlab/SpeciesLM\", revision = \"downstream_species_lm\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ca43b893-2d66-4e93-a08f-b17a92040709",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "ca43b893-2d66-4e93-a08f-b17a92040709",
+ "outputId": "ccbac964-a329-414d-f537-3cae7da66cf2"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "BertForMaskedLM(\n",
+ " (bert): BertModel(\n",
+ " (embeddings): BertEmbeddings(\n",
+ " (word_embeddings): Embedding(5504, 768, padding_idx=0)\n",
+ " (position_embeddings): Embedding(512, 768)\n",
+ " (token_type_embeddings): Embedding(2, 768)\n",
+ " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+ " (dropout): Dropout(p=0.1, inplace=False)\n",
+ " )\n",
+ " (encoder): BertEncoder(\n",
+ " (layer): ModuleList(\n",
+ " (0-11): 12 x BertLayer(\n",
+ " (attention): BertAttention(\n",
+ " (self): BertSdpaSelfAttention(\n",
+ " (query): Linear(in_features=768, out_features=768, bias=True)\n",
+ " (key): Linear(in_features=768, out_features=768, bias=True)\n",
+ " (value): Linear(in_features=768, out_features=768, bias=True)\n",
+ " (dropout): Dropout(p=0.1, inplace=False)\n",
+ " )\n",
+ " (output): BertSelfOutput(\n",
+ " (dense): Linear(in_features=768, out_features=768, bias=True)\n",
+ " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+ " (dropout): Dropout(p=0.1, inplace=False)\n",
+ " )\n",
+ " )\n",
+ " (intermediate): BertIntermediate(\n",
+ " (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
+ " (intermediate_act_fn): GELUActivation()\n",
+ " )\n",
+ " (output): BertOutput(\n",
+ " (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
+ " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+ " (dropout): Dropout(p=0.1, inplace=False)\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ " (cls): BertOnlyMLMHead(\n",
+ " (predictions): BertLMPredictionHead(\n",
+ " (transform): BertPredictionHeadTransform(\n",
+ " (dense): Linear(in_features=768, out_features=768, bias=True)\n",
+ " (transform_act_fn): GELUActivation()\n",
+ " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+ " )\n",
+ " (decoder): Linear(in_features=768, out_features=5504, bias=True)\n",
+ " )\n",
+ " )\n",
+ ")"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "lm.eval()\n",
+ "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+ "lm.to(device);"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c1bda6f2-34bb-4ce2-aa3f-3013548b0a28",
+ "metadata": {
+ "id": "c1bda6f2-34bb-4ce2-aa3f-3013548b0a28"
+ },
+ "source": [
+ "### 2. Prepare datasets"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f4c61e59-457c-47d9-8929-5e8cd32d3125",
+ "metadata": {
+ "id": "f4c61e59-457c-47d9-8929-5e8cd32d3125"
+ },
+ "source": [
+ "We'll load the `nucleotide_transformer_downstream_tasks` dataset, which contains 18 downstream tasks from the Nucleotide Transformer paper. This dataset provides a consistent genomics benchmark with binary classification tasks."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f5c0b3df-911a-4645-9140-99ee489515e8",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 145,
+ "referenced_widgets": [
+ "03bba232d3974119acf8031bc086a072",
+ "9107f7bfc8d3483390f802b0458e9380",
+ "f5c80fa70ead4c86aa3b2a046061b901",
+ "57966a469ca1458daab74e81672ae855",
+ "1464502dc3dd46308be8b4fcc9d5ddb9",
+ "92f64c7e088342b9b3c070ba7a295ed0",
+ "ab0aa8af3816422e9d97934f12af842c",
+ "ff89a891bd9c42a8be164587a94ccac1",
+ "e113a50f8ed2410ca12ce7cb38a1681d",
+ "1afa6e9b69c74136863b7747e62a0608",
+ "0838d19b226d486285a26ce0b04d7e15",
+ "7bdab33f4b244fc89408b91755bf17c5",
+ "4d4ce0d35c124690b3427e84a9a128b1",
+ "33be6b0ca8fd44188f834a48a9574a72",
+ "74e9bc1ead434ae78077df6b85f1df58",
+ "e1acc6e70b9246a5b063b3e262f01c81",
+ "078c6877377a491d97d6fadd27064a76",
+ "d46ee1c39bac44c2b541a88c883de1cb",
+ "12f1de7122a7471e90f01d9e7be81178",
+ "dad286d42a514c9ca6bb01bfe9e9c4be",
+ "c028ed977b5e479fbd93b8add588a6dc",
+ "6d80dec073e449efba272fa9f3527922",
+ "c311b777514f41ef986756a386c0bb34",
+ "e2e4bf053ce442f6aee6ffab5f76525f",
+ "c88cf701e20b4354a63ac7d8645d1df9",
+ "f71c252ada474be882b0335ed9a0a1c3",
+ "e059c665229e46ea905dcbd6fc179c88",
+ "bd5273325a4b453e8053d98a09fe9493",
+ "8f20ed2b74d84e80a8d403793354adea",
+ "57c9af47364d48ffbb4ffbdd2c951ede",
+ "fa9d75fcb1d5400c8ca1d1d13d28d0c7",
+ "682644a713b145f0b2dcff99790c6d4d",
+ "9b9b9d573d44464f9a6f5030a40245fe",
+ "ec165fdbe87a4b00a6c288ef1e85c0a9",
+ "17859b793a304e389d1ea0b9ccc3646f",
+ "34921fd116cc42b7b530174d9f61e71e",
+ "2d5466a5e98849c5a09f16faa98f91da",
+ "952397f9c91c480184fa57e175ab1b4c",
+ "86bcccb842244f4f9add58f62facaace",
+ "78b5bbf4c8ac4fe5961776fded4d5798",
+ "c80062a855cb41a28ac625ab03635da2",
+ "aecd740c17c84d45b0615d4fc4196035",
+ "39640709e7174f84a50da05764abbf99",
+ "7114a029e75c4ed5b966eddd3a3c919d"
+ ]
+ },
+ "id": "f5c0b3df-911a-4645-9140-99ee489515e8",
+ "outputId": "15315be1-9d07-4c46-acda-c65cb5a05250"
+ },
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "03bba232d3974119acf8031bc086a072",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Downloading data: 0%| | 0.00/3.50M [00:00\n",
+ " \n",
+ " \n",
+ " [65/65 01:43, Epoch 5/5]\n",
+ " \n",
+ "
Copy a token from your Hugging Face\ntokens page and paste it below. Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
"
+ }
+ },
+ "e297072ab5d64815b90bc89d22503378": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "e4e1a4338c5e46b3ba5a3bb960da7107": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "e56c22f77c884caaacfafd48dfa51a55": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "ProgressStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "bar_color": null,
+ "description_width": ""
+ }
+ },
+ "e69cd88ccbae4bb7b238fa112a60f0f9": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "DescriptionStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "description_width": ""
+ }
+ },
+ "e92b30d0b4234af6b5a33bff989b1b45": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "ea1bdb5f2da64332960bccd967a84b4a": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "HTMLModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "HTMLModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "HTMLView",
+ "description": "",
+ "description_tooltip": null,
+ "layout": "IPY_MODEL_347540dc03d34e65b7ffbb0f5fc569aa",
+ "placeholder": "",
+ "style": "IPY_MODEL_7243d8e2e1cc4043a2ee310eabd0ac09",
+ "value": " 177/177 [00:00<00:00, 11.4kB/s]"
+ }
+ },
+ "eadeec171e7b4c0f9e26964f031cfb71": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "HTMLModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "HTMLModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "HTMLView",
+ "description": "",
+ "description_tooltip": null,
+ "layout": "IPY_MODEL_de3757d6125a4c07b502dd60816bafec",
+ "placeholder": "",
+ "style": "IPY_MODEL_8c4d6f4eea3742289a2604e66b0c6182",
+ "value": "tokenizer_config.json: 100%"
+ }
+ },
+ "ec014d847e394a309b6a82c30a6fdfc5": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "ProgressStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "bar_color": null,
+ "description_width": ""
+ }
+ },
+ "ede66e196fa9482498f58dcdffd494a2": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "HTMLModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "HTMLModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "HTMLView",
+ "description": "",
+ "description_tooltip": null,
+ "layout": "IPY_MODEL_026072374b7d47c194707a50f5c99099",
+ "placeholder": "",
+ "style": "IPY_MODEL_63ac7dafeb27446cb30aaddf4cd27c9f",
+ "value": "Map: 100%"
+ }
+ },
+ "ee4e4af964ec4dd597cb04a90f0697f9": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "f07c8a6ec12f46ea9e32a2208e70bccd": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "DescriptionStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "description_width": ""
+ }
+ },
+ "f2ab2fa803e94328a237e84cd4ea0027": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "FloatProgressModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "ProgressView",
+ "bar_style": "success",
+ "description": "",
+ "description_tooltip": null,
+ "layout": "IPY_MODEL_5690d92586494b9187147f32fa708405",
+ "max": 1105272,
+ "min": 0,
+ "orientation": "horizontal",
+ "style": "IPY_MODEL_317cda72329c4043ab0b224b46b259d3",
+ "value": 1105272
+ }
+ },
+ "f4ca7b63d7d749ff83a848e250f03ec1": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "f7e59b47f9b74523843f37268212d566": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "DescriptionStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "description_width": ""
+ }
+ },
+ "f81756eb9e554899b0778311f2c407c4": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "f86b969ef69b48119619e1a424b50460": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "fbc6a2834c5442fbb6667f1b3612bb5b": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "DescriptionStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "description_width": ""
+ }
+ },
+ "feae525923d5407bb69a922954c474f7": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "FloatProgressModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "ProgressView",
+ "bar_style": "success",
+ "description": "",
+ "description_tooltip": null,
+ "layout": "IPY_MODEL_bac377ed96ae4e8db9b298bb623888ec",
+ "max": 50566,
+ "min": 0,
+ "orientation": "horizontal",
+ "style": "IPY_MODEL_02d6cc4c2717434c895798601bda7c86",
+ "value": 50566
+ }
+ },
+ "ffe561df8772443ebf40a3b8b656079f": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "DescriptionStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "description_width": ""
+ }
+ },
+ "fffbf696c07744fc8e3d81ab51dc9c90": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ }
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/dora_finetuning/README.md b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/dora_finetuning/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..20250476e44cebe27eb3e817b08f283dbe1570cf
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/dora_finetuning/README.md
@@ -0,0 +1,105 @@
+# DoRA: Weight-Decomposed Low-Rank Adaptation
+
+
+
+
+## Introduction
+[DoRA](https://huggingface.co/papers/2402.09353) is a novel approach that leverages low rank adaptation through weight decomposition analysis to investigate the inherent differences between full fine-tuning and LoRA. DoRA initially decomposes the pretrained weight into its magnitude and directional components and finetunes both of them. Because the directional component is large in terms of parameter numbers, we further decompose it with LoRA for efficient finetuning. This results in enhancing both the learning capacity and training stability of LoRA while avoiding any additional inference overhead.
+
+## Quick start
+```python
+import torch
+from peft import LoraConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("huggyllama/llama-7b", device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("huggyllama/llama-7b")
+dataset = load_dataset("timdettmers/openassistant-guanaco", split="train")
+lora_config = LoraConfig(
+ use_dora=True
+)
+peft_model = get_peft_model(model, lora_config)
+trainer = transformers.Trainer(
+ model=peft_model,
+ train_dataset=dataset,
+ dataset_text_field="text",
+ max_length=2048,
+ tokenizer=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("dora-llama-3-8b")
+```
+
+There is no additional change needed to your standard LoRA procedure, except for specifying `use_dora = True` option in your lora configuration.
+
+
+Run the finetuning script simply by running:
+```bash
+python examples/dora_finetuning/dora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --data_path timdettmers/openassistant-guanaco
+```
+This 👆🏻 by default will load the model in peft set up with LoRA config. Now if you wanna quickly compare it with Dora, all you need to do is to input ` --use_dora` in the command line. So same above example would be 👇🏻;
+
+```bash
+python examples/dora_finetuning/dora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --data_path timdettmers/openassistant-guanaco --use_dora
+```
+
+DoRA also supports quantization. To use 4-bit quantization try:
+
+```bash
+python examples/dora_finetuning/dora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --quantize
+```
+
+Similarly, by default the LoRA layers are the attention and MLP layers of LLama model, if you get to choose a different set of layers for LoRA to be applied on, you can simply define it using:
+```bash
+python examples/dora_finetuning/dora_finetuning.py --lora_target_modules "q_proj,k_proj,v_proj,o_proj"
+```
+
+### Full example of the script
+```bash
+python dora_finetuning.py \
+ --base_model "PATH_TO_MODEL" \
+ --data_path "PATH_TO_DATASET" \
+ --output_dir "PATH_TO_OUTPUT_DIR" \
+ --batch_size 1 \
+ --num_epochs 3 \
+ --learning_rate 3e-4 \
+ --cutoff_len 512 \
+ --val_set_size 500 \
+ --use_dora \
+ --quantize \
+ --eval_step 10 \
+ --save_step 100 \
+ --lora_r 16 \
+ --lora_alpha 32 \
+ --lora_dropout 0.05 \
+ --lora_target_modules "q_proj,k_proj,v_proj,o_proj" \
+ --hub_model_id "YOUR_HF_REPO" \
+ --push_to_hub
+```
+## Use the model on 🤗
+You can load and use the model as any other 🤗 models.
+```python
+from transformers import AutoModel
+model = AutoModel.from_pretrained("ShirinYamani/huggyllama-llama-7b-finetuned")
+```
+
+## DoRA vs. LoRA
+In general, DoRA finetuning on diffusion models is still experimental and is likely to require different hyperparameter values to perform best compared to LoRA.
+
+Specifically, people have noticed 2 differences to take into account in your training:
+
+1. LoRA seem to converge faster than DoRA (so a set of parameters that may lead to overfitting when training a LoRA may be working well for a DoRA)
+
+2. DoRA quality superior to LoRA especially in lower ranks: The difference in quality of DoRA of rank 8 and LoRA of rank 8 appears to be more significant than when training ranks of 32 or 64 for example.
+
+
+## Citation
+```
+@article{liu2024dora,
+ title={DoRA: Weight-Decomposed Low-Rank Adaptation},
+ author={Liu, Shih-Yang and Wang, Chien-Yi and Yin, Hongxu and Molchanov, Pavlo and Wang, Yu-Chiang Frank and Cheng, Kwang-Ting and Chen, Min-Hung},
+ journal={arXiv preprint arXiv:2402.09353},
+ year={2024}
+}
+```
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/dora_finetuning/dora-caching.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/dora_finetuning/dora-caching.py
new file mode 100644
index 0000000000000000000000000000000000000000..bdcff097ac7c7833a77da08f9ec98355d9bc8a68
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/dora_finetuning/dora-caching.py
@@ -0,0 +1,126 @@
+# Copyright 2025-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Small script to measure DoRA caching efficiency
+"""
+
+import argparse
+import time
+from contextlib import contextmanager
+
+import torch
+from transformers import AutoModelForCausalLM
+
+from peft import LoraConfig, get_peft_model
+from peft.helpers import DoraCaching
+from peft.utils import infer_device
+
+
+device = infer_device()
+# check for CPU
+if device == "cpu":
+ raise ValueError("This benchmark requires a hardware accelerator, only found CPU")
+torch_accelerator_module = getattr(torch, device, torch.cuda)
+
+
+@contextmanager
+def timeit(logs):
+ start = time.perf_counter()
+ yield
+ end = time.perf_counter()
+ dur = end - start
+ logs["time"].append(dur)
+
+
+def run_benchmark(model, num_runs):
+ logs = {
+ "time": [],
+ }
+
+ mem_start = torch_accelerator_module.max_memory_reserved()
+ for _ in range(num_runs + 1):
+ with timeit(logs):
+ for i in range(3):
+ x = torch.randint(10, 100, (1, 50)).to(device)
+ model(x)
+ mem_end = torch_accelerator_module.max_memory_reserved()
+ logs["memory"] = (mem_end - mem_start) / 1024**2
+
+ # remove the first run (warm up)
+ del logs["time"][0]
+ return logs
+
+
+def main(model_id, num_runs):
+ model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.bfloat16, device_map=device)
+ base_memory = torch_accelerator_module.max_memory_reserved() / 1024**2
+
+ # LORA
+ config = LoraConfig(init_lora_weights=False, use_dora=False)
+ model = get_peft_model(model, config)
+ model.eval()
+ torch_accelerator_module.reset_peak_memory_stats()
+ logs_lora = run_benchmark(model, num_runs)
+ avg_duration_lora = sum(logs_lora["time"]) / num_runs
+ max_memory_lora = logs_lora["memory"] + base_memory
+
+ # DORA
+ del model
+ torch_accelerator_module.empty_cache()
+
+ model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.bfloat16, device_map=device)
+ base_memory = torch_accelerator_module.max_memory_reserved() / 1024**2
+ config = LoraConfig(init_lora_weights=False, use_dora=True)
+ model = get_peft_model(model, config)
+ model.eval()
+
+ # WITHOUT CACHING
+ torch_accelerator_module.reset_peak_memory_stats()
+ logs_dora_no_caching = run_benchmark(model, num_runs)
+ avg_duration_no_caching = sum(logs_dora_no_caching["time"]) / num_runs
+ max_memory_no_caching = logs_dora_no_caching["memory"] + base_memory
+
+ # WITH CACHING
+ torch_accelerator_module.reset_peak_memory_stats()
+ with DoraCaching():
+ logs_dora_caching = run_benchmark(model, num_runs)
+ avg_duration_caching = sum(logs_dora_caching["time"]) / num_runs
+ max_memory_caching = logs_dora_caching["memory"] + base_memory
+
+ print(
+ f"Benchmark results for model {model_id} with {num_runs} runs:\n\n"
+ f"avg time LoRA: {avg_duration_lora:.4f} sec\n"
+ f"avg time DoRA no caching: {avg_duration_no_caching:.4f} sec\n"
+ f"avg time DoRA with caching: {avg_duration_caching:.4f} sec\n"
+ f"\n"
+ f"memory LoRA: {max_memory_lora:.2f} MB\n"
+ f"memory DoRA no caching: {max_memory_no_caching:.2f} MB\n"
+ f"memory DoRA with caching: {max_memory_caching:.2f} MB\n"
+ f"\n"
+ f"DoRA time overhead no caching: {(avg_duration_no_caching - avg_duration_lora) / avg_duration_lora * 100:.2f}%\n"
+ f"DoRA time overhead with caching: {(avg_duration_caching - avg_duration_lora) / avg_duration_lora * 100:.2f}%\n"
+ f"\n"
+ f"DoRA memory overhead no caching: {(max_memory_no_caching - max_memory_lora) / max_memory_lora * 100:.2f}%\n"
+ f"DoRA memory overhead with caching: {(max_memory_caching - max_memory_lora) / max_memory_lora * 100:.2f}%"
+ )
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser(description="Benchmark DoRA caching efficiency")
+ parser.add_argument("--model_id", type=str, default="meta-llama/Llama-3.1-8B", help="Model ID to benchmark")
+ parser.add_argument("--num_runs", type=int, default=10, help="Number of runs for the benchmark")
+ args = parser.parse_args()
+
+ main(args.model_id, args.num_runs)
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/dora_finetuning/dora_finetuning.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/dora_finetuning/dora_finetuning.py
new file mode 100644
index 0000000000000000000000000000000000000000..c8d281fc617a96958b96fbbb91fb2514a875a03e
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/dora_finetuning/dora_finetuning.py
@@ -0,0 +1,208 @@
+import os
+
+import torch
+from datasets import load_dataset
+from transformers import (
+ AutoModelForCausalLM,
+ AutoTokenizer,
+ BitsAndBytesConfig,
+ DataCollatorForLanguageModeling,
+ Trainer,
+ TrainingArguments,
+)
+
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+
+
+def train_model(
+ base_model: str,
+ data_path: str,
+ output_dir: str,
+ batch_size: int,
+ num_epochs: int,
+ learning_rate: float,
+ cutoff_len: int,
+ val_set_size: int,
+ use_dora: bool,
+ quantize: bool,
+ eval_step: int,
+ save_step: int,
+ device: str,
+ lora_r: int,
+ lora_alpha: int,
+ lora_dropout: float,
+ lora_target_modules: str,
+ hub_model_id: str,
+ push_to_hub: bool,
+):
+ os.environ["TOKENIZERS_PARALLELISM"] = "false"
+ hf_token = os.getenv("HF_TOKEN")
+
+ # Setup device
+ if device == "auto":
+ device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+ else:
+ device = torch.device(device)
+ print(f"Using device: {device}")
+
+ # load tokenizer
+ tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token)
+
+ # QDoRA (quantized dora): IF YOU WANNA QUANTIZE THE MODEL
+ if quantize:
+ if (torch.cuda.is_available() and torch.cuda.is_bf16_supported()) or torch.xpu.is_available():
+ bnb_4bit_compute_dtype = torch.bfloat16
+ else:
+ bnb_4bit_compute_dtype = torch.float16
+ model = AutoModelForCausalLM.from_pretrained(
+ base_model,
+ token=hf_token,
+ quantization_config=BitsAndBytesConfig(
+ load_in_4bit=True,
+ bnb_4bit_compute_dtype=bnb_4bit_compute_dtype,
+ bnb_4bit_use_double_quant=True,
+ bnb_4bit_quant_type="nf4",
+ ),
+ )
+ # setup for quantized training
+ model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)
+ else:
+ model = AutoModelForCausalLM.from_pretrained(base_model, token=hf_token)
+ # LoRa config for the PEFT model
+ lora_config = LoraConfig(
+ use_dora=use_dora, # to use Dora OR compare to Lora just set the --use_dora
+ r=lora_r, # Rank of matrix
+ lora_alpha=lora_alpha,
+ target_modules=(
+ lora_target_modules.split(",")
+ if lora_target_modules
+ else ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+ ),
+ lora_dropout=lora_dropout,
+ bias="none",
+ )
+
+ # get the peft model with LoRa config
+ model = get_peft_model(model, lora_config)
+
+ model.to(device) # MODEL TO GPU/CUDA
+ tokenizer.pad_token = tokenizer.eos_token
+
+ # Load the dataset
+ dataset = load_dataset(data_path)
+
+ def tokenize_function(examples):
+ inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len)
+ inputs["labels"] = inputs["input_ids"].copy() # setting labels for a language modeling task
+ return inputs
+
+ # Tokenize the dataset and prepare for training
+ tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names)
+
+ # Data collator to dynamically pad the batched examples
+ data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+ # Define training arguments
+ training_args = TrainingArguments(
+ output_dir=output_dir,
+ num_train_epochs=num_epochs,
+ per_device_train_batch_size=batch_size,
+ per_device_eval_batch_size=batch_size,
+ warmup_steps=100,
+ weight_decay=0.01,
+ logging_dir="./logs",
+ logging_steps=eval_step,
+ save_steps=save_step,
+ save_total_limit=2,
+ push_to_hub=push_to_hub,
+ hub_model_id=hub_model_id,
+ gradient_accumulation_steps=16,
+ fp16=True,
+ learning_rate=learning_rate,
+ hub_token=hf_token,
+ )
+
+ # Clear device cache to free memory
+ if torch.cuda.is_available():
+ torch.cuda.empty_cache()
+ elif torch.xpu.is_available():
+ torch.xpu.empty_cache()
+
+ # Initialize the Trainer
+ trainer = Trainer(
+ model=model,
+ args=training_args,
+ train_dataset=tokenized_datasets["train"],
+ eval_dataset=tokenized_datasets["test"],
+ data_collator=data_collator,
+ )
+
+ # Start model training
+ trainer.train()
+
+ # Save and push the trained model and tokenizer
+ if push_to_hub:
+ # Push the main model to the hub
+ trainer.push_to_hub(commit_message="Fine-tuned model")
+
+ # Save the model and tokenizer locally
+ model.save_pretrained(output_dir)
+ tokenizer.save_pretrained(output_dir)
+
+
+if __name__ == "__main__":
+ import argparse
+
+ parser = argparse.ArgumentParser(description="Fine-tune LLaMA with DoRA and PEFT")
+ parser.add_argument("--base_model", type=str, default="huggyllama/llama-7b", help="Base model path or name")
+ parser.add_argument(
+ "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name"
+ )
+ parser.add_argument(
+ "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model"
+ )
+ parser.add_argument("--batch_size", type=int, default=1, help="Batch size")
+ parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs")
+ parser.add_argument("--learning_rate", type=float, default=3e-4, help="Learning rate")
+ parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization")
+ parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size")
+ parser.add_argument("--use_dora", action="store_true", help="Apply Dora")
+ parser.add_argument("--quantize", action="store_true", help="Use quantization")
+ parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval")
+ parser.add_argument("--save_step", type=int, default=100, help="Save step interval")
+ parser.add_argument("--device", type=str, default="auto", help="Device to use for training")
+ parser.add_argument("--lora_r", type=int, default=8, help="LoRA rank")
+ parser.add_argument("--lora_alpha", type=int, default=16, help="LoRA alpha")
+ parser.add_argument("--lora_dropout", type=float, default=0.05, help="LoRA dropout rate")
+ parser.add_argument(
+ "--lora_target_modules", type=str, default=None, help="Comma-separated list of target modules for LoRA"
+ )
+ parser.add_argument(
+ "--hub_model_id",
+ type=str,
+ default="path/to/repo",
+ help="Repository name to push the model on the Hugging Face Hub",
+ )
+ parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub")
+ args = parser.parse_args()
+ train_model(
+ base_model=args.base_model,
+ data_path=args.data_path,
+ output_dir=args.output_dir,
+ batch_size=args.batch_size,
+ num_epochs=args.num_epochs,
+ learning_rate=args.learning_rate,
+ cutoff_len=args.cutoff_len,
+ val_set_size=args.val_set_size,
+ use_dora=args.use_dora,
+ quantize=args.quantize,
+ eval_step=args.eval_step,
+ save_step=args.save_step,
+ device=args.device,
+ lora_r=args.lora_r,
+ lora_alpha=args.lora_alpha,
+ lora_dropout=args.lora_dropout,
+ lora_target_modules=args.lora_target_modules,
+ hub_model_id=args.hub_model_id,
+ push_to_hub=args.push_to_hub,
+ )
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/ephemeral_gpu_offloading/load_with_dora.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/ephemeral_gpu_offloading/load_with_dora.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc61925f9008af2f526c145fca9689587d75cd65
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/ephemeral_gpu_offloading/load_with_dora.py
@@ -0,0 +1,103 @@
+# Copyright 2024-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Example script demonstrating the time difference loading a model with a DoRA using ephemeral GPU offloading vs doing it purely on the CPU.
+
+Example outputs:
+$ python load_with_dora.py
+--- Loading model ---
+Loading checkpoint shards: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:04<00:00, 1.03s/it]
+--- Loading PeftModel ---
+--- Done ---
+Model loading time: 4.83s
+PeftModel loading time: 28.14s
+Use ephemeral GPU offloading: False
+
+(Note: if this was the first time you ran the script, or if your cache was cleared, the times shown above are invalid, due to the time taken to download the model and DoRA files. Just re-run the script in this case.)
+
+$ python load_with_dora.py --ephemeral_gpu_offload
+--- Loading model ---
+Loading checkpoint shards: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:03<00:00, 1.11it/s]
+--- Loading PeftModel ---
+--- Done ---
+Model loading time: 4.28s
+PeftModel loading time: 16.59s
+Use ephemeral GPU offloading: True
+
+(Note: if this was the first time you ran the script, or if your cache was cleared, the times shown above are invalid, due to the time taken to download the model and DoRA files. Just re-run the script in this case.)
+"""
+
+import argparse
+import time
+
+from huggingface_hub import snapshot_download
+from transformers import AutoModelForCausalLM
+
+from peft import PeftModel
+
+
+def main():
+ parser = argparse.ArgumentParser(description="Load a model with DoRA using ephemeral GPU offloading")
+ parser.add_argument("--model", type=str, default="NousResearch/Hermes-2-Pro-Mistral-7B", help="Model to load")
+ parser.add_argument(
+ "--dora",
+ type=str,
+ default="peft-internal-testing/DoRA-Hermes-2-Pro-Mistral-7B",
+ help="DoRA to use",
+ )
+ parser.add_argument("--ephemeral_gpu_offload", action="store_true", help="Use ephemeral GPU offloading")
+ parser.add_argument(
+ "--merge_model_path", type=str, help="Merge the model with the DoRA model and save to the given path"
+ )
+ args = parser.parse_args()
+
+ peft_model_kwargs = {
+ "ephemeral_gpu_offload": args.ephemeral_gpu_offload,
+ "max_memory": {"cpu": "256GiB"},
+ "device_map": {"": "cpu"},
+ }
+
+ # Predownload
+ try:
+ snapshot_download(repo_id=args.model)
+ except Exception as e:
+ print(f"Failed to download model: {e}")
+ # We continue anyway as this might be e.g. a local directory or something
+ try:
+ snapshot_download(repo_id=args.dora)
+ except Exception as e:
+ print(f"Failed to download DoRA: {e}")
+ # We continue anyway as this might be e.g. a local directory or something
+
+ start = time.perf_counter()
+ print("--- Loading model ---")
+ model = AutoModelForCausalLM.from_pretrained(args.model)
+ model_time = time.perf_counter() - start
+ print("--- Loading PeftModel ---")
+ peft_model = PeftModel.from_pretrained(model, args.dora, **peft_model_kwargs)
+ print("--- Done ---")
+ peft_model_time = time.perf_counter() - start
+
+ print(f"Model loading time: {model_time:.2f}s")
+ print(f"PeftModel loading time: {peft_model_time:.2f}s")
+ print(f"Use ephemeral GPU offloading: {args.ephemeral_gpu_offload}")
+
+ if args.merge_model_path is not None:
+ merged_model = peft_model.merge_and_unload(progressbar=True)
+ merged_model.save_pretrained(args.merge_model_path)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/eva_finetuning/README.md b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/eva_finetuning/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..0c710410059719eb7b50b043fa94437a45bfec28
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/eva_finetuning/README.md
@@ -0,0 +1,159 @@
+# EVA: Explained Variance Adaptation
+## Introduction ([Paper](https://huggingface.co/papers/2410.07170), [code](https://github.com/ml-jku/EVA))
+Explained Variance Adaptation (EVA) is a novel initialization method for LoRA style adapters which initializes adapter weights in a data driven manner and adaptively allocates ranks according to the variance they explain. EVA improves average performance on a multitude of tasks across various domains, such as Language generation and understanding, Image classification, and Decision Making.
+
+The abstract from the paper is:
+
+*Foundation models (FMs) are pre-trained on large-scale datasets and then fine-tuned on a downstream task for a specific application. The most successful and most commonly used fine-tuning method is to update the pre-trained weights via a low-rank adaptation (LoRA). LoRA introduces new weight matrices that are usually initialized at random with a uniform rank distribution across model weights. Recent works focus on weight-driven initialization or learning of adaptive ranks during training. Both approaches have only been investigated in isolation, resulting in slow convergence or a uniform rank distribution, in turn leading to sub-optimal performance. We propose to enhance LoRA by initializing the new weights in a data-driven manner by computing singular value decomposition on minibatches of activation vectors. Then, we initialize the LoRA matrices with the obtained right-singular vectors and re-distribute ranks among all weight matrices to explain the maximal amount of variance and continue the standard LoRA fine-tuning procedure. This results in our new method **E**xplained **V**ariance **A**daptation (EVA). We apply EVA to a variety of fine-tuning tasks ranging from language generation and understanding to image classification and reinforcement learning. EVA exhibits faster convergence than competitors and attains the highest average score across a multitude of tasks per domain.*
+
+## Quick Start
+Below is an example of how to use EVA with a causal language model. For a more detailed example see [eva_finetuning.py](https://github.com/huggingface/peft/blob/main/examples/eva_finetuning/eva_finetuning.py).
+```python
+import torch
+from datasets import load_dataset
+from torch.utils.data import DataLoader
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from peft import EvaConfig, LoraConfig, get_peft_model, initialize_lora_eva_weights
+
+
+# config
+model_name = "meta-llama/Llama-3.1-8B"
+max_seq_len = 512
+rank = 16
+alpha = 1
+rho = 2.0
+target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"]
+svd_batch_size = 4 # can be different from the batch size used in finetuning
+
+# load model and tokenizer
+model = AutoModelForCausalLM.from_pretrained(model_name)
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+tokenizer.pad_token = tokenizer.eos_token
+
+# load dataset
+dataset = load_dataset("Rowan/hellaswag")
+dataset = dataset.map(
+ lambda x: tokenizer(x["ctx"], padding="max_length", truncation=True, max_length=max_seq_len),
+ batched=True,
+ remove_columns=dataset["train"].column_names,
+)
+dataset.set_format(type="torch")
+
+# create dataloader for SVD
+# typically this is the same as the dataloader used for finetuning
+dataloader = DataLoader(
+ dataset["train"],
+ batch_size=svd_batch_size,
+ collate_fn=lambda examples: {k: torch.stack([v[k] for v in examples], dim=0) for k in examples[0].keys()},
+)
+
+# setup peft config
+eva_config = EvaConfig(
+ rho=rho
+)
+peft_config = LoraConfig(
+ r=rank,
+ lora_alpha=alpha,
+ target_modules=target_modules,
+ init_lora_weights="eva",
+ eva_config=eva_config
+)
+
+# move model to accelerator
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+model = model.to(device)
+
+# to optimize memory usage during EVA initialization, set low_cpu_mem_usage=True
+peft_model = get_peft_model(model, peft_config, low_cpu_mem_usage=True)
+
+initialize_lora_eva_weights(peft_model, dataloader)
+```
+`initialize_lora_eva_weights` will compute the SVD and load the components into the model. After this continue with standard LoRA finetuning.
+
+## Using EVA with Bitsandbytes
+EVA is fully compatible with bitsandbytes. Simply initialize the pretrained model with a BitsAndBytesConfig and then use the peft model with EVA.
+```python
+from transformers import BitsAndBytesConfig
+from peft import prepare_model_for_kbit_training
+
+model = AutoModelForCausalLM.from_pretrained(
+ "meta-llama/Llama-3.1-8B",
+ quantization_config=BitsAndBytesConfig(load_in_4bit=True)
+)
+model = prepare_model_for_kbit_training(model)
+peft_model = get_peft_model(model, peft_config)
+initialize_lora_eva_weights(peft_model, dataloader)
+```
+
+## Getting the EVA state_dict without loading the adapter weights
+In some cases you might just want to get the state_dict after EVA initialization without loading the adapter weights. This can be useful for example if:
+- you want to precompute and store the state_dict for different downstream tasks.
+- you need to quantize the model for finetuning but want to perform EVA initialization with model weights in full/half precision.
+- you do not intend to use a peft model for LoRA finetuning.
+- you would like to leverage multiple accelerators for EVA initialization. (At the moment this is not directly supported by `initialize_lora_eva_weights`)
+
+You can do this by calling `get_eva_state_dict` directly (you only need to pass `peft_config` if `model` is not a PeftModel):
+```python
+from peft import get_eva_state_dict
+
+eva_state_dict = get_eva_state_dict(model, dataloader, peft_config)
+```
+Later you can load the state_dict into a `PeftModel` by using the `eva_state_dict` argument in `initialize_lora_eva_weights`:
+```python
+initialize_lora_eva_weights(peft_model, eva_state_dict=eva_state_dict)
+```
+
+## Leveraging multiple accelerators
+
+EVA initialization can be parallelized across multiple accelerators. In this case inputs from multiple accelerators are gathered before computing the SVD for the batch. This requires that the model is wrapped in a `torch.nn.DataParallel` or `torch.nn.DistributedDataParallel` class. An example of how to use this can be found in [eva_finetuning_multi_accelerator.py](https://github.com/huggingface/peft/blob/main/examples/eva_finetuning/eva_finetuning_multi_accelerator.py).
+
+## Customizing EVA
+
+By default, EVA is designed to work with standard transformer language models. However we integrated three different parameters which can be used to customize EVA for other types of models.
+1. `forward_fn`: Defines how the forward pass during EVA initialization should be computed.
+2. `prepare_model_inputs_fn`: Can be used if it is necessary to use information contained in the original model_input to prepare the input for SVD in individual layers.
+3. `prepare_layer_inputs_fn`: Defines how layer inputs should be prepared for SVD.
+
+All three parameters can be passed to `initialize_lora_eva_weights` and `get_eva_state_dict`.
+
+### forward_fn
+
+`forward_fn` defines how the forward pass during EVA initialization should be computed. `forward_fn` receives two arguments: `model` and `inputs`. By default this is set to `forward_fn_dict` which simply returns `model(**inputs)`.
+
+### prepare_model_inputs_fn
+
+`prepare_model_inputs_fn` can be used if it is necessary to use information contained in the original model_input to prepare the input for SVD in individual layers. `prepare_model_inputs_fn` receives two arguments: `model_input` and `peft_config`. This component is separate from `prepare_layer_inputs_fn` as the output only needs to be computed once per batch. By default this parameter is set to `prepare_model_inputs_fn_language_modeling` which is used get a subset of indices based on attention and label mask to avoid including padding tokens in the SVD computation. If you would like to not use this component set `prepare_model_inputs_fn` to None. The default logic is:
+```python
+def prepare_model_inputs_fn_language_modeling(model_input, peft_config: LoraConfig):
+ mask = model_input.get("attention_mask", torch.ones_like(model_input["input_ids"])).bool()
+ if peft_config.eva_config.use_label_mask and hasattr(model_input, "labels"):
+ mask = torch.logical_and(mask, model_input["labels"] != peft_config.eva_config.label_mask_value)
+ return mask.nonzero()
+```
+
+### prepare_layer_inputs_fn
+
+`prepare_layer_inputs_fn` can be used to preprocess the layer inputs before passing them to the SVD algorithm. `prepare_layer_inputs_fn` receives three arguments: `layer_input`, `model_input` and `layer_name`. It can either be a callable or a dictionary where the keys are the layer names and the values are callables. If it is a dictionary, functions are assigned to adapter layers based on the layer names. By default a language modeling setting is assumed where model_inputs are the outputs of `prepare_model_inputs_fn_language_modeling` which is a mask of indices. If this parameter is set to None, only two modifications are made to the layer inputs
+- take the first element incase of a tuple or list.
+- if the input has more than 2 dimensions, we flatten all but the last dimension.
+
+Must always return a tensor. The default logic is:
+```python
+def prepare_layer_inputs_fn_default(layer_input, model_input, layer_name) -> torch.Tensor:
+ if isinstance(layer_input, (tuple, list)):
+ layer_input = layer_input[0]
+ return layer_input[model_input.T.unbind()]
+```
+
+## Citation
+In case you find our work useful, please consider citing it.
+
+```
+@article{paischer2024eva,
+ title={One Initialization to Rule them All: Fine-tuning via Explained Variance Adaptation},
+ author={Fabian Paischer, Lukas Hauzenberger, Thomas Schmied, Benedikt Alkin, Marc Peter Deisenroth, Sepp Hochreiter},
+ journal={arXiv preprint arXiv:2410.07170},
+ year={2024}
+}
+```
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/eva_finetuning/eva_finetuning.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/eva_finetuning/eva_finetuning.py
new file mode 100644
index 0000000000000000000000000000000000000000..4901770f0b58170fea3e2ecb9bb5fb6746d2be9e
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/eva_finetuning/eva_finetuning.py
@@ -0,0 +1,96 @@
+# Copyright 2024-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+from datasets import load_dataset
+from torch.utils.data import DataLoader
+from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments
+from utils import DataCollator, TokenizerMetaMath
+
+from peft import EvaConfig, LoraConfig, get_peft_model, initialize_lora_eva_weights
+
+
+DEVICE = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+
+# config
+model_name = "meta-llama/Llama-3.1-8B"
+max_seq_len = 512
+rank = 16
+alpha = 1
+rho = 2.0
+target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"]
+svd_batch_size = 4 # can be different from the batch size used in finetuning
+batch_size = 4
+learning_rate = 5e-4
+gradient_accumulation_steps = 8
+num_epochs = 1
+output_dir = "outputs"
+bf16 = True
+
+
+# load model and tokenizer
+model = AutoModelForCausalLM.from_pretrained(model_name)
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+
+# load dataset
+dataset = load_dataset("meta-math/MetaMathQA")
+dataset = dataset.map(
+ TokenizerMetaMath(model_name),
+ batched=True,
+ remove_columns=dataset["train"].column_names,
+)
+dataset.set_format(type="torch")
+
+# data collator
+data_collator = DataCollator(tokenizer.eos_token_id, max_length=max_seq_len)
+
+# dataloader
+dataloader = DataLoader(
+ dataset["train"],
+ batch_size=svd_batch_size,
+ collate_fn=data_collator,
+)
+
+# setup peft config
+eva_config = EvaConfig(rho=rho)
+peft_config = LoraConfig(
+ r=rank, lora_alpha=alpha, target_modules=target_modules, init_lora_weights="eva", eva_config=eva_config
+)
+
+# move model to accelerator
+model = model.to(DEVICE)
+
+# to optimize memory usage during eva initialization, set low_cpu_mem_usage=True
+peft_model = get_peft_model(model, peft_config, low_cpu_mem_usage=True)
+initialize_lora_eva_weights(peft_model, dataloader)
+
+# setup training arguments
+training_args = TrainingArguments(
+ per_device_train_batch_size=batch_size,
+ learning_rate=learning_rate,
+ gradient_accumulation_steps=gradient_accumulation_steps,
+ num_train_epochs=num_epochs,
+ output_dir=output_dir,
+ remove_unused_columns=False,
+ bf16=bf16,
+)
+
+# continue with standard finetuning
+trainer = Trainer(
+ model=peft_model,
+ args=training_args,
+ train_dataset=dataset["train"],
+ data_collator=data_collator,
+)
+trainer.train()
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/eva_finetuning/eva_finetuning_multi_accelerator.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/eva_finetuning/eva_finetuning_multi_accelerator.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a77eb6e606f1a46e1cada8dd5f5f1dd446fdfe1
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/eva_finetuning/eva_finetuning_multi_accelerator.py
@@ -0,0 +1,132 @@
+# Copyright 2024-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+
+import torch
+import torch.distributed as dist
+from datasets import load_dataset
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments
+from utils import DataCollator, TokenizerMetaMath
+
+from peft import EvaConfig, LoraConfig, get_eva_state_dict, get_peft_model, initialize_lora_eva_weights
+
+
+# run this script e.g. with: torchrun --nproc_per_node=4 eva_finetuning_multi_gpu.py
+
+# config
+model_name = "meta-llama/Llama-2-7b-hf"
+max_seq_len = 512
+rank = 16
+alpha = 1
+rho = 2.0
+target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"]
+svd_batch_size = 4 # can be different from the batch size used in finetuning
+batch_size = 4
+learning_rate = 5e-4
+gradient_accumulation_steps = 8
+num_epochs = 1
+output_dir = "outputs"
+bf16 = True
+
+
+# Initialize distributed environment
+if torch.cuda.is_available():
+ local_rank = int(os.environ.get("LOCAL_RANK", "-1"))
+ torch.cuda.set_device(local_rank)
+ dist.init_process_group("nccl")
+ world_size = dist.get_world_size()
+elif torch.xpu.is_available():
+ local_rank = int(os.environ.get("LOCAL_RANK", "-1"))
+ torch.xpu.set_device(local_rank)
+ dist.init_process_group("xccl")
+ world_size = dist.get_world_size()
+else:
+ local_rank = -1
+ world_size = 1
+
+
+# load model and tokenizer
+model = AutoModelForCausalLM.from_pretrained(model_name)
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+
+# load dataset
+dataset = load_dataset("meta-math/MetaMathQA")
+dataset = dataset.map(
+ TokenizerMetaMath(model_name),
+ batched=True,
+ remove_columns=dataset["train"].column_names,
+)
+dataset.set_format(type="torch")
+
+# data collator
+data_collator = DataCollator(tokenizer.eos_token_id, max_length=max_seq_len)
+
+# Create sampler for distributed training
+sampler = DistributedSampler(dataset["train"], num_replicas=world_size, rank=local_rank)
+
+# dataloader
+dataloader = DataLoader(
+ dataset["train"],
+ batch_size=svd_batch_size,
+ collate_fn=data_collator,
+ sampler=sampler,
+ shuffle=False,
+)
+
+sampler.set_epoch(0)
+
+# Wrap model in DDP
+model = model.to(local_rank)
+model = DDP(model, device_ids=[local_rank], output_device=local_rank)
+
+# setup peft config
+eva_config = EvaConfig(rho=rho)
+peft_config = LoraConfig(
+ r=rank, lora_alpha=alpha, target_modules=target_modules, init_lora_weights="eva", eva_config=eva_config
+)
+
+# EVA initialization
+eva_state_dict = get_eva_state_dict(model, dataloader, peft_config)
+eva_state_dict = {".".join(["base_model.model"] + k.split(".")[1:]): v for k, v in eva_state_dict.items()}
+
+# cleanup ddp
+model = model.module
+
+# initialize peft model
+peft_model = get_peft_model(model, peft_config, low_cpu_mem_usage=True)
+initialize_lora_eva_weights(peft_model, eva_state_dict=eva_state_dict)
+
+# setup training arguments
+training_args = TrainingArguments(
+ per_device_train_batch_size=batch_size,
+ learning_rate=learning_rate,
+ gradient_accumulation_steps=gradient_accumulation_steps,
+ num_train_epochs=num_epochs,
+ output_dir=output_dir,
+ remove_unused_columns=False,
+ bf16=bf16,
+)
+
+# continue with standard finetuning
+trainer = Trainer(
+ model=peft_model,
+ args=training_args,
+ train_dataset=dataset["train"],
+ data_collator=data_collator,
+)
+trainer.train()
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/eva_finetuning/utils.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/eva_finetuning/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..df7f069a07e461e7851e9515cf912497ff28c310
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/eva_finetuning/utils.py
@@ -0,0 +1,76 @@
+# Copyright 2024-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+from transformers import AutoTokenizer
+
+
+class TokenizerMetaMath:
+ PROMPT_NO_INPUT = (
+ "Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n"
+ "### Instruction:\n{query}\n\n### Response: "
+ )
+ PROMPT = (
+ "Below is an instruction that describes a task, paired with an input that provides further context. "
+ "Write a response that appropriately completes the request.\n\n"
+ "### Instruction:\n{query}\n\n### Input:\n{input}\n\n### Response: "
+ )
+
+ def format_prompt(self, query):
+ query = query.split("\n", 1)
+ if len(query) == 1 or query[1].strip("\n") == "":
+ return self.PROMPT_NO_INPUT.format(query=query[0])
+ else:
+ return self.PROMPT.format(query=query[0], input=query[1])
+
+ def __init__(self, tokenizer_path):
+ self.tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)
+
+ def __call__(self, examples):
+ prompts = [self.format_prompt(text) for text in examples["query"]]
+ completions = examples["response"]
+ return self._tokenize_fn(prompts, completions)
+
+ def _tokenize_fn(self, prompts, completions):
+ prompt_tokens = self.tokenizer(prompts, add_special_tokens=False)["input_ids"]
+ input_tokens = self.tokenizer([x + y for x, y in zip(prompts, completions)], add_special_tokens=False)[
+ "input_ids"
+ ]
+ input_tokens = [[self.tokenizer.bos_token_id] + x + [self.tokenizer.eos_token_id] for x in input_tokens]
+ prompt_length = [len(x) + 1 for x in prompt_tokens] # +1 for the bos token
+ input_length = [len(x) for x in input_tokens]
+ return {"input_ids": input_tokens, "prompt_length": prompt_length, "input_length": input_length}
+
+
+class DataCollator:
+ def __init__(self, eos_token_id, max_length=None):
+ self.eos_token_id = eos_token_id
+ self.max_length = max_length
+
+ def __call__(self, batch):
+ batch = {k: [item[k] for item in batch] for k in batch[0]}
+ input_lengths = torch.stack(batch["input_length"])
+ prompt_lengths = torch.stack(batch["prompt_length"])
+ input_ids = torch.nn.utils.rnn.pad_sequence(
+ batch["input_ids"], batch_first=True, padding_value=self.eos_token_id
+ )
+ col_indices = torch.arange(input_ids.size(1)).unsqueeze(0)
+ attention_mask = col_indices < input_lengths.unsqueeze(1)
+ label_mask = torch.logical_or(col_indices < prompt_lengths.unsqueeze(1), ~attention_mask)
+ labels = input_ids.masked_fill(label_mask, -100)
+ if self.max_length is not None:
+ input_ids = input_ids[:, : self.max_length]
+ attention_mask = attention_mask[:, : self.max_length]
+ labels = labels[:, : self.max_length]
+ return {"input_ids": input_ids, "attention_mask": attention_mask, "labels": labels}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/evaluation/lora-lm-eval.ipynb b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/evaluation/lora-lm-eval.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..253c6da49b9a3346f3a8e27c6c83282f57efadb3
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/evaluation/lora-lm-eval.ipynb
@@ -0,0 +1,4252 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "qAkXdLL2D25p"
+ },
+ "source": [
+ "## Peft model evaluation using [lm-eval-harness](https://github.com/EleutherAI/lm-evaluation-harness)\n",
+ "\n",
+ "In this notebook, we are going to learn how to evaluate the finetuned lora model on the hellaswag task using lm-eval-harness toolkit."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "o52TJHcYD25q",
+ "outputId": "c5482c79-ff56-4ffa-d20c-46c3d30d2cd5"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[33m DEPRECATION: Building 'rouge-score' using the legacy setup.py bdist_wheel mechanism, which will be removed in a future version. pip 25.3 will enforce this behaviour change. A possible replacement is to use the standardized build interface by setting the `--use-pep517` option, (possibly combined with `--no-build-isolation`), or adding a `pyproject.toml` file to the source tree of 'rouge-score'. Discussion can be found at https://github.com/pypa/pip/issues/6334\u001b[0m\u001b[33m\n",
+ "\u001b[0m\u001b[33m DEPRECATION: Building 'sqlitedict' using the legacy setup.py bdist_wheel mechanism, which will be removed in a future version. pip 25.3 will enforce this behaviour change. A possible replacement is to use the standardized build interface by setting the `--use-pep517` option, (possibly combined with `--no-build-isolation`), or adding a `pyproject.toml` file to the source tree of 'sqlitedict'. Discussion can be found at https://github.com/pypa/pip/issues/6334\u001b[0m\u001b[33m\n",
+ "\u001b[0m\u001b[33m DEPRECATION: Building 'word2number' using the legacy setup.py bdist_wheel mechanism, which will be removed in a future version. pip 25.3 will enforce this behaviour change. A possible replacement is to use the standardized build interface by setting the `--use-pep517` option, (possibly combined with `--no-build-isolation`), or adding a `pyproject.toml` file to the source tree of 'word2number'. Discussion can be found at https://github.com/pypa/pip/issues/6334\u001b[0m\u001b[33m\n",
+ "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager, possibly rendering your system unusable. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv. Use the --root-user-action option if you know what you are doing and want to suppress this warning.\u001b[0m\u001b[33m\n",
+ "\u001b[0m\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m25.1.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m25.2\u001b[0m\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpython3 -m pip install --upgrade pip\u001b[0m\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Install LM-Eval\n",
+ "!pip install -q datasets evaluate lm_eval"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "uhUflrJXD25q"
+ },
+ "source": [
+ "### First we will check the accuracy score on the hellaswag task for the base bert without finetuning"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "hwJIYD5KD25q",
+ "outputId": "51e69f81-d048-46b2-9699-658d3ffc5f08"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "If you want to use `BertLMHeadModel` as a standalone, add `is_decoder=True.`\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "7b1ea8948a0747bc98795d6459270044",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "README.md: 0.00B [00:00, ?B/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "4ec51e06812446899b66826c41697f8d",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "data/train-00000-of-00001.parquet: 0%| | 0.00/24.4M [00:00\n",
+ " \n",
+ " \n",
+ " [3910/3910 40:13, Epoch 5/5]\n",
+ " \n",
+ "
WSGG Medical Goggles, FDA registered, Safety Goggles, Fit Over Glasses, Anti-Fog, Anti-Splash (1 pack)
\n",
+ "
\n",
+ "
\n",
+ "
474000
\n",
+ "
474000
\n",
+ "
iJDMTOY 15W CREE High Power LED Angel Eye Bulbs Compatible With BMW 5 6 7 Series X3 X5 (E39 E60 E63 E65 E53), 7000K Xenon White Headlight Ring Marker Lights
\n",
+ "
\n",
+ "
\n",
+ "
18997
\n",
+ "
18997
\n",
+ "
USB Charger, Anker Elite Dual Port 24W Wall Charger, PowerPort 2 with PowerIQ and Foldable Plug, for iPhone 11/Xs/XS Max/XR/X/8/7/6/Plus, iPad Pro/Air 2/Mini 3/Mini 4, Samsung S4/S5, and More
\n",
+ "
\n",
+ "
\n",
+ "
208666
\n",
+ "
208666
\n",
+ "
AOGGY Compatible with MacBook Air 13 inch Case A1466/A1369 (2010-2017 Release) Glitter Fluorescent Color Plastic Hard Case， with Older Version MacBook Air 13 inch Keyboard Cover - Gold
\n",
+ "
\n",
+ "
\n",
+ "
326614
\n",
+ "
326614
\n",
+ "
CUTE STONE Little Kitchen Playset, Kitchen Toy Set with Realistic Sound &Light, Play Sink, Cooking Stove with Steam, Play Food and Kitchen Accessories, Great Kitchen Toys for Toddlers Kids
Copy a token from your Hugging Face\ntokens page and paste it below. Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
Copy a token from your Hugging Face\ntokens page and paste it below. Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
Copy a token from your Hugging Face\ntokens page and paste it below. Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
\n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "***** Running Evaluation *****\n",
+ " Num examples = 1816\n",
+ " Batch size = 8\n",
+ "Saving model checkpoint to ./whisper-small-hi/checkpoint-500\n",
+ "Trainer.model is not a `PreTrainedModel`, only saving its state dict.\n",
+ "Feature extractor saved in ./whisper-small-hi/checkpoint-500/preprocessor_config.json\n",
+ "/usr/local/lib/python3.8/dist-packages/torch/utils/checkpoint.py:31: UserWarning: None of the inputs have requires_grad=True. Gradients will be None\n",
+ " warnings.warn(\"None of the inputs have requires_grad=True. Gradients will be None\")\n",
+ "/usr/local/lib/python3.8/dist-packages/bitsandbytes/autograd/_functions.py:298: UserWarning: MatMul8bitLt: inputs will be cast from torch.float32 to float16 during quantization\n",
+ " warnings.warn(f\"MatMul8bitLt: inputs will be cast from {A.dtype} to float16 during quantization\")\n",
+ "***** Running Evaluation *****\n",
+ " Num examples = 1816\n",
+ " Batch size = 8\n",
+ "Saving model checkpoint to ./whisper-small-hi/checkpoint-1000\n",
+ "Trainer.model is not a `PreTrainedModel`, only saving its state dict.\n",
+ "Feature extractor saved in ./whisper-small-hi/checkpoint-1000/preprocessor_config.json\n",
+ "/usr/local/lib/python3.8/dist-packages/torch/utils/checkpoint.py:31: UserWarning: None of the inputs have requires_grad=True. Gradients will be None\n",
+ " warnings.warn(\"None of the inputs have requires_grad=True. Gradients will be None\")\n",
+ "/usr/local/lib/python3.8/dist-packages/bitsandbytes/autograd/_functions.py:298: UserWarning: MatMul8bitLt: inputs will be cast from torch.float32 to float16 during quantization\n",
+ " warnings.warn(f\"MatMul8bitLt: inputs will be cast from {A.dtype} to float16 during quantization\")\n",
+ "***** Running Evaluation *****\n",
+ " Num examples = 1816\n",
+ " Batch size = 8\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "
Copy a token from your Hugging Face\ntokens page and paste it below. Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
"
+ }
+ },
+ "e297072ab5d64815b90bc89d22503378": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "e4e1a4338c5e46b3ba5a3bb960da7107": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "e56c22f77c884caaacfafd48dfa51a55": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "ProgressStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "bar_color": null,
+ "description_width": ""
+ }
+ },
+ "e69cd88ccbae4bb7b238fa112a60f0f9": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "DescriptionStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "description_width": ""
+ }
+ },
+ "e92b30d0b4234af6b5a33bff989b1b45": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "ea1bdb5f2da64332960bccd967a84b4a": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "HTMLModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "HTMLModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "HTMLView",
+ "description": "",
+ "description_tooltip": null,
+ "layout": "IPY_MODEL_347540dc03d34e65b7ffbb0f5fc569aa",
+ "placeholder": "",
+ "style": "IPY_MODEL_7243d8e2e1cc4043a2ee310eabd0ac09",
+ "value": " 177/177 [00:00<00:00, 11.4kB/s]"
+ }
+ },
+ "eadeec171e7b4c0f9e26964f031cfb71": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "HTMLModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "HTMLModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "HTMLView",
+ "description": "",
+ "description_tooltip": null,
+ "layout": "IPY_MODEL_de3757d6125a4c07b502dd60816bafec",
+ "placeholder": "",
+ "style": "IPY_MODEL_8c4d6f4eea3742289a2604e66b0c6182",
+ "value": "tokenizer_config.json: 100%"
+ }
+ },
+ "ec014d847e394a309b6a82c30a6fdfc5": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "ProgressStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "bar_color": null,
+ "description_width": ""
+ }
+ },
+ "ede66e196fa9482498f58dcdffd494a2": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "HTMLModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "HTMLModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "HTMLView",
+ "description": "",
+ "description_tooltip": null,
+ "layout": "IPY_MODEL_026072374b7d47c194707a50f5c99099",
+ "placeholder": "",
+ "style": "IPY_MODEL_63ac7dafeb27446cb30aaddf4cd27c9f",
+ "value": "Map: 100%"
+ }
+ },
+ "ee4e4af964ec4dd597cb04a90f0697f9": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "f07c8a6ec12f46ea9e32a2208e70bccd": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "DescriptionStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "description_width": ""
+ }
+ },
+ "f2ab2fa803e94328a237e84cd4ea0027": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "FloatProgressModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "ProgressView",
+ "bar_style": "success",
+ "description": "",
+ "description_tooltip": null,
+ "layout": "IPY_MODEL_5690d92586494b9187147f32fa708405",
+ "max": 1105272,
+ "min": 0,
+ "orientation": "horizontal",
+ "style": "IPY_MODEL_317cda72329c4043ab0b224b46b259d3",
+ "value": 1105272
+ }
+ },
+ "f4ca7b63d7d749ff83a848e250f03ec1": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "f7e59b47f9b74523843f37268212d566": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "DescriptionStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "description_width": ""
+ }
+ },
+ "f81756eb9e554899b0778311f2c407c4": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "f86b969ef69b48119619e1a424b50460": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "fbc6a2834c5442fbb6667f1b3612bb5b": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "DescriptionStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "description_width": ""
+ }
+ },
+ "feae525923d5407bb69a922954c474f7": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "FloatProgressModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "ProgressView",
+ "bar_style": "success",
+ "description": "",
+ "description_tooltip": null,
+ "layout": "IPY_MODEL_bac377ed96ae4e8db9b298bb623888ec",
+ "max": 50566,
+ "min": 0,
+ "orientation": "horizontal",
+ "style": "IPY_MODEL_02d6cc4c2717434c895798601bda7c86",
+ "value": 50566
+ }
+ },
+ "ffe561df8772443ebf40a3b8b656079f": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "DescriptionStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "description_width": ""
+ }
+ },
+ "fffbf696c07744fc8e3d81ab51dc9c90": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ }
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/randlora_finetuning/randlora_finetuning.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/randlora_finetuning/randlora_finetuning.py
new file mode 100644
index 0000000000000000000000000000000000000000..01afdf2041691378184c596d1c56c54f29f474c9
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/randlora_finetuning/randlora_finetuning.py
@@ -0,0 +1,230 @@
+# This script is based on examples/dora_finetuning/dora_finetuning.py
+import os
+
+import torch
+from datasets import load_dataset
+from transformers import (
+ AutoModelForCausalLM,
+ AutoTokenizer,
+ BitsAndBytesConfig,
+ DataCollatorForLanguageModeling,
+ Trainer,
+ TrainingArguments,
+)
+
+from peft import LoraConfig, RandLoraConfig, get_peft_model, prepare_model_for_kbit_training
+
+
+def train_model(
+ base_model: str,
+ data_path: str,
+ output_dir: str,
+ batch_size: int,
+ num_epochs: int,
+ learning_rate: float,
+ cutoff_len: int,
+ val_set_size: int,
+ use_lora: bool,
+ quantize: bool,
+ eval_step: int,
+ save_step: int,
+ device: str,
+ rank: int,
+ randlora_alpha: int,
+ randlora_dropout: float,
+ randlora_target_modules: str,
+ hub_model_id: str,
+ push_to_hub: bool,
+ sparse: bool,
+ very_sparse: bool,
+):
+ os.environ["TOKENIZERS_PARALLELISM"] = "false"
+ hf_token = os.getenv("HF_TOKEN")
+
+ # Setup device
+ device = torch.device(device)
+ print(f"Using device: {device}")
+
+ # load tokenizer
+ tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token)
+
+ # Compute type
+ device_type = device.type
+ device_module = getattr(torch, device_type, torch.cuda)
+ bf16_suppotrted = device_module.is_available() and device_module.is_bf16_supported()
+ dtype = torch.bfloat16 if bf16_suppotrted else torch.float16
+
+ # QRandLora (quantized randlora): IF YOU WANNA QUANTIZE THE MODEL
+ if quantize:
+ model = AutoModelForCausalLM.from_pretrained(
+ base_model,
+ token=hf_token,
+ quantization_config=BitsAndBytesConfig(
+ load_in_4bit=True,
+ bnb_4bit_compute_dtype=torch.bfloat16 if bf16_suppotrted else torch.float16,
+ bnb_4bit_use_double_quant=True,
+ bnb_4bit_quant_type="nf4",
+ ),
+ dtype=dtype,
+ )
+ # setup for quantized training
+ model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)
+ else:
+ model = AutoModelForCausalLM.from_pretrained(
+ base_model,
+ dtype=dtype,
+ token=hf_token,
+ )
+ # LoRa config for the PEFT model
+ if use_lora:
+ peft_config = LoraConfig(
+ r=rank, # Rank of matrix
+ lora_alpha=randlora_alpha,
+ target_modules=(randlora_target_modules.split(",") if randlora_target_modules else ["k_proj", "v_proj"]),
+ lora_dropout=randlora_dropout,
+ bias="none",
+ )
+ else:
+ peft_config = RandLoraConfig(
+ r=rank, # Rank of random bases
+ randlora_alpha=randlora_alpha,
+ target_modules=(randlora_target_modules.split(",") if randlora_target_modules else ["k_proj", "v_proj"]),
+ randlora_dropout=randlora_dropout,
+ bias="none",
+ sparse=sparse,
+ very_sparse=very_sparse,
+ )
+
+ # get the peft model with RandLora config
+ model = get_peft_model(model, peft_config)
+
+ model.to(device) # MODEL TO ACCELERATOR
+ tokenizer.pad_token = tokenizer.eos_token
+
+ # Load the dataset
+ dataset = load_dataset(data_path)
+
+ def tokenize_function(examples):
+ inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len)
+ inputs["labels"] = inputs["input_ids"].copy() # setting labels for a language modeling task
+ return inputs
+
+ # Tokenize the dataset and prepare for training
+ tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names)
+
+ # Data collator to dynamically pad the batched examples
+ data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+ # Compute the total amount of training step for warmup
+ max_steps = int((len(dataset) // batch_size) * num_epochs)
+
+ # Define training arguments
+ training_args = TrainingArguments(
+ output_dir=output_dir,
+ num_train_epochs=num_epochs,
+ per_device_train_batch_size=batch_size,
+ per_device_eval_batch_size=batch_size,
+ warmup_steps=int(max_steps * 0.1), # 10% of total trainig steps
+ weight_decay=0.01,
+ logging_dir="./logs",
+ logging_steps=eval_step,
+ save_steps=save_step,
+ save_total_limit=2,
+ push_to_hub=push_to_hub,
+ hub_model_id=hub_model_id,
+ gradient_accumulation_steps=16
+ // batch_size, # Maintaining a minimum batch size of 16 post accumulation is recommended to ensure good performance
+ learning_rate=learning_rate,
+ hub_token=hf_token,
+ label_names=["labels"],
+ )
+
+ # Clear accelerator cache to free memory
+ device_module.empty_cache()
+
+ # Initialize the Trainer
+ trainer = Trainer(
+ model=model,
+ args=training_args,
+ train_dataset=tokenized_datasets["train"],
+ eval_dataset=tokenized_datasets["test"],
+ data_collator=data_collator,
+ )
+
+ # Start model training
+ trainer.train()
+
+ # Save and push the trained model and tokenizer
+ if push_to_hub:
+ # Push the main model to the hub
+ trainer.push_to_hub(commit_message="Fine-tuned model")
+
+ # Save the model and tokenizer locally
+ model.save_pretrained(output_dir)
+ tokenizer.save_pretrained(output_dir)
+
+
+if __name__ == "__main__":
+ import argparse
+
+ parser = argparse.ArgumentParser(description="Fine-tune LLaMA with DoRA and PEFT")
+ parser.add_argument("--base_model", type=str, default="huggyllama/llama-7b", help="Base model path or name")
+ parser.add_argument(
+ "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name"
+ )
+ parser.add_argument(
+ "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model"
+ )
+ parser.add_argument("--batch_size", type=int, default=1, help="Batch size")
+ parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs")
+ parser.add_argument("--learning_rate", type=float, default=3e-4, help="Learning rate")
+ parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization")
+ parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size")
+ parser.add_argument("--use_lora", action="store_true", help="Apply Lora instead of RandLora")
+ parser.add_argument("--quantize", action="store_true", help="Use quantization")
+ parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval")
+ parser.add_argument("--save_step", type=int, default=100, help="Save step interval")
+ parser.add_argument("--device", type=str, default="auto", help="Device to use for training")
+ parser.add_argument("--rank", type=int, default=32, help="RandLora basis rank")
+ parser.add_argument("--randlora_alpha", type=int, default=640, help="RandLora alpha")
+ parser.add_argument("--randlora_dropout", type=float, default=0.05, help="RandLora dropout rate")
+ parser.add_argument(
+ "--randlora_target_modules", type=str, default=None, help="Comma-separated list of target modules for RandLora"
+ )
+ parser.add_argument("--sparse", action="store_true", help="Use sparse matrix multiplication")
+ parser.add_argument("--very_sparse", action="store_true", help="Use very sparse matrix multiplication")
+ parser.add_argument(
+ "--hub_model_id",
+ type=str,
+ default="path/to/repo",
+ help="Repository name to push the model on the Hugging Face Hub",
+ )
+ parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub")
+ args = parser.parse_args()
+
+ if args.device == "auto":
+ args.device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+
+ train_model(
+ base_model=args.base_model,
+ data_path=args.data_path,
+ output_dir=args.output_dir,
+ batch_size=args.batch_size,
+ num_epochs=args.num_epochs,
+ learning_rate=args.learning_rate,
+ cutoff_len=args.cutoff_len,
+ val_set_size=args.val_set_size,
+ use_lora=args.use_lora,
+ quantize=args.quantize,
+ eval_step=args.eval_step,
+ save_step=args.save_step,
+ device=args.device,
+ rank=args.rank,
+ randlora_alpha=args.randlora_alpha,
+ randlora_dropout=args.randlora_dropout,
+ randlora_target_modules=args.randlora_target_modules,
+ hub_model_id=args.hub_model_id,
+ push_to_hub=args.push_to_hub,
+ sparse=args.sparse,
+ very_sparse=args.very_sparse,
+ )
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/road_finetuning/README.md b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/road_finetuning/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..3d8716574f239127b7d187b0098a6845624aec0f
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/road_finetuning/README.md
@@ -0,0 +1,88 @@
+# RoAd: 3-in-1: 2D Rotary Adaptation for Efficient Finetuning, Efficient Batching and Composability
+
+
+## Introduction
+
+[RoAd](https://huggingface.co/papers/2409.00119) is a novel method that adapts LLMs using simple 2D rotations. It is highly parameter-efficient,
+achieving strong performance with less than 0.1% trainable parameters.
+RoAd also supports efficient serving of mixed-adapter requests within a batch, incurring only element-wise computation overhead rather than costly batch matrix multiplications.
+Additionally, it improves model interpretability through structured and composable transformations.
+
+## Quick start
+```python
+import torch
+from peft import RoadConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("huggyllama/llama-7b", device_map="cuda")
+tokenizer = AutoTokenizer.from_pretrained("huggyllama/llama-7b")
+dataset = load_dataset("timdettmers/openassistant-guanaco", split="train")
+road_config = RoadConfig(
+ variant="1",
+)
+peft_model = get_peft_model(model, road_config)
+trainer = transformers.Trainer(
+ model=peft_model,
+ train_dataset=dataset,
+ dataset_text_field="text",
+ max_length=2048,
+ tokenizer=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("road-llama-3-8b")
+```
+
+RoAd requires a higher learning rate compared to LoRa and similar approaches, set it to around 1e-3.
+
+Run the finetuning script simply by running:
+
+```bash
+python examples/road_finetuning/road_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --data_path timdettmers/openassistant-guanaco
+```
+
+RoAd also supports quantization. To use 4-bit quantization try:
+
+```bash
+python examples/road_finetuning/road_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --quantize
+```
+
+### Full example of the script
+```bash
+python road_finetuning.py \
+ --base_model "PATH_TO_MODEL" \
+ --data_path "PATH_TO_DATASET" \
+ --output_dir "PATH_TO_OUTPUT_DIR" \
+ --batch_size 1 \
+ --num_epochs 3 \
+ --learning_rate 1e-3 \
+ --cutoff_len 512 \
+ --val_set_size 500 \
+ --quantize \
+ --eval_step 10 \
+ --save_step 100 \
+ --device "cuda:0" \
+ --variant 1 \
+ --road_target_modules "q_proj,k_proj,v_proj,o_proj" \
+ --hub_model_id "YOUR_HF_REPO" \
+ --push_to_hub
+```
+## Use the model on 🤗
+You can load and use the model as any other 🤗 models.
+```python
+from transformers import AutoModel
+model = AutoModel.from_pretrained("ppetrushkov/llama-2-7b-sql-road-test")
+```
+
+
+## Citation
+```
+@inproceedings{
+ liao2024in,
+ title={3-in-1: 2D Rotary Adaptation for Efficient Finetuning, Efficient Batching and Composability},
+ author={Baohao Liao and Christof Monz},
+ booktitle={The Thirty-eighth Annual Conference on Neural Information Processing Systems},
+ year={2024},
+ url={https://openreview.net/forum?id=rYjYwuM6yH}
+}
+```
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/road_finetuning/road_finetuning.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/road_finetuning/road_finetuning.py
new file mode 100644
index 0000000000000000000000000000000000000000..0469785db44a15f622962bc3da8447390c511290
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/road_finetuning/road_finetuning.py
@@ -0,0 +1,203 @@
+# Copyright 2025-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+
+import torch
+from datasets import load_dataset
+from transformers import (
+ AutoModelForCausalLM,
+ AutoTokenizer,
+ BitsAndBytesConfig,
+ DataCollatorForLanguageModeling,
+ Trainer,
+ TrainingArguments,
+)
+
+from peft import RoadConfig, get_peft_model, prepare_model_for_kbit_training
+
+
+def train_model(
+ base_model: str,
+ data_path: str,
+ output_dir: str,
+ batch_size: int,
+ num_epochs: int,
+ learning_rate: float,
+ cutoff_len: int,
+ val_set_size: int,
+ quantize: bool,
+ eval_step: int,
+ save_step: int,
+ device: str,
+ variant: str,
+ road_target_modules: str,
+ hub_model_id: str,
+ push_to_hub: bool,
+):
+ os.environ["TOKENIZERS_PARALLELISM"] = "false"
+ hf_token = os.getenv("HF_TOKEN")
+
+ # Setup device
+ device = torch.device(device)
+ print(f"Using device: {device}")
+
+ # load tokenizer
+ tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token)
+
+ # IF YOU WANNA QUANTIZE THE MODEL
+ if quantize:
+ model = AutoModelForCausalLM.from_pretrained(
+ base_model,
+ token=hf_token,
+ quantization_config=BitsAndBytesConfig(
+ load_in_4bit=True,
+ bnb_4bit_compute_dtype=(
+ torch.bfloat16 if torch.cuda.is_available() and torch.cuda.is_bf16_supported() else torch.float16
+ ),
+ bnb_4bit_use_double_quant=True,
+ bnb_4bit_quant_type="nf4",
+ ),
+ )
+ # setup for quantized training
+ model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)
+ else:
+ model = AutoModelForCausalLM.from_pretrained(base_model, token=hf_token, device_map="auto")
+ # RoAd config for the PEFT model
+ road_config = RoadConfig(
+ variant=variant, # Rank of matrix
+ target_modules=(
+ road_target_modules.split(",")
+ if road_target_modules
+ else ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+ ),
+ )
+
+ # get the peft model with RoAd config
+ model = get_peft_model(model, road_config)
+
+ model.to(device) # MODEL TO GPU/CUDA
+ tokenizer.pad_token = tokenizer.eos_token
+
+ # Load the dataset
+ dataset = load_dataset(data_path)
+
+ def tokenize_function(examples):
+ inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len)
+ inputs["labels"] = inputs["input_ids"].copy() # setting labels for a language modeling task
+ return inputs
+
+ # Tokenize the dataset and prepare for training
+ tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names)
+
+ # Data collator to dynamically pad the batched examples
+ data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+ # Define training arguments
+ training_args = TrainingArguments(
+ output_dir=output_dir,
+ num_train_epochs=num_epochs,
+ per_device_train_batch_size=batch_size,
+ per_device_eval_batch_size=batch_size,
+ warmup_steps=100,
+ weight_decay=0.01,
+ logging_dir="./logs",
+ logging_steps=eval_step,
+ save_steps=save_step,
+ save_total_limit=2,
+ push_to_hub=push_to_hub,
+ hub_model_id=hub_model_id,
+ gradient_accumulation_steps=16,
+ fp16=True,
+ learning_rate=learning_rate,
+ hub_token=hf_token,
+ )
+
+ # Clear CUDA cache to free memory
+ torch.cuda.empty_cache()
+
+ # Initialize the Trainer
+ trainer = Trainer(
+ model=model,
+ args=training_args,
+ train_dataset=tokenized_datasets["train"],
+ eval_dataset=tokenized_datasets["test"],
+ data_collator=data_collator,
+ )
+
+ # Start model training
+ trainer.train()
+
+ # Save and push the trained model and tokenizer
+ if push_to_hub:
+ # Push the main model to the hub
+ trainer.push_to_hub(commit_message="Fine-tuned model")
+
+ # Save the model and tokenizer locally
+ model.save_pretrained(output_dir)
+ tokenizer.save_pretrained(output_dir)
+
+
+if __name__ == "__main__":
+ import argparse
+
+ parser = argparse.ArgumentParser(description="Fine-tune LLaMA with DoRA and PEFT")
+ parser.add_argument("--base_model", type=str, default="huggyllama/llama-7b", help="Base model path or name")
+ parser.add_argument(
+ "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name"
+ )
+ parser.add_argument(
+ "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model"
+ )
+ parser.add_argument("--batch_size", type=int, default=1, help="Batch size")
+ parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs")
+ parser.add_argument("--learning_rate", type=float, default=3e-3, help="Learning rate")
+ parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization")
+ parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size")
+ parser.add_argument("--quantize", action="store_true", help="Use quantization")
+ parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval")
+ parser.add_argument("--save_step", type=int, default=100, help="Save step interval")
+ parser.add_argument("--device", type=str, default="cuda:0", help="Device to use for training")
+ parser.add_argument(
+ "--variant", type=str, default="road_1", choices=["road_1", "road_2", "road_4"], help="RoAD variant"
+ )
+ parser.add_argument(
+ "--road_target_modules", type=str, default=None, help="Comma-separated list of target modules for RoAd"
+ )
+ parser.add_argument(
+ "--hub_model_id",
+ type=str,
+ default="path/to/repo",
+ help="Repository name to push the model on the Hugging Face Hub",
+ )
+ parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub")
+ args = parser.parse_args()
+ train_model(
+ base_model=args.base_model,
+ data_path=args.data_path,
+ output_dir=args.output_dir,
+ batch_size=args.batch_size,
+ num_epochs=args.num_epochs,
+ learning_rate=args.learning_rate,
+ cutoff_len=args.cutoff_len,
+ val_set_size=args.val_set_size,
+ quantize=args.quantize,
+ eval_step=args.eval_step,
+ save_step=args.save_step,
+ device=args.device,
+ variant=args.variant,
+ road_target_modules=args.road_target_modules,
+ hub_model_id=args.hub_model_id,
+ push_to_hub=args.push_to_hub,
+ )
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/semantic_segmentation/README.md b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/semantic_segmentation/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..fa23cb02cd6cca1f6e2595e0091dbd912c655ece
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/semantic_segmentation/README.md
@@ -0,0 +1,7 @@
+# Fine-tuning for semantic segmentation using LoRA and 🤗 PEFT
+
+[](https://colab.research.google.com/github/huggingface/peft/blob/main/examples/semantic_segmentation/semantic_segmentation_peft_lora.ipynb)
+
+We provide a notebook (`semantic_segmentation_peft_lora.ipynb`) where we learn how to use [LoRA](https://huggingface.co/papers/2106.09685) from 🤗 PEFT to fine-tune an semantic segmentation by ONLY using **14%%** of the original trainable parameters of the model.
+
+LoRA adds low-rank "update matrices" to certain blocks in the underlying model (in this case the attention blocks) and ONLY trains those matrices during fine-tuning. During inference, these update matrices are _merged_ with the original model parameters. For more details, check out the [original LoRA paper](https://huggingface.co/papers/2106.09685).
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/semantic_segmentation/semantic_segmentation_peft_lora.ipynb b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/semantic_segmentation/semantic_segmentation_peft_lora.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..e21503279d32fa25fc2fef95bef29c38d8431ac9
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/semantic_segmentation/semantic_segmentation_peft_lora.ipynb
@@ -0,0 +1,1556 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "JAeWcsvLF2_6"
+ },
+ "source": [
+ "## Introduction\n",
+ "\n",
+ "In this notebook, we will learn how to use [LoRA](https://huggingface.co/papers/2106.09685) from 🤗 PEFT to fine-tune a SegFormer model variant for semantic segmentation by ONLY using **14%** of the original trainable parameters of the model. \n",
+ "\n",
+ "LoRA adds low-rank \"update matrices\" to certain blocks in the underlying model (in this case the attention blocks) and ONLY trains those matrices during fine-tuning. During inference, these update matrices are _merged_ with the original model parameters. For more details, check out the [original LoRA paper](https://huggingface.co/papers/2106.09685). \n",
+ "\n",
+ "Let's get started by installing the dependencies. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "lveGHtBcGNyc"
+ },
+ "source": [
+ "## Install dependencies\n",
+ "\n",
+ "Here we're installing `peft` from source to ensure we have access to all the bleeding edge features of `peft`. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "lbYTKXv4ZTwg",
+ "outputId": "5a033ebd-6bbd-4bf4-802c-a1bac6a48a07"
+ },
+ "outputs": [],
+ "source": [
+ "!pip install transformers accelerate evaluate datasets==3.6.0 git+https://github.com/huggingface/peft -q"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "B0fmCvTsGPah"
+ },
+ "source": [
+ "## Authentication\n",
+ "\n",
+ "We will share our fine-tuned model at the end of training. So, to do that we just authenticate using our 🤗 token. This token is available from [here](https://huggingface.co/settings/tokens). If you don't have a 🤗 account already, we highly encourage you to do so; it's free!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 331,
+ "referenced_widgets": [
+ "f2a722f371904cce80dc1c087b153ad6",
+ "6c88a55a635b4c9f946a1aa838d69f20",
+ "6c6d19cd893e4d82bae9972fa10c6d74",
+ "fc48ee28c2e44f1daa03149c8004c314",
+ "cb4053f102fc4207a1c9513f81ad6415",
+ "0dcc5a2866a349e0843673bef499dc66",
+ "b7431f99d93b4e9b8c8177ac4a7b4070",
+ "14ac809ba0bc4cd5bcd51f83105947b0",
+ "e7393e78f41b496495982490b72ef2a3",
+ "42a7b8268d8945b5bbe9d3f20bc8840c",
+ "554b55f29a5e4d5a81608d912d3635e8",
+ "3f69c7b15e5e48039777e4b6b1a51f53",
+ "5bcfe3da0ffb41ccbb9404ac35ae8945",
+ "21bf954f54db41e6ba78f76195721614",
+ "f83dd354396e4aa3acd214a6fd98efb2",
+ "24fde588dc1a49a397e379cda320ed71",
+ "9746875e74b845daab06619393b4d46b"
+ ]
+ },
+ "id": "OYhwMOj5ZTwm",
+ "outputId": "ff2d4cc4-4363-4093-8bdc-763761cbe3ef"
+ },
+ "outputs": [],
+ "source": [
+ "from huggingface_hub import notebook_login\n",
+ "\n",
+ "notebook_login()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "B9Cu7j_QGVbH"
+ },
+ "source": [
+ "## Load a dataset\n",
+ "\n",
+ "We're only loading the first 150 instances from the training set of the [SceneParse150 dataset](https://huggingface.co/datasets/scene_parse_150) to keep this example runtime short. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "sGJWDwtHZTwn",
+ "outputId": "260c874e-1844-42ba-9dc2-0f727e2930cc"
+ },
+ "outputs": [],
+ "source": [
+ "from datasets import load_dataset\n",
+ "\n",
+ "ds = load_dataset(\"scene_parse_150\", split=\"train[:150]\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "RpSPx8EHGeLM"
+ },
+ "source": [
+ "## Prepare train and test splits"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "id": "ydWKIqCUZTwo"
+ },
+ "outputs": [],
+ "source": [
+ "ds = ds.train_test_split(test_size=0.1)\n",
+ "train_ds = ds[\"train\"]\n",
+ "test_ds = ds[\"test\"]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "yHtqAQ2WGhlR"
+ },
+ "source": [
+ "## Prepare label mappers\n",
+ "\n",
+ "We create two dictionaries:\n",
+ "\n",
+ "* `label2id`: maps the semantic classes of the dataset to integer ids.\n",
+ "* `id2label`: `label2id` reversed. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "Hu8Y4dEIZTwq",
+ "outputId": "eba72235-c1a7-4c95-8c89-5ef5588d6581"
+ },
+ "outputs": [],
+ "source": [
+ "import json\n",
+ "from huggingface_hub import hf_hub_download\n",
+ "\n",
+ "repo_id = \"huggingface/label-files\"\n",
+ "filename = \"ade20k-id2label.json\"\n",
+ "id2label = json.load(open(hf_hub_download(repo_id=repo_id, filename=filename, repo_type=\"dataset\"), \"r\"))\n",
+ "id2label = {int(k): v for k, v in id2label.items()}\n",
+ "label2id = {v: k for k, v in id2label.items()}\n",
+ "num_labels = len(id2label)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "5V8nhdt0HBsk"
+ },
+ "source": [
+ "## Prepare datasets for training and evaluation"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "fNi_TKYpZTwq",
+ "outputId": "a28647b4-0deb-49cc-a1b8-c4a2ab99bb4d"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/usr/local/lib/python3.11/dist-packages/transformers/image_processing_base.py:412: UserWarning: The following named arguments are not valid for `SegformerImageProcessor.__init__` and were ignored: 'reduce_labels'\n",
+ " image_processor = cls(**image_processor_dict)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from transformers import AutoImageProcessor\n",
+ "\n",
+ "checkpoint = \"nvidia/mit-b0\"\n",
+ "image_processor = AutoImageProcessor.from_pretrained(checkpoint, do_reduce_labels=True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "id": "JAjiYzklZTwr"
+ },
+ "outputs": [],
+ "source": [
+ "from torchvision.transforms import ColorJitter\n",
+ "\n",
+ "jitter = ColorJitter(brightness=0.25, contrast=0.25, saturation=0.25, hue=0.1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "id": "_HaS12U0ZTwr"
+ },
+ "outputs": [],
+ "source": [
+ "from PIL import Image\n",
+ "import numpy as np\n",
+ "\n",
+ "\n",
+ "def handle_grayscale_image(image):\n",
+ " np_image = np.array(image)\n",
+ " if np_image.ndim == 2:\n",
+ " tiled_image = np.tile(np.expand_dims(np_image, -1), 3)\n",
+ " return Image.fromarray(tiled_image)\n",
+ " else:\n",
+ " return Image.fromarray(np_image)\n",
+ "\n",
+ "\n",
+ "def train_transforms(example_batch):\n",
+ " images = [jitter(handle_grayscale_image(x)) for x in example_batch[\"image\"]]\n",
+ " labels = [x for x in example_batch[\"annotation\"]]\n",
+ " inputs = image_processor(images, labels)\n",
+ " return inputs\n",
+ "\n",
+ "\n",
+ "def val_transforms(example_batch):\n",
+ " images = [handle_grayscale_image(x) for x in example_batch[\"image\"]]\n",
+ " labels = [x for x in example_batch[\"annotation\"]]\n",
+ " inputs = image_processor(images, labels)\n",
+ " return inputs"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "id": "Qyjsvup2ZTws"
+ },
+ "outputs": [],
+ "source": [
+ "train_ds.set_transform(train_transforms)\n",
+ "test_ds.set_transform(val_transforms)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Lu8RjicxHJiO"
+ },
+ "source": [
+ "## Evaluation function\n",
+ "\n",
+ "Including a metric during training is often helpful for evaluating your model’s performance. You can quickly load a evaluation method with the [🤗 Evaluate](https://huggingface.co/docs/evaluate/index) library. For this task, load the [mean Intersection over Union (IoU)](https://huggingface.co/spaces/evaluate-metric/accuracy) metric (see the 🤗 Evaluate [quick tour](https://huggingface.co/docs/evaluate/a_quick_tour) to learn more about how to load and compute a metric):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "id": "TMSnlebfZTwt"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Downloading builder script: 12.9kB [00:00, 34.2MB/s]\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch\n",
+ "from torch import nn\n",
+ "import evaluate\n",
+ "\n",
+ "metric = evaluate.load(\"mean_iou\")\n",
+ "\n",
+ "\n",
+ "def compute_metrics(eval_pred):\n",
+ " with torch.no_grad():\n",
+ " logits, labels = eval_pred\n",
+ " logits_tensor = torch.from_numpy(logits)\n",
+ " # scale the logits to the size of the label\n",
+ " logits_tensor = nn.functional.interpolate(\n",
+ " logits_tensor,\n",
+ " size=labels.shape[-2:],\n",
+ " mode=\"bilinear\",\n",
+ " align_corners=False,\n",
+ " ).argmax(dim=1)\n",
+ "\n",
+ " pred_labels = logits_tensor.detach().cpu().numpy()\n",
+ " # currently using _compute instead of compute\n",
+ " # see this issue for more info: https://github.com/huggingface/evaluate/pull/328#issuecomment-1286866576\n",
+ " metrics = metric._compute(\n",
+ " predictions=pred_labels,\n",
+ " references=labels,\n",
+ " num_labels=len(id2label),\n",
+ " ignore_index=0,\n",
+ " reduce_labels=image_processor.do_reduce_labels,\n",
+ " )\n",
+ "\n",
+ " # add per category metrics as individual key-value pairs\n",
+ " per_category_accuracy = metrics.pop(\"per_category_accuracy\").tolist()\n",
+ " per_category_iou = metrics.pop(\"per_category_iou\").tolist()\n",
+ "\n",
+ " metrics.update({f\"accuracy_{id2label[i]}\": v for i, v in enumerate(per_category_accuracy)})\n",
+ " metrics.update({f\"iou_{id2label[i]}\": v for i, v in enumerate(per_category_iou)})\n",
+ "\n",
+ " return metrics"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "r304cnpxHxp5"
+ },
+ "source": [
+ "## Load a base model\n",
+ "\n",
+ "For this example, we use the [SegFormer B0 variant](https://huggingface.co/nvidia/mit-b0). "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "id": "Krvppe44a_7y"
+ },
+ "outputs": [],
+ "source": [
+ "def print_trainable_parameters(model):\n",
+ " \"\"\"\n",
+ " Prints the number of trainable parameters in the model.\n",
+ " \"\"\"\n",
+ " trainable_params = 0\n",
+ " all_param = 0\n",
+ " for _, param in model.named_parameters():\n",
+ " all_param += param.numel()\n",
+ " if param.requires_grad:\n",
+ " trainable_params += param.numel()\n",
+ " print(\n",
+ " f\"trainable params: {trainable_params} || all params: {all_param} || trainable%: {100 * trainable_params / all_param:.2f}\"\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "q_Wwl_ewID9I"
+ },
+ "source": [
+ "We pass the `label2id` and `id2label` dictionaries to let the `AutoModelForSemanticSegmentation` class know that we're interested in a custom base model where the decoder head should be randomly initialized w.r.t our custom dataset. Note, however, that the rest of the model parameters are pre-trained and will be fine-tuned in a regular transfer learning setup.\n",
+ "\n",
+ "We also notice that the 100% parameters in the `model` are trainable. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "kcdLdvIlZTwt",
+ "outputId": "a6b71dce-905e-4389-dcf6-46b43e769fcc"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Some weights of SegformerForSemanticSegmentation were not initialized from the model checkpoint at nvidia/mit-b0 and are newly initialized: ['decode_head.batch_norm.bias', 'decode_head.batch_norm.num_batches_tracked', 'decode_head.batch_norm.running_mean', 'decode_head.batch_norm.running_var', 'decode_head.batch_norm.weight', 'decode_head.classifier.bias', 'decode_head.classifier.weight', 'decode_head.linear_c.0.proj.bias', 'decode_head.linear_c.0.proj.weight', 'decode_head.linear_c.1.proj.bias', 'decode_head.linear_c.1.proj.weight', 'decode_head.linear_c.2.proj.bias', 'decode_head.linear_c.2.proj.weight', 'decode_head.linear_c.3.proj.bias', 'decode_head.linear_c.3.proj.weight', 'decode_head.linear_fuse.weight']\n",
+ "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "trainable params: 3752694 || all params: 3752694 || trainable%: 100.00\n"
+ ]
+ }
+ ],
+ "source": [
+ "from transformers import AutoModelForSemanticSegmentation, TrainingArguments, Trainer\n",
+ "\n",
+ "model = AutoModelForSemanticSegmentation.from_pretrained(\n",
+ " checkpoint, id2label=id2label, label2id=label2id, ignore_mismatched_sizes=True\n",
+ ")\n",
+ "print_trainable_parameters(model)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "4yhyYVTCInF0"
+ },
+ "source": [
+ "## Wrap `model` as a `PeftModel` for LoRA training\n",
+ "\n",
+ "This involves two steps:\n",
+ "\n",
+ "* Defining a config with `LoraConfig`\n",
+ "* Wrapping the original `model` with `get_peft_model()` with the config defined in the step above. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "YPg4W5eFB__n",
+ "outputId": "9995eb44-1c30-43e7-cc4e-691ecb1b1878"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "trainable params: 566422 || all params: 4317068 || trainable%: 13.12\n"
+ ]
+ }
+ ],
+ "source": [
+ "from peft import LoraConfig, get_peft_model\n",
+ "\n",
+ "config = LoraConfig(\n",
+ " r=32,\n",
+ " lora_alpha=32,\n",
+ " target_modules=[\"query\", \"value\"],\n",
+ " lora_dropout=0.1,\n",
+ " bias=\"lora_only\",\n",
+ " modules_to_save=[\"decode_head\"],\n",
+ ")\n",
+ "lora_model = get_peft_model(model, config)\n",
+ "print_trainable_parameters(lora_model)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "4M3wYekOI95X"
+ },
+ "source": [
+ " Let's unpack what's going on here. \n",
+ "\n",
+ "In order for LoRA to take effect, we need to specify the target modules to `LoraConfig` so that `PeftModel` knows which modules inside our model needs to be amended with LoRA matrices. In this case, we're only interested in targetting the query and value matrices of the attention blocks of the base model. Since the parameters corresponding to these matrices are \"named\" with `query` and `value` respectively, we specify them accordingly in the `target_modules` argument of `LoraConfig`. \n",
+ "\n",
+ "We also specify `modules_to_save`. After we wrap our base model `model` with `PeftModel` along with the `config`, we get a new model where only the LoRA parameters are trainable (so-called \"update matrices\") while the pre-trained parameters are kept frozen. These include the parameters of the randomly initialized classifier parameters too. This is NOT we want when fine-tuning the base model on our custom dataset. To ensure that the classifier parameters are also trained, we specify `modules_to_save`. This also ensures that these modules are serialized alongside the LoRA trainable parameters when using utilities like `save_pretrained()` and `push_to_hub()`. \n",
+ "\n",
+ "Regarding the other parameters:\n",
+ "\n",
+ "* `r`: The dimension used by the LoRA update matrices.\n",
+ "* `alpha`: Scaling factor.\n",
+ "* `bias`: Specifying if the `bias` parameters should be trained. `lora_only` denotes only the LoRA `bias` parameters will be trained. \n",
+ "\n",
+ "`r` and `alpha` together control the total number of final trainable parameters when using LoRA giving us the flexbility to balance a trade-off between end performance and compute efficiency.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "XTF68xfjJEci"
+ },
+ "source": [
+ "We can also how many parameters we're actually training. Since we're interested in performing **parameter-efficient fine-tuning**, we should expect to notice a less number of trainable parameters from the `lora_model` in comparison to the original `model` which is indeed the case here. \n",
+ "\n",
+ "For sanity, let's also manually verify the modules that are actually trainable in `lora_model`. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "PUe1Gzvd1PEP",
+ "outputId": "7b8ba17f-01fd-4ab4-d703-9a0c01cff31b"
+ },
+ "outputs": [],
+ "source": [
+ "for name, param in lora_model.named_parameters():\n",
+ " if param.requires_grad:\n",
+ " print(name, param.shape)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can confirm that only the LoRA parameters appended to the attention blocks and the `decode_head` parameters are trainable."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rX75AyI7JYVC"
+ },
+ "source": [
+ "## Train!\n",
+ "\n",
+ "This is a two-step process: \n",
+ "\n",
+ "1. Define your training hyperparameters in [TrainingArguments](https://huggingface.co/docs/transformers/v4.26.0/en/main_classes/trainer#transformers.TrainingArguments). It is important you don’t remove unused columns because this’ll drop the image column. Without the image column, you can’t create `pixel_values`. Set `remove_unused_columns=False` to prevent this behavior! The only other required parameter is output_dir which specifies where to save your model. At the end of each epoch, the `Trainer` will evaluate the IoU metric and save the training checkpoint.\n",
+ "2. Pass the training arguments to [Trainer](https://huggingface.co/docs/transformers/v4.26.0/en/main_classes/trainer#transformers.Trainer) along with the model, dataset, tokenizer, data collator, and `compute_metrics` function.\n",
+ "3. Call `train()` to finetune your model.\n",
+ "\n",
+ "\n",
+ "**Note** that This example is meant to walk you through the workflow when using PEFT for semantic segmentation. We didn't perform extensive hyperparameter tuning to achieve optimal results. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000
+ },
+ "id": "K6HVcNkDZTwu",
+ "outputId": "1b28a072-0e16-4b1a-ec32-d78e93630ef3"
+ },
+ "outputs": [],
+ "source": [
+ "model_name = checkpoint.split(\"/\")[-1]\n",
+ "\n",
+ "training_args = TrainingArguments(\n",
+ " output_dir=f\"{model_name}-scene-parse-150-lora\",\n",
+ " learning_rate=5e-4,\n",
+ " num_train_epochs=50,\n",
+ " per_device_train_batch_size=4,\n",
+ " per_device_eval_batch_size=2,\n",
+ " save_total_limit=3,\n",
+ " eval_strategy=\"epoch\",\n",
+ " save_strategy=\"epoch\",\n",
+ " logging_steps=5,\n",
+ " remove_unused_columns=False,\n",
+ " push_to_hub=True,\n",
+ " label_names=[\"labels\"],\n",
+ ")\n",
+ "\n",
+ "trainer = Trainer(\n",
+ " model=lora_model,\n",
+ " args=training_args,\n",
+ " train_dataset=train_ds,\n",
+ " eval_dataset=test_ds,\n",
+ " compute_metrics=compute_metrics,\n",
+ ")\n",
+ "\n",
+ "trainer.train()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "dacaBLE6KLdu"
+ },
+ "source": [
+ "## Saving the model and inference \n",
+ "\n",
+ "Here we use the `save_pretrained()` method of the `lora_model` to save the *LoRA-only parameters* locally. However, you can also use thr `push_to_hub()` method to upload these parameters directly to the Hugging Face Hub (as shown [here](https://colab.research.google.com/github/huggingface/peft/blob/main/examples/image_classification/image_classification_peft_lora.ipynb)). "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {
+ "id": "pvkLkrQo-6l6"
+ },
+ "outputs": [],
+ "source": [
+ "model_id = \"segformer-scene-parse-150-lora\"\n",
+ "lora_model.save_pretrained(model_id)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Ur8n41kBK4uj"
+ },
+ "source": [
+ "We can see that the LoRA-only parameters are just **2.2 MB in size**! This greatly improves the portability when using very large models. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "grzLeOT-__ht",
+ "outputId": "1ce26a27-2f38-43f3-9454-8ba11f2cfc59"
+ },
+ "outputs": [],
+ "source": [
+ "!ls -lh {model_id}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "KFYC6Z3FLB5F"
+ },
+ "source": [
+ "Let's now prepare our `inference_model` and run an inference. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "T7zeMQTaACur",
+ "outputId": "762b7fbc-07d4-4572-f107-c836e3e7928a"
+ },
+ "outputs": [],
+ "source": [
+ "from peft import PeftConfig, PeftModel\n",
+ "\n",
+ "config = PeftConfig.from_pretrained(model_id)\n",
+ "model = AutoModelForSemanticSegmentation.from_pretrained(\n",
+ " checkpoint, id2label=id2label, label2id=label2id, ignore_mismatched_sizes=True\n",
+ ")\n",
+ "# Load the Lora model\n",
+ "inference_model = PeftModel.from_pretrained(model, model_id)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "2L1R0LDWLImd"
+ },
+ "source": [
+ "Fetch an image."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 444
+ },
+ "id": "lwjRvZOmA7Hh",
+ "outputId": "44ab267d-e2b9-4bda-a52b-91968eabce29"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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",
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 43,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import requests\n",
+ "\n",
+ "url = \"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/semantic-seg-image.png\"\n",
+ "image = Image.open(requests.get(url, stream=True).raw)\n",
+ "image"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "kdK_bGhsLKKE"
+ },
+ "source": [
+ "Preprocess the image."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "G0z-3R-PBKc9",
+ "outputId": "56c91198-0116-4c2c-fc63-147dc7431b89"
+ },
+ "outputs": [],
+ "source": [
+ "# prepare image for the model\n",
+ "encoding = image_processor(image.convert(\"RGB\"), return_tensors=\"pt\")\n",
+ "print(encoding.pixel_values.shape)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "hJRijta4LLu9"
+ },
+ "source": [
+ "Run an inference. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {
+ "id": "z1p-QDoiBP56"
+ },
+ "outputs": [],
+ "source": [
+ "with torch.no_grad():\n",
+ " outputs = inference_model(pixel_values=encoding.pixel_values)\n",
+ " logits = outputs.logits\n",
+ "\n",
+ "upsampled_logits = nn.functional.interpolate(\n",
+ " logits,\n",
+ " size=image.size[::-1],\n",
+ " mode=\"bilinear\",\n",
+ " align_corners=False,\n",
+ ")\n",
+ "\n",
+ "pred_seg = upsampled_logits.argmax(dim=1)[0]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "gmYIcfL4LNtj"
+ },
+ "source": [
+ "Visualize the results.\n",
+ "\n",
+ "We need a color palette to visualize the results. Here, we use [one provided by the TensorFlow Model Garden repository](https://github.com/tensorflow/models/blob/3f1ca33afe3c1631b733ea7e40c294273b9e406d/research/deeplab/utils/get_dataset_colormap.py#L51)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {
+ "id": "jy5c6vmzBqzC"
+ },
+ "outputs": [],
+ "source": [
+ "def ade_palette():\n",
+ " \"\"\"Creates a label colormap used in ADE20K segmentation benchmark.\n",
+ " Returns:\n",
+ " A colormap for visualizing segmentation results.\n",
+ " \"\"\"\n",
+ " return np.asarray(\n",
+ " [\n",
+ " [0, 0, 0],\n",
+ " [120, 120, 120],\n",
+ " [180, 120, 120],\n",
+ " [6, 230, 230],\n",
+ " [80, 50, 50],\n",
+ " [4, 200, 3],\n",
+ " [120, 120, 80],\n",
+ " [140, 140, 140],\n",
+ " [204, 5, 255],\n",
+ " [230, 230, 230],\n",
+ " [4, 250, 7],\n",
+ " [224, 5, 255],\n",
+ " [235, 255, 7],\n",
+ " [150, 5, 61],\n",
+ " [120, 120, 70],\n",
+ " [8, 255, 51],\n",
+ " [255, 6, 82],\n",
+ " [143, 255, 140],\n",
+ " [204, 255, 4],\n",
+ " [255, 51, 7],\n",
+ " [204, 70, 3],\n",
+ " [0, 102, 200],\n",
+ " [61, 230, 250],\n",
+ " [255, 6, 51],\n",
+ " [11, 102, 255],\n",
+ " [255, 7, 71],\n",
+ " [255, 9, 224],\n",
+ " [9, 7, 230],\n",
+ " [220, 220, 220],\n",
+ " [255, 9, 92],\n",
+ " [112, 9, 255],\n",
+ " [8, 255, 214],\n",
+ " [7, 255, 224],\n",
+ " [255, 184, 6],\n",
+ " [10, 255, 71],\n",
+ " [255, 41, 10],\n",
+ " [7, 255, 255],\n",
+ " [224, 255, 8],\n",
+ " [102, 8, 255],\n",
+ " [255, 61, 6],\n",
+ " [255, 194, 7],\n",
+ " [255, 122, 8],\n",
+ " [0, 255, 20],\n",
+ " [255, 8, 41],\n",
+ " [255, 5, 153],\n",
+ " [6, 51, 255],\n",
+ " [235, 12, 255],\n",
+ " [160, 150, 20],\n",
+ " [0, 163, 255],\n",
+ " [140, 140, 140],\n",
+ " [250, 10, 15],\n",
+ " [20, 255, 0],\n",
+ " [31, 255, 0],\n",
+ " [255, 31, 0],\n",
+ " [255, 224, 0],\n",
+ " [153, 255, 0],\n",
+ " [0, 0, 255],\n",
+ " [255, 71, 0],\n",
+ " [0, 235, 255],\n",
+ " [0, 173, 255],\n",
+ " [31, 0, 255],\n",
+ " [11, 200, 200],\n",
+ " [255, 82, 0],\n",
+ " [0, 255, 245],\n",
+ " [0, 61, 255],\n",
+ " [0, 255, 112],\n",
+ " [0, 255, 133],\n",
+ " [255, 0, 0],\n",
+ " [255, 163, 0],\n",
+ " [255, 102, 0],\n",
+ " [194, 255, 0],\n",
+ " [0, 143, 255],\n",
+ " [51, 255, 0],\n",
+ " [0, 82, 255],\n",
+ " [0, 255, 41],\n",
+ " [0, 255, 173],\n",
+ " [10, 0, 255],\n",
+ " [173, 255, 0],\n",
+ " [0, 255, 153],\n",
+ " [255, 92, 0],\n",
+ " [255, 0, 255],\n",
+ " [255, 0, 245],\n",
+ " [255, 0, 102],\n",
+ " [255, 173, 0],\n",
+ " [255, 0, 20],\n",
+ " [255, 184, 184],\n",
+ " [0, 31, 255],\n",
+ " [0, 255, 61],\n",
+ " [0, 71, 255],\n",
+ " [255, 0, 204],\n",
+ " [0, 255, 194],\n",
+ " [0, 255, 82],\n",
+ " [0, 10, 255],\n",
+ " [0, 112, 255],\n",
+ " [51, 0, 255],\n",
+ " [0, 194, 255],\n",
+ " [0, 122, 255],\n",
+ " [0, 255, 163],\n",
+ " [255, 153, 0],\n",
+ " [0, 255, 10],\n",
+ " [255, 112, 0],\n",
+ " [143, 255, 0],\n",
+ " [82, 0, 255],\n",
+ " [163, 255, 0],\n",
+ " [255, 235, 0],\n",
+ " [8, 184, 170],\n",
+ " [133, 0, 255],\n",
+ " [0, 255, 92],\n",
+ " [184, 0, 255],\n",
+ " [255, 0, 31],\n",
+ " [0, 184, 255],\n",
+ " [0, 214, 255],\n",
+ " [255, 0, 112],\n",
+ " [92, 255, 0],\n",
+ " [0, 224, 255],\n",
+ " [112, 224, 255],\n",
+ " [70, 184, 160],\n",
+ " [163, 0, 255],\n",
+ " [153, 0, 255],\n",
+ " [71, 255, 0],\n",
+ " [255, 0, 163],\n",
+ " [255, 204, 0],\n",
+ " [255, 0, 143],\n",
+ " [0, 255, 235],\n",
+ " [133, 255, 0],\n",
+ " [255, 0, 235],\n",
+ " [245, 0, 255],\n",
+ " [255, 0, 122],\n",
+ " [255, 245, 0],\n",
+ " [10, 190, 212],\n",
+ " [214, 255, 0],\n",
+ " [0, 204, 255],\n",
+ " [20, 0, 255],\n",
+ " [255, 255, 0],\n",
+ " [0, 153, 255],\n",
+ " [0, 41, 255],\n",
+ " [0, 255, 204],\n",
+ " [41, 0, 255],\n",
+ " [41, 255, 0],\n",
+ " [173, 0, 255],\n",
+ " [0, 245, 255],\n",
+ " [71, 0, 255],\n",
+ " [122, 0, 255],\n",
+ " [0, 255, 184],\n",
+ " [0, 92, 255],\n",
+ " [184, 255, 0],\n",
+ " [0, 133, 255],\n",
+ " [255, 214, 0],\n",
+ " [25, 194, 194],\n",
+ " [102, 255, 0],\n",
+ " [92, 0, 255],\n",
+ " ]\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 595
+ },
+ "id": "3KJFvgENBih0",
+ "outputId": "63d42e4f-3867-4d33-8ac0-83bebf8819ca"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "color_seg = np.zeros((pred_seg.shape[0], pred_seg.shape[1], 3), dtype=np.uint8)\n",
+ "palette = np.array(ade_palette())\n",
+ "\n",
+ "for label, color in enumerate(palette):\n",
+ " color_seg[pred_seg == label, :] = color\n",
+ "color_seg = color_seg[..., ::-1] # convert to BGR\n",
+ "\n",
+ "img = np.array(image) * 0.5 + color_seg * 0.5 # plot the image with the segmentation map\n",
+ "img = img.astype(np.uint8)\n",
+ "\n",
+ "plt.figure(figsize=(15, 10))\n",
+ "plt.imshow(img)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "q1aGuHYFLP7i"
+ },
+ "source": [
+ "The results are definitely not as expected and as mentioned above, this example is not meant to provide a state-of-the-art model. It exists to familiarize you with the end-to-end workflow. \n",
+ "\n",
+ "On the other hand, if you perform full fine-tuning on the same setup (same model variant, same dataset, same training schedule, etc.), the results would not have been any different. This is a crucial aspect of parameter-efficient fine-tuning -- to be able to match up to the results of the full fine-tuning but with a fraction of total trainable parameters. \n",
+ "\n",
+ "Here are some things that you can try to get better results:\n",
+ "\n",
+ "* Increase the number of training samples. \n",
+ "* Try a larger SegFormer model variant (know about the available model variants [here](https://huggingface.co/models?search=segformer)). \n",
+ "* Try different values for the arguments available in `LoraConfig`. \n",
+ "* Tune the learning rate and batch size. "
+ ]
+ }
+ ],
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "machine_shape": "hm",
+ "provenance": []
+ },
+ "gpuClass": "premium",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.11.13"
+ },
+ "widgets": {
+ "application/vnd.jupyter.widget-state+json": {
+ "0dcc5a2866a349e0843673bef499dc66": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "HTMLModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "HTMLModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "HTMLView",
+ "description": "",
+ "description_tooltip": null,
+ "layout": "IPY_MODEL_24fde588dc1a49a397e379cda320ed71",
+ "placeholder": "",
+ "style": "IPY_MODEL_9746875e74b845daab06619393b4d46b",
+ "value": "\nPro Tip: If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. "
+ }
+ },
+ "14ac809ba0bc4cd5bcd51f83105947b0": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "21bf954f54db41e6ba78f76195721614": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "24fde588dc1a49a397e379cda320ed71": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "3f69c7b15e5e48039777e4b6b1a51f53": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "42a7b8268d8945b5bbe9d3f20bc8840c": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "554b55f29a5e4d5a81608d912d3635e8": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "DescriptionStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "description_width": ""
+ }
+ },
+ "5bcfe3da0ffb41ccbb9404ac35ae8945": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "DescriptionStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "description_width": ""
+ }
+ },
+ "6c6d19cd893e4d82bae9972fa10c6d74": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "PasswordModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "PasswordModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "PasswordView",
+ "continuous_update": true,
+ "description": "Token:",
+ "description_tooltip": null,
+ "disabled": false,
+ "layout": "IPY_MODEL_42a7b8268d8945b5bbe9d3f20bc8840c",
+ "placeholder": "",
+ "style": "IPY_MODEL_554b55f29a5e4d5a81608d912d3635e8",
+ "value": ""
+ }
+ },
+ "6c88a55a635b4c9f946a1aa838d69f20": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "HTMLModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "HTMLModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "HTMLView",
+ "description": "",
+ "description_tooltip": null,
+ "layout": "IPY_MODEL_14ac809ba0bc4cd5bcd51f83105947b0",
+ "placeholder": "",
+ "style": "IPY_MODEL_e7393e78f41b496495982490b72ef2a3",
+ "value": "
Copy a token from your Hugging Face\ntokens page and paste it below. Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
"
+ }
+ },
+ "9746875e74b845daab06619393b4d46b": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "DescriptionStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "description_width": ""
+ }
+ },
+ "b7431f99d93b4e9b8c8177ac4a7b4070": {
+ "model_module": "@jupyter-widgets/base",
+ "model_module_version": "1.2.0",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": "center",
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": "flex",
+ "flex": null,
+ "flex_flow": "column",
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": "50%"
+ }
+ },
+ "cb4053f102fc4207a1c9513f81ad6415": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "ButtonModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "ButtonModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "ButtonView",
+ "button_style": "",
+ "description": "Login",
+ "disabled": false,
+ "icon": "",
+ "layout": "IPY_MODEL_21bf954f54db41e6ba78f76195721614",
+ "style": "IPY_MODEL_f83dd354396e4aa3acd214a6fd98efb2",
+ "tooltip": ""
+ }
+ },
+ "e7393e78f41b496495982490b72ef2a3": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "DescriptionStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "description_width": ""
+ }
+ },
+ "f2a722f371904cce80dc1c087b153ad6": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "VBoxModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "VBoxModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "VBoxView",
+ "box_style": "",
+ "children": [
+ "IPY_MODEL_6c88a55a635b4c9f946a1aa838d69f20",
+ "IPY_MODEL_6c6d19cd893e4d82bae9972fa10c6d74",
+ "IPY_MODEL_fc48ee28c2e44f1daa03149c8004c314",
+ "IPY_MODEL_cb4053f102fc4207a1c9513f81ad6415",
+ "IPY_MODEL_0dcc5a2866a349e0843673bef499dc66"
+ ],
+ "layout": "IPY_MODEL_b7431f99d93b4e9b8c8177ac4a7b4070"
+ }
+ },
+ "f83dd354396e4aa3acd214a6fd98efb2": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "ButtonStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "ButtonStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "button_color": null,
+ "font_weight": ""
+ }
+ },
+ "fc48ee28c2e44f1daa03149c8004c314": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_module_version": "1.5.0",
+ "model_name": "CheckboxModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "CheckboxModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "CheckboxView",
+ "description": "Add token as git credential?",
+ "description_tooltip": null,
+ "disabled": false,
+ "indent": true,
+ "layout": "IPY_MODEL_3f69c7b15e5e48039777e4b6b1a51f53",
+ "style": "IPY_MODEL_5bcfe3da0ffb41ccbb9404ac35ae8945",
+ "value": true
+ }
+ }
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sequence_classification/C3A.ipynb b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sequence_classification/C3A.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..dbd8282a76cb3e4655d63b2e4411c4c0bd3dd3dc
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sequence_classification/C3A.ipynb
@@ -0,0 +1,512 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "d36e1e93-ae93-4a4e-93c6-68fd868d2882",
+ "metadata": {},
+ "source": [
+ "# Using C3A for sequence classification"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ddfc0610-55f6-4343-a950-125ccf0f45ac",
+ "metadata": {},
+ "source": [
+ "In this example, we fine-tune Roberta (base) on a sequence classification task using C3A."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "45addd81-d4f3-4dfd-960d-3920d347f0a6",
+ "metadata": {},
+ "source": [
+ "## Imports"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a9935ae2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# To run this notebook, please run `pip install evaluate` to install additional dependencies not covered by PEFT.\n",
+ "import torch\n",
+ "from torch.optim import AdamW\n",
+ "from torch.utils.data import DataLoader\n",
+ "from peft import (\n",
+ " get_peft_model,\n",
+ " C3AConfig,\n",
+ " PeftType,\n",
+ ")\n",
+ "from peft.utils import infer_device\n",
+ "\n",
+ "import evaluate\n",
+ "from datasets import load_dataset\n",
+ "from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed, AutoConfig\n",
+ "from tqdm import tqdm"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "62c959bf-7cc2-49e0-b97e-4c10ec3b9bf3",
+ "metadata": {},
+ "source": [
+ "## Parameters"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e3b13308",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "batch_size = 32\n",
+ "model_name_or_path = \"roberta-base\"\n",
+ "task = \"mrpc\"\n",
+ "peft_type = PeftType.C3A\n",
+ "device = infer_device()\n",
+ "num_epochs = 5 # for better results, increase this number\n",
+ "block_size = 768 # for better results, increase this number\n",
+ "max_length = 512\n",
+ "torch.manual_seed(0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0526f571",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "peft_config = C3AConfig(\n",
+ " task_type=\"SEQ_CLS\", \n",
+ " block_size=block_size,\n",
+ " target_modules=[\"query\", \"value\"],\n",
+ ")\n",
+ "head_lr = 4e-6 # the learning rate for the classification head for NLU tasks\n",
+ "ft_lr = 3e-1 # the learning rate for C3A parameters, a much larger LR than that is usually used, at least 1e-1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c075c5d2-a457-4f37-a7f1-94fd0d277972",
+ "metadata": {},
+ "source": [
+ "## Loading data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "7bb52cb4-d1c3-4b04-8bf0-f39ca88af139",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n",
+ " padding_side = \"left\"\n",
+ "else:\n",
+ " padding_side = \"right\"\n",
+ "\n",
+ "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n",
+ "if getattr(tokenizer, \"pad_token_id\") is None:\n",
+ " tokenizer.pad_token_id = tokenizer.eos_token_id"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e69c5e1f-d27b-4264-a41e-fc9b99d025e6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "datasets = load_dataset(\"glue\", task)\n",
+ "metric = evaluate.load(\"glue\", task)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "0209f778-c93b-40eb-a4e0-24c25db03980",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def tokenize_function(examples):\n",
+ " # max_length=None => use the model max length (it's actually the default)\n",
+ " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=max_length)\n",
+ " return outputs\n",
+ "\n",
+ "\n",
+ "tokenized_datasets = datasets.map(\n",
+ " tokenize_function,\n",
+ " batched=True,\n",
+ " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+ ")\n",
+ "\n",
+ "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+ "# transformers library\n",
+ "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "7453954e-982c-46f0-b09c-589776e6d6cb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def collate_fn(examples):\n",
+ " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+ "\n",
+ "\n",
+ "# Instantiate dataloaders.\n",
+ "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+ "eval_dataloader = DataLoader(\n",
+ " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f3b9b2e8-f415-4d0f-9fb4-436f1a3585ea",
+ "metadata": {},
+ "source": [
+ "## Preparing the C3A model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "2ed5ac74",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
+ "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "trainable params: 610,562 || all params: 125,257,732 || trainable%: 0.4874\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True, max_length=None)\n",
+ "model = get_peft_model(model, peft_config)\n",
+ "model.print_trainable_parameters()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "0d2d0381",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "head_param = list(map(id, model.classifier.parameters()))\n",
+ "\n",
+ "others_param = filter(lambda p: id(p) not in head_param, model.parameters()) \n",
+ "\n",
+ "optimizer = AdamW([\n",
+ " {\"params\": model.classifier.parameters(), \"lr\": head_lr},\n",
+ " {\"params\": others_param, \"lr\": ft_lr}\n",
+ "],weight_decay=0.)\n",
+ "\n",
+ "\n",
+ "# Instantiate scheduler\n",
+ "lr_scheduler = get_linear_schedule_with_warmup(\n",
+ " optimizer=optimizer,\n",
+ " num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n",
+ " num_training_steps=(len(train_dataloader) * num_epochs),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c0dd5aa8-977b-4ac0-8b96-884b17bcdd00",
+ "metadata": {},
+ "source": [
+ "## Training"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "fa0e73be",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ " 0%| | 0/115 [00:00"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "batch_size = 32\n",
+ "model_name_or_path = \"roberta-base\"\n",
+ "task = \"mrpc\"\n",
+ "peft_type = PeftType.FOURIERFT\n",
+ "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+ "num_epochs = 5 # for better results, increase this number\n",
+ "n_frequency = 1000 # for better results, increase this number\n",
+ "scaling = 150.0\n",
+ "max_length = 512\n",
+ "torch.manual_seed(0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "0526f571",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "peft_config = FourierFTConfig(\n",
+ " task_type=\"SEQ_CLS\", \n",
+ " n_frequency=n_frequency,\n",
+ " target_modules=[\"query\", \"value\"],\n",
+ " scaling = scaling,\n",
+ ")\n",
+ "head_lr = 6e-3 # the learning rate for the classification head for NLU tasks\n",
+ "fft_lr = 6e-2 # the learning rate for the parameters other than the classification head (q,v in this case)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c075c5d2-a457-4f37-a7f1-94fd0d277972",
+ "metadata": {},
+ "source": [
+ "## Loading data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "7bb52cb4-d1c3-4b04-8bf0-f39ca88af139",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n",
+ " padding_side = \"left\"\n",
+ "else:\n",
+ " padding_side = \"right\"\n",
+ "\n",
+ "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n",
+ "if getattr(tokenizer, \"pad_token_id\") is None:\n",
+ " tokenizer.pad_token_id = tokenizer.eos_token_id"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e69c5e1f-d27b-4264-a41e-fc9b99d025e6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "datasets = load_dataset(\"glue\", task)\n",
+ "metric = evaluate.load(\"glue\", task)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "0209f778-c93b-40eb-a4e0-24c25db03980",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def tokenize_function(examples):\n",
+ " # max_length=None => use the model max length (it's actually the default)\n",
+ " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=max_length)\n",
+ " return outputs\n",
+ "\n",
+ "\n",
+ "tokenized_datasets = datasets.map(\n",
+ " tokenize_function,\n",
+ " batched=True,\n",
+ " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+ ")\n",
+ "\n",
+ "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+ "# transformers library\n",
+ "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "7453954e-982c-46f0-b09c-589776e6d6cb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def collate_fn(examples):\n",
+ " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+ "\n",
+ "\n",
+ "# Instantiate dataloaders.\n",
+ "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+ "eval_dataloader = DataLoader(\n",
+ " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f3b9b2e8-f415-4d0f-9fb4-436f1a3585ea",
+ "metadata": {},
+ "source": [
+ "## Preparing the FourierFT model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "2ed5ac74",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
+ "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "trainable params: 616,130 || all params: 125,263,300 || trainable%: 0.4919\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True, max_length=None)\n",
+ "model = get_peft_model(model, peft_config)\n",
+ "model.print_trainable_parameters()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "0d2d0381",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "head_param = list(map(id, model.classifier.parameters()))\n",
+ "\n",
+ "others_param = filter(lambda p: id(p) not in head_param, model.parameters()) \n",
+ "\n",
+ "optimizer = AdamW([\n",
+ " {\"params\": model.classifier.parameters(), \"lr\": head_lr},\n",
+ " {\"params\": others_param, \"lr\": fft_lr}\n",
+ "],weight_decay=0.)\n",
+ "\n",
+ "\n",
+ "# Instantiate scheduler\n",
+ "lr_scheduler = get_linear_schedule_with_warmup(\n",
+ " optimizer=optimizer,\n",
+ " num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n",
+ " num_training_steps=(len(train_dataloader) * num_epochs),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c0dd5aa8-977b-4ac0-8b96-884b17bcdd00",
+ "metadata": {},
+ "source": [
+ "## Training"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "fa0e73be",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ " 0%| | 0/115 [00:00 use the model max length (it's actually the default)\n",
+ " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n",
+ " return outputs\n",
+ "\n",
+ "\n",
+ "tokenized_datasets = datasets.map(\n",
+ " tokenize_function,\n",
+ " batched=True,\n",
+ " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+ ")\n",
+ "\n",
+ "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+ "# transformers library\n",
+ "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")\n",
+ "\n",
+ "\n",
+ "def collate_fn(examples):\n",
+ " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+ "\n",
+ "\n",
+ "# Instantiate dataloaders.\n",
+ "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+ "eval_dataloader = DataLoader(\n",
+ " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+ ")\n",
+ "test_dataloader = DataLoader(tokenized_datasets[\"test\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "2ed5ac74",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000,
+ "referenced_widgets": [
+ "0cecb897c86c4892b94a1990ab08a926",
+ "b8af0294819e4280ad41fa1c11006adf",
+ "c7530d63b2f745e799713284abacbd2c",
+ "12a1e302a69543c5bc0e0a66be008ca0",
+ "9c372e9e9b20433faed8530ca0f4424c",
+ "b07f26a21325493cac19113f1aa1ee96",
+ "fbdf6c544fb54294903524a69384e773",
+ "6c6f2223243b4a7485aef7fbbfe07668",
+ "a93509d61ac94628a74bc0f98c0eec06",
+ "3a8de0eb7db44647a734590b6b351b44",
+ "64d8affd2e854a1c9043fec7ca8a2796"
+ ]
+ },
+ "id": "2ed5ac74",
+ "outputId": "18ea15ac-ed8d-4d80-b166-706681ee49ab"
+ },
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "0cecb897c86c4892b94a1990ab08a926",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Downloading model.safetensors: 0%| | 0.00/1.42G [00:00 use the model max length (it's actually the default)\n",
+ " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n",
+ " return outputs"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "cf5ef289-f42f-4582-bd5e-9852ad8beff2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tokenized_datasets = datasets.map(\n",
+ " tokenize_function,\n",
+ " batched=True,\n",
+ " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+ ")\n",
+ "\n",
+ "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+ "# transformers library\n",
+ "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "739b3655-9db0-48bc-8542-308c6d5e0b8b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def collate_fn(examples):\n",
+ " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "0288f311-8475-4a0e-99af-e4b909d10e01",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Instantiate dataloaders.\n",
+ "train_dataloader = DataLoader(\n",
+ " tokenized_datasets[\"train\"],\n",
+ " shuffle=True,\n",
+ " collate_fn=collate_fn,\n",
+ " batch_size=batch_size,\n",
+ ")\n",
+ "eval_dataloader = DataLoader(\n",
+ " tokenized_datasets[\"validation\"],\n",
+ " shuffle=False,\n",
+ " collate_fn=collate_fn,\n",
+ " batch_size=batch_size,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fcaf6f9e-c9d1-445a-9f08-18ef462f67ce",
+ "metadata": {},
+ "source": [
+ "## Model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "e5dfff56-ea80-4561-aeaf-43216bbb9af7",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "2ac42f98e60d412496fe77ed7eb5c6df",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Loading checkpoint shards: 0%| | 0/3 [00:00, weight=AffineQuantizedTensor(shape=torch.Size([2048, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n",
+ " (lora_dropout): ModuleDict(\n",
+ " (default): Dropout(p=0.1, inplace=False)\n",
+ " )\n",
+ " (lora_A): ModuleDict(\n",
+ " (default): Linear(in_features=2304, out_features=16, bias=False)\n",
+ " )\n",
+ " (lora_B): ModuleDict(\n",
+ " (default): Linear(in_features=16, out_features=2048, bias=False)\n",
+ " )\n",
+ " (lora_embedding_A): ParameterDict()\n",
+ " (lora_embedding_B): ParameterDict()\n",
+ " (lora_magnitude_vector): ModuleDict()\n",
+ " )\n",
+ " (k_proj): Linear(in_features=2304, out_features=1024, weight=LinearActivationQuantizedTensor(activation=, weight=AffineQuantizedTensor(shape=torch.Size([1024, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n",
+ " (v_proj): lora.TorchaoLoraLinear(\n",
+ " (base_layer): Linear(in_features=2304, out_features=1024, weight=LinearActivationQuantizedTensor(activation=, weight=AffineQuantizedTensor(shape=torch.Size([1024, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n",
+ " (lora_dropout): ModuleDict(\n",
+ " (default): Dropout(p=0.1, inplace=False)\n",
+ " )\n",
+ " (lora_A): ModuleDict(\n",
+ " (default): Linear(in_features=2304, out_features=16, bias=False)\n",
+ " )\n",
+ " (lora_B): ModuleDict(\n",
+ " (default): Linear(in_features=16, out_features=1024, bias=False)\n",
+ " )\n",
+ " (lora_embedding_A): ParameterDict()\n",
+ " (lora_embedding_B): ParameterDict()\n",
+ " (lora_magnitude_vector): ModuleDict()\n",
+ " )\n",
+ " (o_proj): Linear(in_features=2048, out_features=2304, weight=LinearActivationQuantizedTensor(activation=, weight=AffineQuantizedTensor(shape=torch.Size([2304, 2048]), block_size=(1, 2048), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n",
+ " (rotary_emb): Gemma2RotaryEmbedding()\n",
+ " )\n",
+ " (mlp): Gemma2MLP(\n",
+ " (gate_proj): Linear(in_features=2304, out_features=9216, weight=LinearActivationQuantizedTensor(activation=, weight=AffineQuantizedTensor(shape=torch.Size([9216, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n",
+ " (up_proj): Linear(in_features=2304, out_features=9216, weight=LinearActivationQuantizedTensor(activation=, weight=AffineQuantizedTensor(shape=torch.Size([9216, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n",
+ " (down_proj): Linear(in_features=9216, out_features=2304, weight=LinearActivationQuantizedTensor(activation=, weight=AffineQuantizedTensor(shape=torch.Size([2304, 9216]), block_size=(1, 9216), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n",
+ " (act_fn): PytorchGELUTanh()\n",
+ " )\n",
+ " (input_layernorm): Gemma2RMSNorm((2304,), eps=1e-06)\n",
+ " (post_attention_layernorm): Gemma2RMSNorm((2304,), eps=1e-06)\n",
+ " (pre_feedforward_layernorm): Gemma2RMSNorm((2304,), eps=1e-06)\n",
+ " (post_feedforward_layernorm): Gemma2RMSNorm((2304,), eps=1e-06)\n",
+ " )\n",
+ " )\n",
+ " (norm): Gemma2RMSNorm((2304,), eps=1e-06)\n",
+ " )\n",
+ " (score): ModulesToSaveWrapper(\n",
+ " (original_module): Linear(in_features=2304, out_features=2, bias=False)\n",
+ " (modules_to_save): ModuleDict(\n",
+ " (default): Linear(in_features=2304, out_features=2, bias=False)\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ ")"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "model.config.use_cache = False\n",
+ "model.to(device)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "fa0e73be",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ " 0%| | 0/230 [00:00 use the model max length (it's actually the default)\n",
+ " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n",
+ " return outputs"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "cf5ef289-f42f-4582-bd5e-9852ad8beff2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tokenized_datasets = datasets.map(\n",
+ " tokenize_function,\n",
+ " batched=True,\n",
+ " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+ ")\n",
+ "\n",
+ "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+ "# transformers library\n",
+ "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "739b3655-9db0-48bc-8542-308c6d5e0b8b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def collate_fn(examples):\n",
+ " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "0288f311-8475-4a0e-99af-e4b909d10e01",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Instantiate dataloaders.\n",
+ "train_dataloader = DataLoader(\n",
+ " tokenized_datasets[\"train\"],\n",
+ " shuffle=True,\n",
+ " collate_fn=collate_fn,\n",
+ " batch_size=batch_size,\n",
+ ")\n",
+ "eval_dataloader = DataLoader(\n",
+ " tokenized_datasets[\"validation\"],\n",
+ " shuffle=False,\n",
+ " collate_fn=collate_fn,\n",
+ " batch_size=batch_size,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fcaf6f9e-c9d1-445a-9f08-18ef462f67ce",
+ "metadata": {},
+ "source": [
+ "## Model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "e5dfff56-ea80-4561-aeaf-43216bbb9af7",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "512d9dc10a4d4ecc88b9440575b0973a",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Loading checkpoint shards: 0%| | 0/3 [00:00 use the model max length (it's actually the default)\n",
+ " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n",
+ " return outputs\n",
+ "\n",
+ "\n",
+ "tokenized_datasets = datasets.map(\n",
+ " tokenize_function,\n",
+ " batched=True,\n",
+ " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+ ")\n",
+ "\n",
+ "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+ "# transformers library\n",
+ "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")\n",
+ "\n",
+ "\n",
+ "def collate_fn(examples):\n",
+ " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+ "\n",
+ "\n",
+ "# Instantiate dataloaders.\n",
+ "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+ "eval_dataloader = DataLoader(\n",
+ " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2ed5ac74",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True)\n",
+ "model = get_peft_model(model, peft_config)\n",
+ "model.print_trainable_parameters()\n",
+ "model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "0d2d0381",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "optimizer = AdamW(params=model.parameters(), lr=lr)\n",
+ "\n",
+ "# Instantiate scheduler\n",
+ "lr_scheduler = get_linear_schedule_with_warmup(\n",
+ " optimizer=optimizer,\n",
+ " num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n",
+ " num_training_steps=(len(train_dataloader) * num_epochs),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "fa0e73be",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ " 0%| | 0/115 [00:00 use the model max length (it's actually the default)\n",
+ " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n",
+ " return outputs\n",
+ "\n",
+ "\n",
+ "tokenized_datasets = datasets.map(\n",
+ " tokenize_function,\n",
+ " batched=True,\n",
+ " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+ ")\n",
+ "\n",
+ "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+ "# transformers library\n",
+ "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")\n",
+ "\n",
+ "\n",
+ "def collate_fn(examples):\n",
+ " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+ "\n",
+ "\n",
+ "# Instantiate dataloaders.\n",
+ "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+ "eval_dataloader = DataLoader(\n",
+ " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f6bc8144",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True)\n",
+ "model = get_peft_model(model, peft_config)\n",
+ "model.print_trainable_parameters()\n",
+ "model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "af41c571",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "optimizer = AdamW(params=model.parameters(), lr=lr)\n",
+ "\n",
+ "# Instantiate scheduler\n",
+ "lr_scheduler = get_linear_schedule_with_warmup(\n",
+ " optimizer=optimizer,\n",
+ " num_warmup_steps=0, # 0.06*(len(train_dataloader) * num_epochs),\n",
+ " num_training_steps=(len(train_dataloader) * num_epochs),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "90993c93",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ " 0%| | 0/115 [00:00 use the model max length (it's actually the default)\n",
+ " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n",
+ " return outputs\n",
+ "\n",
+ "\n",
+ "tokenized_datasets = datasets.map(\n",
+ " tokenize_function,\n",
+ " batched=True,\n",
+ " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+ ")\n",
+ "\n",
+ "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+ "# transformers library\n",
+ "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")\n",
+ "\n",
+ "\n",
+ "def collate_fn(examples):\n",
+ " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+ "\n",
+ "\n",
+ "# Instantiate dataloaders.\n",
+ "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+ "eval_dataloader = DataLoader(\n",
+ " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a3c15af0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True)\n",
+ "model = get_peft_model(model, peft_config)\n",
+ "model.print_trainable_parameters()\n",
+ "model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "6d3c5edb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "optimizer = AdamW(params=model.parameters(), lr=lr)\n",
+ "\n",
+ "# Instantiate scheduler\n",
+ "lr_scheduler = get_linear_schedule_with_warmup(\n",
+ " optimizer=optimizer,\n",
+ " num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n",
+ " num_training_steps=(len(train_dataloader) * num_epochs),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "4d279225",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ " 0%| | 0/115 [00:00"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "batch_size = 32\n",
+ "model_name_or_path = \"roberta-large\"\n",
+ "task = \"mrpc\"\n",
+ "peft_type = PeftType.VBLORA\n",
+ "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+ "num_epochs = 20\n",
+ "rank = 4\n",
+ "max_length = 128\n",
+ "num_vectors = 90\n",
+ "vector_length = 256\n",
+ "torch.manual_seed(0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "0526f571",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "peft_config = VBLoRAConfig(\n",
+ " task_type=\"SEQ_CLS\", \n",
+ " r=rank,\n",
+ " topk=2,\n",
+ " target_modules=['key', 'value', 'query', 'output.dense', 'intermediate.dense'],\n",
+ " num_vectors=num_vectors,\n",
+ " vector_length=vector_length,\n",
+ " save_only_topk_weights=True, # Set to True to reduce storage space. Note that the saved parameters cannot be used to resume training from checkpoints.\n",
+ " vblora_dropout=0.,\n",
+ ")\n",
+ "head_lr = 4e-3\n",
+ "vector_bank_lr = 1e-3\n",
+ "logits_lr = 1e-2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c075c5d2-a457-4f37-a7f1-94fd0d277972",
+ "metadata": {},
+ "source": [
+ "## Loading data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "7bb52cb4-d1c3-4b04-8bf0-f39ca88af139",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n",
+ " padding_side = \"left\"\n",
+ "else:\n",
+ " padding_side = \"right\"\n",
+ "\n",
+ "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n",
+ "if getattr(tokenizer, \"pad_token_id\") is None:\n",
+ " tokenizer.pad_token_id = tokenizer.eos_token_id"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e69c5e1f-d27b-4264-a41e-fc9b99d025e6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "datasets = load_dataset(\"glue\", task)\n",
+ "metric = evaluate.load(\"glue\", task)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "0209f778-c93b-40eb-a4e0-24c25db03980",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def tokenize_function(examples):\n",
+ " # max_length=None => use the model max length (it's actually the default)\n",
+ " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=max_length)\n",
+ " return outputs\n",
+ "\n",
+ "\n",
+ "tokenized_datasets = datasets.map(\n",
+ " tokenize_function,\n",
+ " batched=True,\n",
+ " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+ ")\n",
+ "\n",
+ "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+ "# transformers library\n",
+ "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "7453954e-982c-46f0-b09c-589776e6d6cb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def collate_fn(examples):\n",
+ " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+ "\n",
+ "\n",
+ "# Instantiate dataloaders.\n",
+ "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+ "eval_dataloader = DataLoader(\n",
+ " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f3b9b2e8-f415-4d0f-9fb4-436f1a3585ea",
+ "metadata": {},
+ "source": [
+ "## Preparing the VB-LoRA model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "2ed5ac74",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-large and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
+ "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "trainable params: 1,696,770 || all params: 357,058,564 || trainable%: 0.4752\n",
+ "VB-LoRA params to-be-saved (float32-equivalent): 33,408 || total params to-be-saved: 1,085,058\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True, max_length=None)\n",
+ "model = get_peft_model(model, peft_config)\n",
+ "model.print_trainable_parameters()\n",
+ "model.print_savable_parameters()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "0d2d0381",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\n",
+ "from transformers.pytorch_utils import ALL_LAYERNORM_LAYERS\n",
+ "from transformers.trainer_pt_utils import get_parameter_names\n",
+ "\n",
+ "decay_parameters = get_parameter_names(model, ALL_LAYERNORM_LAYERS)\n",
+ "decay_parameters = [name for name in decay_parameters if \"bias\" not in name]\n",
+ "vector_bank_parameters = [name for name, _ in model.named_parameters() if \"vector_bank\" in name]\n",
+ "logits_parameters = [name for name, _ in model.named_parameters() if \"logits\" in name ]\n",
+ "\n",
+ "optimizer_grouped_parameters = [\n",
+ " {\n",
+ " \"params\": [p for n, p in model.named_parameters() if n in decay_parameters and \\\n",
+ " n not in logits_parameters and n not in vector_bank_parameters],\n",
+ " \"weight_decay\": 0.1,\n",
+ " \"lr\": head_lr,\n",
+ " },\n",
+ " {\n",
+ " \"params\": [p for n, p in model.named_parameters() if n not in decay_parameters and \\\n",
+ " n not in logits_parameters and n not in vector_bank_parameters],\n",
+ " \"weight_decay\": 0.0,\n",
+ " \"lr\": head_lr,\n",
+ " },\n",
+ " {\n",
+ " \"params\": [p for n, p in model.named_parameters() if n in vector_bank_parameters],\n",
+ " \"lr\": vector_bank_lr,\n",
+ " \"weight_decay\": 0.0,\n",
+ " },\n",
+ " {\n",
+ " \"params\": [p for n, p in model.named_parameters() if n in logits_parameters],\n",
+ " \"lr\": logits_lr,\n",
+ " \"weight_decay\": 0.0,\n",
+ " },\n",
+ "]\n",
+ "\n",
+ "optimizer = AdamW(optimizer_grouped_parameters)\n",
+ "lr_scheduler = get_linear_schedule_with_warmup(\n",
+ " optimizer=optimizer,\n",
+ " num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n",
+ " num_training_steps=(len(train_dataloader) * num_epochs),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c0dd5aa8-977b-4ac0-8b96-884b17bcdd00",
+ "metadata": {},
+ "source": [
+ "## Training"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "fa0e73be",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ " 0%| | 0/115 [00:00"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "batch_size = 128\n",
+ "model_name_or_path = \"roberta-base\"\n",
+ "task = \"mrpc\"\n",
+ "peft_type = PeftType.VERA\n",
+ "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+ "num_epochs = 5 # for best results, increase this number\n",
+ "rank = 8 # for best results, increase this number\n",
+ "max_length = 128\n",
+ "torch.manual_seed(0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "0526f571",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "peft_config = VeraConfig(\n",
+ " task_type=\"SEQ_CLS\", \n",
+ " r=rank,\n",
+ " d_initial=0.1,\n",
+ " target_modules=[\"query\", \"value\", \"intermediate.dense\"],\n",
+ " save_projection=True,\n",
+ ")\n",
+ "head_lr = 1e-2\n",
+ "vera_lr = 2e-2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c075c5d2-a457-4f37-a7f1-94fd0d277972",
+ "metadata": {},
+ "source": [
+ "## Loading data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "7bb52cb4-d1c3-4b04-8bf0-f39ca88af139",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n",
+ " padding_side = \"left\"\n",
+ "else:\n",
+ " padding_side = \"right\"\n",
+ "\n",
+ "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n",
+ "if getattr(tokenizer, \"pad_token_id\") is None:\n",
+ " tokenizer.pad_token_id = tokenizer.eos_token_id"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e69c5e1f-d27b-4264-a41e-fc9b99d025e6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "datasets = load_dataset(\"glue\", task)\n",
+ "metric = evaluate.load(\"glue\", task)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "0209f778-c93b-40eb-a4e0-24c25db03980",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def tokenize_function(examples):\n",
+ " # max_length=None => use the model max length (it's actually the default)\n",
+ " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=max_length)\n",
+ " return outputs\n",
+ "\n",
+ "\n",
+ "tokenized_datasets = datasets.map(\n",
+ " tokenize_function,\n",
+ " batched=True,\n",
+ " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+ ")\n",
+ "\n",
+ "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+ "# transformers library\n",
+ "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "7453954e-982c-46f0-b09c-589776e6d6cb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def collate_fn(examples):\n",
+ " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+ "\n",
+ "\n",
+ "# Instantiate dataloaders.\n",
+ "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+ "eval_dataloader = DataLoader(\n",
+ " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f3b9b2e8-f415-4d0f-9fb4-436f1a3585ea",
+ "metadata": {},
+ "source": [
+ "## Preparing the VeRA model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "2ed5ac74",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
+ "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "trainable params: 647,714 || all params: 125,294,884 || trainable%: 0.5170\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True, max_length=None)\n",
+ "model = get_peft_model(model, peft_config)\n",
+ "model.print_trainable_parameters()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "0d2d0381",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "optimizer = AdamW(\n",
+ " [\n",
+ " {\"params\": [p for n, p in model.named_parameters() if \"vera_lambda_\" in n], \"lr\": vera_lr},\n",
+ " {\"params\": [p for n, p in model.named_parameters() if \"classifier\" in n], \"lr\": head_lr},\n",
+ " ]\n",
+ ")\n",
+ "\n",
+ "# Instantiate scheduler\n",
+ "lr_scheduler = get_linear_schedule_with_warmup(\n",
+ " optimizer=optimizer,\n",
+ " num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n",
+ " num_training_steps=(len(train_dataloader) * num_epochs),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c0dd5aa8-977b-4ac0-8b96-884b17bcdd00",
+ "metadata": {},
+ "source": [
+ "## Training"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "fa0e73be",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ " 0%| | 0/29 [00:00 use the model max length (it's actually the default)
+ outputs = tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, max_length=None)
+ return outputs
+
+ def collate_fn(examples):
+ return tokenizer.pad(examples, padding="longest", return_tensors="pt")
+
+ with accelerator.main_process_first():
+ tokenized_datasets = datasets.map(
+ tokenize_function,
+ batched=True,
+ remove_columns=["idx", "sentence1", "sentence2"],
+ )
+
+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
+ # transformers library
+ tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
+
+ # Instantiate dataloaders.
+ train_dataloader = DataLoader(
+ tokenized_datasets["train"], shuffle=True, collate_fn=collate_fn, batch_size=args.per_device_train_batch_size
+ )
+ eval_dataloader = DataLoader(
+ tokenized_datasets["validation"],
+ shuffle=False,
+ collate_fn=collate_fn,
+ batch_size=args.per_device_eval_batch_size,
+ )
+
+ model = AutoModelForSequenceClassification.from_pretrained(args.model_name_or_path)
+ model = get_peft_model(model, peft_config)
+ model.print_trainable_parameters()
+
+ if getattr(accelerator.state, "fsdp_plugin", None) is not None:
+ accelerator.state.fsdp_plugin.auto_wrap_policy = fsdp_auto_wrap_policy(model)
+ model = accelerator.prepare(model)
+
+ optimizer = AdamW(params=model.parameters(), lr=args.learning_rate)
+
+ # Instantiate scheduler
+ lr_scheduler = get_linear_schedule_with_warmup(
+ optimizer=optimizer,
+ num_warmup_steps=args.num_warmup_steps,
+ num_training_steps=(len(train_dataloader) * args.num_train_epochs),
+ )
+
+ if getattr(accelerator.state, "fsdp_plugin", None) is not None:
+ train_dataloader, eval_dataloader, optimizer, lr_scheduler = accelerator.prepare(
+ train_dataloader, eval_dataloader, optimizer, lr_scheduler
+ )
+ else:
+ model, train_dataloader, eval_dataloader, optimizer, lr_scheduler = accelerator.prepare(
+ model, train_dataloader, eval_dataloader, optimizer, lr_scheduler
+ )
+
+ for epoch in range(args.num_train_epochs):
+ model.train()
+ for step, batch in enumerate(tqdm(train_dataloader)):
+ outputs = model(**batch)
+ loss = outputs.loss
+ accelerator.backward(loss)
+ optimizer.step()
+ lr_scheduler.step()
+ optimizer.zero_grad()
+
+ model.eval()
+ samples_seen = 0
+ for step, batch in enumerate(tqdm(eval_dataloader)):
+ with torch.no_grad():
+ outputs = model(**batch)
+ predictions = outputs.logits.argmax(dim=-1)
+ predictions, references = accelerator.gather((predictions, batch["labels"]))
+ # If we are in a multiprocess environment, the last batch has duplicates
+ if accelerator.num_processes > 1:
+ if step == len(eval_dataloader) - 1:
+ predictions = predictions[: len(eval_dataloader.dataset) - samples_seen]
+ references = references[: len(eval_dataloader.dataset) - samples_seen]
+ else:
+ samples_seen += references.shape[0]
+ metric.add_batch(
+ predictions=predictions,
+ references=references,
+ )
+ eval_metric = metric.compute()
+ accelerator.print(f"epoch {epoch}:", eval_metric)
+
+ accelerator.wait_for_everyone()
+ unwrapped_model = accelerator.unwrap_model(model)
+ unwrapped_model.save_pretrained(args.output_dir, state_dict=accelerator.get_state_dict(model))
+ if accelerator.is_main_process:
+ tokenizer.save_pretrained(args.output_dir)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sequence_classification/prefix_tuning.ipynb b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sequence_classification/prefix_tuning.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..bd2fc1fa1b29a795e93662124cfd3412b1c51d66
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sequence_classification/prefix_tuning.ipynb
@@ -0,0 +1,710 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "a825ba6b",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "===================================BUG REPORT===================================\n",
+ "Welcome to bitsandbytes. For bug reports, please submit your error trace to: https://github.com/TimDettmers/bitsandbytes/issues\n",
+ "For effortless bug reporting copy-paste your error into this form: https://docs.google.com/forms/d/e/1FAIpQLScPB8emS3Thkp66nvqwmjTEgxp8Y9ufuWTzFyr9kJ5AoI47dQ/viewform?usp=sf_link\n",
+ "================================================================================\n",
+ "CUDA SETUP: CUDA runtime path found: /home/sourab/miniconda3/envs/ml/lib/libcudart.so\n",
+ "CUDA SETUP: Highest compute capability among GPUs detected: 7.5\n",
+ "CUDA SETUP: Detected CUDA version 117\n",
+ "CUDA SETUP: Loading binary /home/sourab/miniconda3/envs/ml/lib/python3.10/site-packages/bitsandbytes/libbitsandbytes_cuda117.so...\n"
+ ]
+ }
+ ],
+ "source": [
+ "import argparse\n",
+ "import os\n",
+ "\n",
+ "import torch\n",
+ "from torch.optim import AdamW\n",
+ "from torch.utils.data import DataLoader\n",
+ "from peft import (\n",
+ " get_peft_config,\n",
+ " get_peft_model,\n",
+ " get_peft_model_state_dict,\n",
+ " set_peft_model_state_dict,\n",
+ " PeftType,\n",
+ " PrefixTuningConfig,\n",
+ " PromptEncoderConfig,\n",
+ ")\n",
+ "\n",
+ "import evaluate\n",
+ "from datasets import load_dataset\n",
+ "from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed\n",
+ "from tqdm import tqdm"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2bd7cbb2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "batch_size = 32\n",
+ "model_name_or_path = \"roberta-large\"\n",
+ "task = \"mrpc\"\n",
+ "peft_type = PeftType.PREFIX_TUNING\n",
+ "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+ "num_epochs = 20"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "33d9b62e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "peft_config = PrefixTuningConfig(task_type=\"SEQ_CLS\", num_virtual_tokens=20)\n",
+ "lr = 1e-2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "152b6177",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Found cached dataset glue (/home/sourab/.cache/huggingface/datasets/glue/mrpc/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a5a0bfeb5fc42e75c9db75b96da6053ad)\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "be1eddbb9a7d4e6dae32fd026e167f96",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ " 0%| | 0/3 [00:00 use the model max length (it's actually the default)\n",
+ " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n",
+ " return outputs\n",
+ "\n",
+ "\n",
+ "tokenized_datasets = datasets.map(\n",
+ " tokenize_function,\n",
+ " batched=True,\n",
+ " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+ ")\n",
+ "\n",
+ "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+ "# transformers library\n",
+ "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")\n",
+ "\n",
+ "\n",
+ "def collate_fn(examples):\n",
+ " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+ "\n",
+ "\n",
+ "# Instantiate dataloaders.\n",
+ "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+ "eval_dataloader = DataLoader(\n",
+ " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f6bc8144",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True)\n",
+ "model = get_peft_model(model, peft_config)\n",
+ "model.print_trainable_parameters()\n",
+ "model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "af41c571",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "optimizer = AdamW(params=model.parameters(), lr=lr)\n",
+ "\n",
+ "# Instantiate scheduler\n",
+ "lr_scheduler = get_linear_schedule_with_warmup(\n",
+ " optimizer=optimizer,\n",
+ " num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n",
+ " num_training_steps=(len(train_dataloader) * num_epochs),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "90993c93",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ " 0%| | 0/115 [00:00
+
+
+Optimization in Unsloth to speed up QLoRA finetuning while reducing GPU memory usage
+
+## Multi-GPU SFT with QLoRA
+To speed up QLoRA finetuning when you have access to multiple GPUs, look at the launch command at [run_peft_multigpu.sh](https://github.com/huggingface/peft/blob/main/examples/sft/run_peft_multigpu.sh). This example to performs DDP on 8 GPUs.
+
+Note:
+1. At present, `use_reentrant` needs to be `False` when using gradient checkpointing with Multi-GPU QLoRA else it will lead to errors. However, this leads to huge GPU memory consumption.
+
+## Multi-GPU SFT with LoRA and DeepSpeed
+When you have access to multiple GPUs, it would be better to use normal LoRA with DeepSpeed/FSDP. To use LoRA with DeepSpeed, refer to the docs at [PEFT with DeepSpeed](https://huggingface.co/docs/peft/accelerate/deepspeed).
+
+
+## Multi-GPU SFT with LoRA and FSDP
+When you have access to multiple GPUs, it would be better to use normal LoRA with DeepSpeed/FSDP. To use LoRA with FSDP, refer to the docs at [PEFT with FSDP](https://huggingface.co/docs/peft/accelerate/fsdp).
+
+Note: FSDP is currently not compatible with 8bit bitsandbytes quantization.
+
+
+## Multi-GPU SFT with LoRA and FSDP for GPT-QModel:
+As in [Multi-GPU SFT with LoRA and FSDP](https://github.com/huggingface/peft/blob/main/examples/sft/README.md#multi-gpu-sft-with-lora-and-fsdp), we also support other quantization methods like GPT-QModel. You may need to install [GPT-QModel](https://github.com/ModelCloud/GPTQModel) >= v7.0.0 or from source. Here is the launch command for reference: [run_peft_fsdp_gptq.sh]. For the `--model_name_or_path` argument, it is important to pass a model that is already quantized with GPT-QModel, like `"hugging-quants/Meta-Llama-3.1-8B-Instruct-GPTQ-INT4"`.
+
+Note: there is a bug in transformers v4.53.0 for this case, please skip this transformers version.
+
+## Tip
+
+Generally try to upgrade to the latest package versions for best results, especially when it comes to `bitsandbytes`, `accelerate`, `transformers`, `trl`, and `peft`.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/deepspeed_config.yaml b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/deepspeed_config.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..56eef6e48b75727ede1d522b595b5ecde3a205a1
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/deepspeed_config.yaml
@@ -0,0 +1,23 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+deepspeed_config:
+ deepspeed_multinode_launcher: standard
+ gradient_accumulation_steps: 4
+ offload_optimizer_device: none
+ offload_param_device: none
+ zero3_init_flag: true
+ zero3_save_16bit_model: true
+ zero_stage: 3
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 8
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/deepspeed_config_z3_qlora.yaml b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/deepspeed_config_z3_qlora.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..07dddcef7853b963ea64d20d39078893c4e21c33
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/deepspeed_config_z3_qlora.yaml
@@ -0,0 +1,22 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+deepspeed_config:
+ deepspeed_multinode_launcher: standard
+ offload_optimizer_device: none
+ offload_param_device: none
+ zero3_init_flag: true
+ zero3_save_16bit_model: true
+ zero_stage: 3
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 2
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/fsdp_config.yaml b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/fsdp_config.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..7cccb74ca0dfa1a916b5057ceee561271c301ec5
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/fsdp_config.yaml
@@ -0,0 +1,25 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: FSDP
+downcast_bf16: 'no'
+fsdp_config:
+ fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
+ fsdp_backward_prefetch: BACKWARD_PRE
+ fsdp_cpu_ram_efficient_loading: true
+ fsdp_forward_prefetch: false
+ fsdp_offload_params: false
+ fsdp_sharding_strategy: FULL_SHARD
+ fsdp_state_dict_type: SHARDED_STATE_DICT
+ fsdp_sync_module_states: true
+ fsdp_use_orig_params: false
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 8
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/fsdp_config_qlora.yaml b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/fsdp_config_qlora.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..f28a0f1046a735579045655dcdb9d3bf7c6ffdcc
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/fsdp_config_qlora.yaml
@@ -0,0 +1,25 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: FSDP
+downcast_bf16: 'no'
+fsdp_config:
+ fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
+ fsdp_backward_prefetch: BACKWARD_PRE
+ fsdp_cpu_ram_efficient_loading: true
+ fsdp_forward_prefetch: false
+ fsdp_offload_params: true
+ fsdp_sharding_strategy: FULL_SHARD
+ fsdp_state_dict_type: SHARDED_STATE_DICT
+ fsdp_sync_module_states: true
+ fsdp_use_orig_params: false
+machine_rank: 0
+main_training_function: main
+mixed_precision: 'no'
+num_machines: 1
+num_processes: 2
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements.txt b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..752b6976e62f4acff6193804c5422807bc5e8806
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements.txt
@@ -0,0 +1,25 @@
+git+https://github.com/huggingface/transformers
+git+https://github.com/huggingface/accelerate
+git+https://github.com/huggingface/peft
+git+https://github.com/huggingface/trl
+git+https://github.com/huggingface/datatrove.git
+unsloth[conda]@git+https://github.com/unslothai/unsloth.git
+deepspeed
+PyGithub
+flash-attn
+huggingface-hub
+evaluate
+datasets
+bitsandbytes
+einops
+wandb
+tensorboard
+tiktoken
+pandas
+numpy
+scipy
+matplotlib
+sentencepiece
+nltk
+xformers
+hf_transfer
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements_colab.txt b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements_colab.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b8c375dc44bf85305fa53964537f4877210b10bd
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements_colab.txt
@@ -0,0 +1,25 @@
+git+https://github.com/huggingface/transformers
+git+https://github.com/huggingface/accelerate
+git+https://github.com/huggingface/peft
+git+https://github.com/huggingface/trl
+unsloth[colab_ampere] @ git+https://github.com/unslothai/unsloth.git
+datasets
+deepspeed
+PyGithub
+flash-attn
+huggingface-hub
+evaluate
+bitsandbytes
+einops
+wandb
+tensorboard
+tiktoken
+pandas
+numpy
+scipy
+matplotlib
+sentencepiece
+nltk
+xformers
+git+https://github.com/huggingface/datatrove.git
+hf_transfer
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements_xpu.txt b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements_xpu.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9e5918b95180acbdc5789115ba0af71c8adf3aa5
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements_xpu.txt
@@ -0,0 +1,22 @@
+git+https://github.com/huggingface/transformers
+git+https://github.com/huggingface/accelerate
+git+https://github.com/huggingface/peft
+git+https://github.com/huggingface/trl
+git+https://github.com/huggingface/datatrove.git
+deepspeed
+PyGithub
+huggingface-hub
+evaluate
+datasets
+bitsandbytes
+einops
+wandb
+tensorboard
+tiktoken
+pandas
+numpy
+scipy
+matplotlib
+sentencepiece
+nltk
+hf_transfer
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft.sh b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft.sh
new file mode 100644
index 0000000000000000000000000000000000000000..daa29f14f3cddcc829a68248c8055035f9206a5c
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft.sh
@@ -0,0 +1,41 @@
+python train.py \
+--seed 100 \
+--model_name_or_path "mistralai/Mistral-7B-v0.1" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "mistral-sft-lora" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 8 \
+--gradient_checkpointing True \
+--use_reentrant True \
+--dataset_text_field "content" \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--use_flash_attn True
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_deepspeed.sh b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_deepspeed.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8c2bcb13553c0c85c270494377cbcc7d72df9d00
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_deepspeed.sh
@@ -0,0 +1,39 @@
+accelerate launch --config_file "configs/deepspeed_config.yaml" train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "mistral-sft-lora-deepspeed" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 4 \
+--gradient_checkpointing True \
+--use_reentrant False \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization False
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_fsdp.sh b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_fsdp.sh
new file mode 100644
index 0000000000000000000000000000000000000000..82c595d2d6b99a48ad916015f090bcf908e954d5
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_fsdp.sh
@@ -0,0 +1,39 @@
+accelerate launch --config_file "configs/fsdp_config.yaml" train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "mistral-sft-lora-fsdp" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 4 \
+--gradient_checkpointing True \
+--use_reentrant False \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization False
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_fsdp_gptq.sh b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_fsdp_gptq.sh
new file mode 100644
index 0000000000000000000000000000000000000000..9f0939e9c923785c4ad3cd23674c7877fc247488
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_fsdp_gptq.sh
@@ -0,0 +1,36 @@
+accelerate launch --config_file "configs/fsdp_config.yaml" train.py \
+--seed 100 \
+--model_name_or_path "hugging-quants/Meta-Llama-3.1-8B-Instruct-GPTQ-INT4" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "llama3-8B-gptq-sft-lora-fsdp" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 4 \
+--gradient_checkpointing True \
+--use_reentrant False \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "q_proj,k_proj,v_proj,o_proj,up_proj,gate_proj" \
+--use_4bit_quantization False
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_multigpu.sh b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_multigpu.sh
new file mode 100644
index 0000000000000000000000000000000000000000..797df71d6e19b3a6f2bc3a6a92afa2413cfba355
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_multigpu.sh
@@ -0,0 +1,41 @@
+torchrun --nproc_per_node 8 --nnodes 1 train.py \
+--seed 100 \
+--model_name_or_path "mistralai/Mistral-7B-v0.1" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "mistral-sft-lora-multigpu" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 8 \
+--gradient_checkpointing True \
+--use_reentrant False \
+--dataset_text_field "content" \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--use_flash_attn True
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_qlora_deepspeed_stage3.sh b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_qlora_deepspeed_stage3.sh
new file mode 100644
index 0000000000000000000000000000000000000000..9c0fa3a63784f8afb36f610651a00737ab912de1
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_qlora_deepspeed_stage3.sh
@@ -0,0 +1,42 @@
+accelerate launch --config_file "configs/deepspeed_config_z3_qlora.yaml" train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "llama-sft-qlora-dsz3" \
+--per_device_train_batch_size 2 \
+--per_device_eval_batch_size 2 \
+--gradient_accumulation_steps 2 \
+--gradient_checkpointing True \
+--use_reentrant True \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--bnb_4bit_quant_storage_dtype "bfloat16"
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_qlora_fsdp.sh b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_qlora_fsdp.sh
new file mode 100644
index 0000000000000000000000000000000000000000..ca448cf34bfc44fcdabd715078fabbbc48d67782
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_qlora_fsdp.sh
@@ -0,0 +1,42 @@
+accelerate launch --config_file "configs/fsdp_config_qlora.yaml" train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "llama-sft-qlora-fsdp" \
+--per_device_train_batch_size 2 \
+--per_device_eval_batch_size 2 \
+--gradient_accumulation_steps 2 \
+--gradient_checkpointing True \
+--use_reentrant True \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--bnb_4bit_quant_storage_dtype "bfloat16"
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_unsloth_peft.sh b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_unsloth_peft.sh
new file mode 100644
index 0000000000000000000000000000000000000000..608a1d93940fd72583009e204a796f510b7fe12c
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_unsloth_peft.sh
@@ -0,0 +1,42 @@
+python train.py \
+--seed 100 \
+--model_name_or_path "mistralai/Mistral-7B-v0.1" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "mistral-sft-lora-unsloth" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 8 \
+--gradient_checkpointing True \
+--use_reentrant True \
+--dataset_text_field "content" \
+--use_peft_lora True \
+--use_unsloth True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "q_proj,k_proj,v_proj,o_proj,down_proj,up_proj,gate_proj" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--use_flash_attn True
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/train.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/train.py
new file mode 100644
index 0000000000000000000000000000000000000000..921ae9910488caf2ff0c51fdc709494b2a084ab9
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/train.py
@@ -0,0 +1,156 @@
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Optional
+
+from transformers import HfArgumentParser, set_seed
+from trl import SFTConfig, SFTTrainer
+from utils import create_and_prepare_model, create_datasets
+
+
+# Define and parse arguments.
+@dataclass
+class ModelArguments:
+ """
+ Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
+ """
+
+ model_name_or_path: str = field(
+ metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}
+ )
+ chat_template_format: Optional[str] = field(
+ default="none",
+ metadata={
+ "help": "chatml|zephyr|none. Pass `none` if the dataset is already formatted with the chat template."
+ },
+ )
+ lora_alpha: Optional[int] = field(default=16)
+ lora_dropout: Optional[float] = field(default=0.1)
+ lora_r: Optional[int] = field(default=64)
+ lora_target_modules: Optional[str] = field(
+ default="q_proj,k_proj,v_proj,o_proj,down_proj,up_proj,gate_proj",
+ metadata={"help": "comma separated list of target modules to apply LoRA layers to"},
+ )
+ use_nested_quant: Optional[bool] = field(
+ default=False,
+ metadata={"help": "Activate nested quantization for 4bit base models"},
+ )
+ bnb_4bit_compute_dtype: Optional[str] = field(
+ default="float16",
+ metadata={"help": "Compute dtype for 4bit base models"},
+ )
+ bnb_4bit_quant_storage_dtype: Optional[str] = field(
+ default="uint8",
+ metadata={"help": "Quantization storage dtype for 4bit base models"},
+ )
+ bnb_4bit_quant_type: Optional[str] = field(
+ default="nf4",
+ metadata={"help": "Quantization type fp4 or nf4"},
+ )
+ use_flash_attn: Optional[bool] = field(
+ default=False,
+ metadata={"help": "Enables Flash attention for training."},
+ )
+ use_peft_lora: Optional[bool] = field(
+ default=False,
+ metadata={"help": "Enables PEFT LoRA for training."},
+ )
+ use_8bit_quantization: Optional[bool] = field(
+ default=False,
+ metadata={"help": "Enables loading model in 8bit."},
+ )
+ use_4bit_quantization: Optional[bool] = field(
+ default=False,
+ metadata={"help": "Enables loading model in 4bit."},
+ )
+ use_reentrant: Optional[bool] = field(
+ default=False,
+ metadata={"help": "Gradient Checkpointing param. Refer the related docs"},
+ )
+ use_unsloth: Optional[bool] = field(
+ default=False,
+ metadata={"help": "Enables UnSloth for training."},
+ )
+
+
+@dataclass
+class DataTrainingArguments:
+ dataset_name: Optional[str] = field(
+ default="timdettmers/openassistant-guanaco",
+ metadata={"help": "The preference dataset to use."},
+ )
+ append_concat_token: Optional[bool] = field(
+ default=False,
+ metadata={"help": "If True, appends `eos_token_id` at the end of each sample being packed."},
+ )
+ add_special_tokens: Optional[bool] = field(
+ default=False,
+ metadata={"help": "If True, tokenizers adds special tokens to each sample being packed."},
+ )
+ splits: Optional[str] = field(
+ default="train,test",
+ metadata={"help": "Comma separate list of the splits to use from the dataset."},
+ )
+
+
+def main(model_args, data_args, training_args):
+ # Set seed for reproducibility
+ set_seed(training_args.seed)
+
+ # model
+ model, peft_config, tokenizer = create_and_prepare_model(model_args, data_args, training_args)
+
+ # gradient ckpt
+ model.config.use_cache = not training_args.gradient_checkpointing
+ training_args.gradient_checkpointing = training_args.gradient_checkpointing and not model_args.use_unsloth
+ if training_args.gradient_checkpointing:
+ training_args.gradient_checkpointing_kwargs = {"use_reentrant": model_args.use_reentrant}
+
+ training_args.dataset_kwargs = {
+ "append_concat_token": data_args.append_concat_token,
+ "add_special_tokens": data_args.add_special_tokens,
+ }
+
+ # datasets
+ train_dataset, eval_dataset = create_datasets(
+ tokenizer,
+ data_args,
+ training_args,
+ apply_chat_template=model_args.chat_template_format != "none",
+ )
+
+ # trainer
+ trainer = SFTTrainer(
+ model=model,
+ processing_class=tokenizer,
+ args=training_args,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ peft_config=peft_config,
+ )
+ trainer.accelerator.print(f"{trainer.model}")
+ if hasattr(trainer.model, "print_trainable_parameters"):
+ trainer.model.print_trainable_parameters()
+
+ # train
+ checkpoint = None
+ if training_args.resume_from_checkpoint is not None:
+ checkpoint = training_args.resume_from_checkpoint
+ trainer.train(resume_from_checkpoint=checkpoint)
+
+ # saving final model
+ if trainer.is_fsdp_enabled:
+ trainer.accelerator.state.fsdp_plugin.set_state_dict_type("FULL_STATE_DICT")
+ trainer.save_model()
+
+
+if __name__ == "__main__":
+ parser = HfArgumentParser((ModelArguments, DataTrainingArguments, SFTConfig))
+ if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
+ # If we pass only one argument to the script and it's the path to a json file,
+ # let's parse it to get our arguments.
+ model_args, data_args, training_args = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+ else:
+ model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+ model_args.max_length = training_args.max_length
+ main(model_args, data_args, training_args)
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/utils.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..2fcb8dabd4108fe8ccd2549ac90501d3ed914076
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/utils.py
@@ -0,0 +1,219 @@
+import os
+from enum import Enum
+
+import packaging.version
+import torch
+import transformers
+from datasets import DatasetDict, load_dataset, load_from_disk
+from datasets.builder import DatasetGenerationError
+from transformers import (
+ AutoModelForCausalLM,
+ AutoTokenizer,
+ BitsAndBytesConfig,
+)
+
+from peft import LoraConfig
+
+
+DEFAULT_CHATML_CHAT_TEMPLATE = "{% for message in messages %}\n{{'<|im_start|>' + message['role'] + '\n' + message['content'] + '<|im_end|>' + '\n'}}{% if loop.last and add_generation_prompt %}{{'<|im_start|>assistant\n' }}{% endif %}{% endfor %}"
+DEFAULT_ZEPHYR_CHAT_TEMPLATE = "{% for message in messages %}\n{% if message['role'] == 'user' %}\n{{ '<|user|>\n' + message['content'] + eos_token }}\n{% elif message['role'] == 'system' %}\n{{ '<|system|>\n' + message['content'] + eos_token }}\n{% elif message['role'] == 'assistant' %}\n{{ '<|assistant|>\n' + message['content'] + eos_token }}\n{% endif %}\n{% if loop.last and add_generation_prompt %}\n{{ '<|assistant|>' }}\n{% endif %}\n{% endfor %}"
+
+
+class ZephyrSpecialTokens(str, Enum):
+ user = "<|user|>"
+ assistant = "<|assistant|>"
+ system = "<|system|>"
+ eos_token = ""
+ bos_token = ""
+ pad_token = ""
+
+ @classmethod
+ def list(cls):
+ return [c.value for c in cls]
+
+
+class ChatmlSpecialTokens(str, Enum):
+ user = "<|im_start|>user"
+ assistant = "<|im_start|>assistant"
+ system = "<|im_start|>system"
+ eos_token = "<|im_end|>"
+ bos_token = ""
+ pad_token = ""
+
+ @classmethod
+ def list(cls):
+ return [c.value for c in cls]
+
+
+def create_datasets(tokenizer, data_args, training_args, apply_chat_template=False):
+ def preprocess(samples):
+ batch = []
+ for conversation in samples["messages"]:
+ batch.append(tokenizer.apply_chat_template(conversation, tokenize=False))
+ return {"content": batch}
+
+ raw_datasets = DatasetDict()
+ for split in data_args.splits.split(","):
+ try:
+ # Try first if dataset on a Hub repo
+ dataset = load_dataset(data_args.dataset_name, split=split)
+ except DatasetGenerationError:
+ # If not, check local dataset
+ dataset = load_from_disk(os.path.join(data_args.dataset_name, split))
+
+ if "train" in split:
+ raw_datasets["train"] = dataset
+ elif "test" in split:
+ raw_datasets["test"] = dataset
+ else:
+ raise ValueError(f"Split type {split} not recognized as one of test or train.")
+
+ if apply_chat_template:
+ raw_datasets = raw_datasets.map(
+ preprocess,
+ batched=True,
+ remove_columns=raw_datasets["train"].column_names,
+ )
+
+ train_data = raw_datasets["train"]
+ valid_data = raw_datasets["test"]
+ print(f"Size of the train set: {len(train_data)}. Size of the validation set: {len(valid_data)}")
+ print(f"A sample of train dataset: {train_data[0]}")
+
+ return train_data, valid_data
+
+
+def create_and_prepare_model(args, data_args, training_args):
+ if args.use_unsloth:
+ from unsloth import FastLanguageModel
+ bnb_config = None
+ quant_storage_dtype = None
+
+ if (
+ torch.distributed.is_available()
+ and torch.distributed.is_initialized()
+ and torch.distributed.get_world_size() > 1
+ and args.use_unsloth
+ ):
+ raise NotImplementedError("Unsloth is not supported in distributed training")
+
+ if args.use_4bit_quantization and args.use_8bit_quantization:
+ raise ValueError("You configured 4bit and 8bit quantization at the same time, please choose only one of them.")
+ elif args.use_4bit_quantization:
+ compute_dtype = getattr(torch, args.bnb_4bit_compute_dtype)
+ quant_storage_dtype = getattr(torch, args.bnb_4bit_quant_storage_dtype)
+
+ bnb_config = BitsAndBytesConfig(
+ load_in_4bit=args.use_4bit_quantization,
+ bnb_4bit_quant_type=args.bnb_4bit_quant_type,
+ bnb_4bit_compute_dtype=compute_dtype,
+ bnb_4bit_use_double_quant=args.use_nested_quant,
+ bnb_4bit_quant_storage=quant_storage_dtype,
+ )
+
+ if compute_dtype == torch.float16 and args.use_4bit_quantization:
+ major, _ = torch.cuda.get_device_capability()
+ if major >= 8:
+ print("=" * 80)
+ print("Your GPU supports bfloat16, you can accelerate training with the argument --bf16")
+ print("=" * 80)
+ elif args.use_8bit_quantization:
+ bnb_config = BitsAndBytesConfig(load_in_8bit=args.use_8bit_quantization)
+
+ if args.use_unsloth:
+ if torch.xpu.is_available():
+ raise NotImplementedError("XPU hasn't supported unsloth yet")
+ # Load model
+ model, _ = FastLanguageModel.from_pretrained(
+ model_name=args.model_name_or_path,
+ max_seq_length=training_args.max_length,
+ dtype=None,
+ load_in_4bit=args.use_4bit_quantization,
+ )
+ else:
+ dtype = quant_storage_dtype if quant_storage_dtype and quant_storage_dtype.is_floating_point else torch.float32
+
+ # Prepare model loading arguments
+ model_kwargs = {
+ "trust_remote_code": True,
+ "dtype": dtype,
+ }
+ if args.use_flash_attn:
+ if torch.xpu.is_available():
+ print("XPU hasn't supported flash_attn yet, use eager implementation instead.")
+ model_kwargs["attn_implementation"] = "eager"
+ else:
+ model_kwargs["attn_implementation"] = "flash_attention_2"
+
+ # Only add quantization_config if bnb_config is not None
+ if bnb_config is not None:
+ model_kwargs["quantization_config"] = bnb_config
+
+ model = AutoModelForCausalLM.from_pretrained(args.model_name_or_path, **model_kwargs)
+
+ peft_config = None
+ chat_template = None
+ if args.use_peft_lora and not args.use_unsloth:
+ peft_config = LoraConfig(
+ lora_alpha=args.lora_alpha,
+ lora_dropout=args.lora_dropout,
+ r=args.lora_r,
+ bias="none",
+ task_type="CAUSAL_LM",
+ target_modules=args.lora_target_modules.split(",")
+ if args.lora_target_modules != "all-linear"
+ else args.lora_target_modules,
+ )
+
+ special_tokens = None
+ chat_template = None
+ if args.chat_template_format == "chatml":
+ special_tokens = ChatmlSpecialTokens
+ chat_template = DEFAULT_CHATML_CHAT_TEMPLATE
+ elif args.chat_template_format == "zephyr":
+ special_tokens = ZephyrSpecialTokens
+ chat_template = DEFAULT_ZEPHYR_CHAT_TEMPLATE
+
+ if special_tokens is not None:
+ tokenizer = AutoTokenizer.from_pretrained(
+ args.model_name_or_path,
+ pad_token=special_tokens.pad_token.value,
+ bos_token=special_tokens.bos_token.value,
+ eos_token=special_tokens.eos_token.value,
+ additional_special_tokens=special_tokens.list(),
+ trust_remote_code=True,
+ )
+ tokenizer.chat_template = chat_template
+
+ # make embedding resizing configurable?
+ # Transformers 4.46.0+ defaults uses mean_resizing by default, which fails with QLoRA + FSDP because the
+ # embedding could be on meta device, therefore, we set mean_resizing=False in that case (i.e. the status quo
+ # ante). See https://github.com/huggingface/accelerate/issues/1620.
+ uses_transformers_4_46 = packaging.version.parse(transformers.__version__) >= packaging.version.parse("4.46.0")
+ uses_fsdp = os.environ.get("ACCELERATE_USE_FSDP", "false").lower() == "true"
+ # Check if the model is quantized
+ is_quantized = (bnb_config is not None) or (getattr(model, "hf_quantizer", None) is not None)
+ if is_quantized and uses_fsdp and uses_transformers_4_46:
+ model.resize_token_embeddings(len(tokenizer), pad_to_multiple_of=8, mean_resizing=False)
+ else:
+ model.resize_token_embeddings(len(tokenizer), pad_to_multiple_of=8)
+ else:
+ tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path, trust_remote_code=True)
+ tokenizer.pad_token = tokenizer.eos_token
+
+ if args.use_unsloth:
+ # Do model patching and add fast LoRA weights
+ model = FastLanguageModel.get_peft_model(
+ model,
+ lora_alpha=args.lora_alpha,
+ lora_dropout=args.lora_dropout,
+ r=args.lora_r,
+ target_modules=args.lora_target_modules.split(",")
+ if args.lora_target_modules != "all-linear"
+ else args.lora_target_modules,
+ use_gradient_checkpointing=training_args.gradient_checkpointing,
+ random_state=training_args.seed,
+ max_seq_length=training_args.max_length,
+ )
+
+ return model, peft_config, tokenizer
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/shira_finetuning/README.md b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/shira_finetuning/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..d8a30ec8863adcedfc4a4215e872c4caff92226a
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/shira_finetuning/README.md
@@ -0,0 +1,73 @@
+# Sparse High Rank Adapters
+
+## Introduction
+Sparse High Rank Adapters or [SHiRA](https://huggingface.co/papers/2406.13175) is an alternate type of adapter and has been found to have significant advantages over the low rank adapters. Specifically, SHiRA achieves better accuracy than LoRA for a variety of vision and language tasks. It also offers simpler and higher quality multi-adapter fusion by significantly reducing concept loss, a common problem faced by low rank adapters. SHiRA directly finetunes a small number of the base model's parameters to finetune the model on any adaptation task.
+
+## Quick start
+```python
+import torch
+from peft import ShiraConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from trl import SFTConfig, SFTTrainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m", dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
+dataset = load_dataset("imdb", split="train[:1%]")
+shira_config = ShiraConfig(
+ r=32,
+)
+peft_model = get_peft_model(model, shira_config)
+training_args = SFTConfig(dataset_text_field="text", max_length=128)
+trainer = SFTTrainer(
+ model=peft_model,
+ train_dataset=dataset,
+ processing_class=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("shira-opt-350m")
+```
+
+For more options and a more detailed example code, you can refer to shira finetuning script.
+Run the script simply by running:
+```bash
+python3 examples/shira_finetuning/shira_finetuning.py --base_model facebook/opt-350m
+```
+
+If you want to run DDP by [accelerate](https://huggingface.co/docs/accelerate/en/index), please run `accelerate config` to set your ddp config, and run:
+```bash
+accelerate launch examples/shira_finetuning/shira_finetuning.py --base_model facebook/opt-350m
+```
+please add `--device_map cpu` if you want to run finetune on CPU.
+
+If you want to train SHiRA with a custom sparse mask function which requires custom keyword arguments, please see the definition of `custom_random_mask_function_with_custom_kwargs` function provided in the `shira_fintuning.py` script. You can run this code using the `--use_custom_random_mask_function_with_custom_kwargs` argument. Without this argument, SHiRA defaults to a random sparse mask. Please run the code as follows. :
+```bash
+python3 examples/shira_finetuning/shira_finetuning.py --base_model facebook/opt-350m --use_custom_random_mask_function_with_custom_kwargs
+
+```
+
+
+## Use the model
+You can load and use the model as any other 🤗 PEFT model
+```python
+from peft import PeftModel
+from transformers import AutoTokenizer, AutoModelForCausalLM
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")
+tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
+shira_model = PeftModel.from_pretrained(model, "shira-opt-350m")
+```
+
+## Citation
+```
+@inproceedings{NEURIPS2024_18c0102c,
+ author = {Bhardwaj, Kartikeya and Pandey, Nilesh Prasad and Priyadarshi, Sweta and Ganapathy, Viswanath and Kadambi, Shreya and Esteves, Rafael and Borse, Shubhankar and Whatmough, Paul and Garrepalli, Risheek and Van Baalen, Mart and Teague, Harris and Nagel, Markus},
+ booktitle = {Advances in Neural Information Processing Systems},
+ editor = {A. Globerson and L. Mackey and D. Belgrave and A. Fan and U. Paquet and J. Tomczak and C. Zhang},
+ pages = {13685--13715},
+ publisher = {Curran Associates, Inc.},
+ title = {Sparse High Rank Adapters},
+ url = {https://proceedings.neurips.cc/paper_files/paper/2024/file/18c0102cb7f1a02c14f0929089b2e576-Paper-Conference.pdf},
+ volume = {37},
+ year = {2024}
+}
+```
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/shira_finetuning/shira_finetuning.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/shira_finetuning/shira_finetuning.py
new file mode 100644
index 0000000000000000000000000000000000000000..b6478fc61b16f1a40ab70c09eb37d1d07df18d9c
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/shira_finetuning/shira_finetuning.py
@@ -0,0 +1,217 @@
+# Copyright 2025-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import os
+from typing import Optional
+
+import torch
+import transformers
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed
+
+from peft import (
+ PeftModel,
+ ShiraConfig,
+ get_peft_model,
+)
+
+
+def train(
+ base_model: str = "path/to/model",
+ data_path: str = "yahma/alpaca-cleaned",
+ output_dir: str = "shira",
+ batch_size: int = 16,
+ num_epochs: int = 1,
+ learning_rate: float = 3e-4,
+ cutoff_len: int = 256,
+ val_set_size: int = 16,
+ eval_step: int = 100,
+ save_step: int = 100,
+ device_map: str = "auto",
+ shira_r: int = 32,
+ shira_target_modules: Optional[list[str]] = None,
+ dtype: str = "float16",
+ seed: Optional[int] = None,
+ use_custom_random_mask_function_with_custom_kwargs: Optional[bool] = False,
+):
+ # Set device_map to the right place when enabling DDP.
+ world_size = int(os.environ.get("WORLD_SIZE", "0")) or int(os.environ.get("PMI_SIZE", "0"))
+ if world_size > 1 and device_map != "cpu":
+ from accelerate import Accelerator
+
+ device_map = {"": Accelerator().process_index}
+ # Set seed
+ if seed is not None:
+ set_seed(seed)
+ model_kwargs = {"dtype": getattr(torch, dtype), "device_map": device_map}
+ model = AutoModelForCausalLM.from_pretrained(base_model, **model_kwargs)
+
+ tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
+ # For some tokenizer with no pad token like llama
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+
+ def tokenize(prompt, add_eos_token=True):
+ result = tokenizer(
+ prompt,
+ truncation=True,
+ max_length=cutoff_len,
+ padding=False,
+ return_tensors=None,
+ )
+ if (
+ result["input_ids"][-1] != tokenizer.eos_token_id
+ and len(result["input_ids"]) < cutoff_len
+ and add_eos_token
+ ):
+ result["input_ids"].append(tokenizer.eos_token_id)
+ result["attention_mask"].append(1)
+
+ result["labels"] = result["input_ids"].copy()
+
+ return result
+
+ def generate_and_tokenize_prompt(example):
+ full_prompt = generate_prompt(example)
+ tokenized_full_prompt = tokenize(full_prompt)
+ return tokenized_full_prompt
+
+ def custom_random_mask_function_with_custom_kwargs(custom_arg):
+ def mask_fn(base_layer, r):
+ """
+ This mask function is similar to the random_mask provided in src/peft/tuners/shira/mask_functions.py except the seed is derived from custom_kwargs.
+ Please use this as an example to create your own custom sparse masks that may use custom_kwargs. Remember, for a pretrained weight with shape m, n,
+ mask_fn must return only one mask (shape: m, n) which must be binary 0 or 1 with num_shira_parameters = r(m+n) for linear layers. Device and dtype
+ of mask must be same as base layer's weight's device and dtype.
+ """
+ new_seed = custom_arg
+ shape = base_layer.weight.shape
+ num_shira_weights = r * (shape[0] + shape[1])
+ random_generator = torch.Generator()
+ random_generator.manual_seed(new_seed)
+
+ idx = (torch.randperm(base_layer.weight.numel(), generator=random_generator)[:num_shira_weights]).to(
+ base_layer.weight.device
+ )
+ val = torch.ones_like(idx.type(base_layer.weight.dtype))
+ mask = torch.zeros_like(base_layer.weight.view(1, -1))
+ mask = mask.scatter_(1, idx.unsqueeze(0), val.unsqueeze(0)).view(shape)
+
+ return mask
+
+ return mask_fn
+
+ mask_type = "random" if not use_custom_random_mask_function_with_custom_kwargs else "custom"
+ config = ShiraConfig(
+ r=shira_r,
+ mask_type=mask_type,
+ target_modules=shira_target_modules,
+ task_type="CAUSAL_LM",
+ )
+ if use_custom_random_mask_function_with_custom_kwargs:
+ custom_arg = 120
+ custom_mask_fn = custom_random_mask_function_with_custom_kwargs(custom_arg)
+ config.mask_fn = custom_mask_fn
+
+ model = get_peft_model(model, config)
+
+ data = load_dataset(data_path)
+
+ train_val = data["train"].train_test_split(test_size=val_set_size, shuffle=True, seed=42)
+ train_data = train_val["train"].shuffle().map(generate_and_tokenize_prompt)
+ val_data = train_val["test"].shuffle().map(generate_and_tokenize_prompt)
+
+ trainer = transformers.Trainer(
+ model=model,
+ train_dataset=train_data,
+ eval_dataset=val_data,
+ args=transformers.TrainingArguments(
+ per_device_train_batch_size=batch_size,
+ warmup_steps=100,
+ num_train_epochs=num_epochs,
+ learning_rate=learning_rate,
+ logging_steps=100,
+ optim="adamw_torch",
+ eval_strategy="steps",
+ save_strategy="steps",
+ eval_steps=eval_step,
+ save_steps=save_step,
+ output_dir=output_dir,
+ save_total_limit=3,
+ load_best_model_at_end=True,
+ ddp_find_unused_parameters=False if world_size > 1 else None,
+ ),
+ data_collator=transformers.DataCollatorForSeq2Seq(
+ tokenizer, pad_to_multiple_of=8, return_tensors="pt", padding=True
+ ),
+ )
+ trainer.train()
+ model.save_pretrained(output_dir)
+
+ # Delete the model and load it again from the checkpoint.
+ del model
+ model = AutoModelForCausalLM.from_pretrained(base_model, **model_kwargs)
+ model = PeftModel.from_pretrained(model, output_dir)
+
+
+def generate_prompt(example):
+ return f"""Below is an instruction that describes a task. Write a response that appropriately completes the request.
+ ### Instruction:
+ {example["instruction"]}
+ ### Response:
+ {example["output"]}"""
+
+
+if __name__ == "__main__":
+ import argparse
+
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--base_model", type=str, default="path/to/model")
+ parser.add_argument("--data_path", type=str, default="yahma/alpaca-cleaned")
+ parser.add_argument("--output_dir", type=str, default="shira")
+ parser.add_argument("--batch_size", type=int, default=16)
+ parser.add_argument("--num_epochs", type=int, default=1)
+ parser.add_argument("--learning_rate", type=float, default=3e-4)
+ parser.add_argument("--cutoff_len", type=int, default=256)
+ parser.add_argument("--val_set_size", type=int, default=16)
+ parser.add_argument("--eval_step", type=int, default=100)
+ parser.add_argument("--save_step", type=int, default=100)
+ parser.add_argument("--device_map", type=str, default="auto")
+ parser.add_argument("--shira_r", type=int, default=32)
+ parser.add_argument("--shira_target_modules", type=str, default=None)
+ parser.add_argument("--dtype", type=str, default="float16")
+ parser.add_argument("--seed", type=int, default=None)
+ parser.add_argument("--use_custom_random_mask_function_with_custom_kwargs", action="store_true")
+
+ args = parser.parse_args()
+
+ train(
+ base_model=args.base_model,
+ data_path=args.data_path,
+ output_dir=args.output_dir,
+ batch_size=args.batch_size,
+ num_epochs=args.num_epochs,
+ learning_rate=args.learning_rate,
+ cutoff_len=args.cutoff_len,
+ val_set_size=args.val_set_size,
+ eval_step=args.eval_step,
+ save_step=args.save_step,
+ device_map=args.device_map,
+ shira_r=args.shira_r,
+ shira_target_modules=args.shira_target_modules,
+ dtype=args.dtype,
+ seed=args.seed,
+ use_custom_random_mask_function_with_custom_kwargs=args.use_custom_random_mask_function_with_custom_kwargs,
+ )
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/stable_diffusion/convert_sd_adapter_to_peft.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/stable_diffusion/convert_sd_adapter_to_peft.py
new file mode 100644
index 0000000000000000000000000000000000000000..b692ba5d06fdf3b04be58f929ad946413c393357
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/stable_diffusion/convert_sd_adapter_to_peft.py
@@ -0,0 +1,517 @@
+import argparse
+import json
+import logging
+import os
+from collections import Counter
+from dataclasses import dataclass
+from operator import attrgetter
+from typing import Optional, Union
+
+import safetensors
+import torch
+from diffusers import UNet2DConditionModel
+from torch import nn
+from transformers import CLIPTextModel
+
+from peft import LoHaConfig, LoKrConfig, LoraConfig, PeftType, get_peft_model, set_peft_model_state_dict
+from peft.tuners.lokr.layer import factorization
+
+
+logger = logging.getLogger(__name__)
+
+
+# Default kohya_ss LoRA replacement modules
+# https://github.com/kohya-ss/sd-scripts/blob/c924c47f374ac1b6e33e71f82948eb1853e2243f/networks/lora.py#L661
+UNET_TARGET_REPLACE_MODULE = ["Transformer2DModel", "Attention"]
+UNET_TARGET_REPLACE_MODULE_CONV2D_3X3 = ["ResnetBlock2D", "Downsample2D", "Upsample2D"]
+TEXT_ENCODER_TARGET_REPLACE_MODULE = ["CLIPAttention", "CLIPMLP"]
+PREFIX_UNET = "lora_unet"
+PREFIX_TEXT_ENCODER = "lora_te"
+
+
+@dataclass
+class LoRAInfo:
+ kohya_key: str
+ peft_key: str
+ alpha: Optional[float] = None
+ rank: Optional[int] = None
+ lora_A: Optional[torch.Tensor] = None
+ lora_B: Optional[torch.Tensor] = None
+
+ def peft_state_dict(self) -> dict[str, torch.Tensor]:
+ if self.lora_A is None or self.lora_B is None:
+ raise ValueError("At least one of lora_A or lora_B is None, they must both be provided")
+ return {
+ f"base_model.model.{self.peft_key}.lora_A.weight": self.lora_A,
+ f"base_model.model.{self.peft_key}.lora_B.weight": self.lora_B,
+ }
+
+
+@dataclass
+class LoHaInfo:
+ kohya_key: str
+ peft_key: str
+ alpha: Optional[float] = None
+ rank: Optional[int] = None
+ hada_w1_a: Optional[torch.Tensor] = None
+ hada_w1_b: Optional[torch.Tensor] = None
+ hada_w2_a: Optional[torch.Tensor] = None
+ hada_w2_b: Optional[torch.Tensor] = None
+ hada_t1: Optional[torch.Tensor] = None
+ hada_t2: Optional[torch.Tensor] = None
+
+ def peft_state_dict(self) -> dict[str, torch.Tensor]:
+ if self.hada_w1_a is None or self.hada_w1_b is None or self.hada_w2_a is None or self.hada_w2_b is None:
+ raise ValueError(
+ "At least one of hada_w1_a, hada_w1_b, hada_w2_a, hada_w2_b is missing, they all must be provided"
+ )
+ state_dict = {
+ f"base_model.model.{self.peft_key}.hada_w1_a": self.hada_w1_a,
+ f"base_model.model.{self.peft_key}.hada_w1_b": self.hada_w1_b,
+ f"base_model.model.{self.peft_key}.hada_w2_a": self.hada_w2_a,
+ f"base_model.model.{self.peft_key}.hada_w2_b": self.hada_w2_b,
+ }
+ if not (
+ (self.hada_t1 is None and self.hada_t2 is None) or (self.hada_t1 is not None and self.hada_t2 is not None)
+ ):
+ raise ValueError("hada_t1 and hada_t2 must be either both present or not present at the same time")
+ if self.hada_t1 is not None and self.hada_t2 is not None:
+ state_dict[f"base_model.model.{self.peft_key}.hada_t1"] = self.hada_t1
+ state_dict[f"base_model.model.{self.peft_key}.hada_t2"] = self.hada_t2
+ return state_dict
+
+
+@dataclass
+class LoKrInfo:
+ kohya_key: str
+ peft_key: str
+ alpha: Optional[float] = None
+ rank: Optional[int] = None
+ lokr_w1: Optional[torch.Tensor] = None
+ lokr_w1_a: Optional[torch.Tensor] = None
+ lokr_w1_b: Optional[torch.Tensor] = None
+ lokr_w2: Optional[torch.Tensor] = None
+ lokr_w2_a: Optional[torch.Tensor] = None
+ lokr_w2_b: Optional[torch.Tensor] = None
+ lokr_t2: Optional[torch.Tensor] = None
+
+ def peft_state_dict(self) -> dict[str, torch.Tensor]:
+ if (self.lokr_w1 is None) and ((self.lokr_w1_a is None) or (self.lokr_w1_b is None)):
+ raise ValueError("Either lokr_w1 or both lokr_w1_a and lokr_w1_b should be provided")
+
+ if (self.lokr_w2 is None) and ((self.lokr_w2_a is None) or (self.lokr_w2_b is None)):
+ raise ValueError("Either lokr_w2 or both lokr_w2_a and lokr_w2_b should be provided")
+
+ state_dict = {}
+
+ if self.lokr_w1 is not None:
+ state_dict[f"base_model.model.{self.peft_key}.lokr_w1"] = self.lokr_w1
+ elif self.lokr_w1_a is not None:
+ state_dict[f"base_model.model.{self.peft_key}.lokr_w1_a"] = self.lokr_w1_a
+ state_dict[f"base_model.model.{self.peft_key}.lokr_w1_b"] = self.lokr_w1_b
+
+ if self.lokr_w2 is not None:
+ state_dict[f"base_model.model.{self.peft_key}.lokr_w2"] = self.lokr_w2
+ elif self.lokr_w2_a is not None:
+ state_dict[f"base_model.model.{self.peft_key}.lokr_w2_a"] = self.lokr_w2_a
+ state_dict[f"base_model.model.{self.peft_key}.lokr_w2_b"] = self.lokr_w2_b
+
+ if self.lokr_t2 is not None:
+ state_dict[f"base_model.model.{self.peft_key}.lokr_t2"] = self.lokr_t2
+
+ return state_dict
+
+
+def construct_peft_loraconfig(info: dict[str, LoRAInfo], **kwargs) -> LoraConfig:
+ """Constructs LoraConfig from data extracted from adapter checkpoint
+
+ Args:
+ info (Dict[str, LoRAInfo]): Information extracted from adapter checkpoint
+
+ Returns:
+ LoraConfig: config for constructing LoRA
+ """
+
+ # Unpack all ranks and alphas
+ ranks = {key: val.rank for key, val in info.items()}
+ alphas = {x[0]: x[1].alpha or x[1].rank for x in info.items()}
+
+ # Determine which modules needs to be transformed
+ target_modules = sorted(info.keys())
+
+ # Determine most common rank and alpha
+ r = int(Counter(ranks.values()).most_common(1)[0][0])
+ lora_alpha = Counter(alphas.values()).most_common(1)[0][0]
+
+ # Determine which modules have different rank and alpha
+ rank_pattern = dict(sorted(filter(lambda x: x[1] != r, ranks.items()), key=lambda x: x[0]))
+ alpha_pattern = dict(sorted(filter(lambda x: x[1] != lora_alpha, alphas.items()), key=lambda x: x[0]))
+
+ config = LoraConfig(
+ r=r,
+ lora_alpha=lora_alpha,
+ target_modules=target_modules,
+ lora_dropout=0.0,
+ bias="none",
+ init_lora_weights=False,
+ rank_pattern=rank_pattern,
+ alpha_pattern=alpha_pattern,
+ )
+
+ return config
+
+
+def construct_peft_lohaconfig(info: dict[str, LoHaInfo], **kwargs) -> LoHaConfig:
+ """Constructs LoHaConfig from data extracted from adapter checkpoint
+
+ Args:
+ info (Dict[str, LoHaInfo]): Information extracted from adapter checkpoint
+
+ Returns:
+ LoHaConfig: config for constructing LoHA
+ """
+
+ # Unpack all ranks and alphas
+ ranks = {x[0]: x[1].rank for x in info.items()}
+ alphas = {x[0]: x[1].alpha or x[1].rank for x in info.items()}
+
+ # Determine which modules needs to be transformed
+ target_modules = sorted(info.keys())
+
+ # Determine most common rank and alpha
+ r = int(Counter(ranks.values()).most_common(1)[0][0])
+ alpha = Counter(alphas.values()).most_common(1)[0][0]
+
+ # Determine which modules have different rank and alpha
+ rank_pattern = dict(sorted(filter(lambda x: x[1] != r, ranks.items()), key=lambda x: x[0]))
+ alpha_pattern = dict(sorted(filter(lambda x: x[1] != alpha, alphas.items()), key=lambda x: x[0]))
+
+ # Determine whether any of modules have effective conv2d decomposition
+ use_effective_conv2d = any((val.hada_t1 is not None) or (val.hada_t2 is not None) for val in info.values())
+
+ config = LoHaConfig(
+ r=r,
+ alpha=alpha,
+ target_modules=target_modules,
+ rank_dropout=0.0,
+ module_dropout=0.0,
+ init_weights=False,
+ rank_pattern=rank_pattern,
+ alpha_pattern=alpha_pattern,
+ use_effective_conv2d=use_effective_conv2d,
+ )
+
+ return config
+
+
+def construct_peft_lokrconfig(info: dict[str, LoKrInfo], decompose_factor: int = -1, **kwargs) -> LoKrConfig:
+ """Constructs LoKrConfig from data extracted from adapter checkpoint
+
+ Args:
+ info (Dict[str, LoKrInfo]): Information extracted from adapter checkpoint
+
+ Returns:
+ LoKrConfig: config for constructing LoKr
+ """
+
+ # Unpack all ranks and alphas
+ ranks = {x[0]: x[1].rank for x in info.items()}
+ alphas = {x[0]: x[1].alpha or x[1].rank for x in info.items()}
+
+ # Determine which modules needs to be transformed
+ target_modules = sorted(info.keys())
+
+ # Determine most common rank and alpha
+ r = int(Counter(ranks.values()).most_common(1)[0][0])
+ alpha = Counter(alphas.values()).most_common(1)[0][0]
+
+ # Determine which modules have different rank and alpha
+ rank_pattern = dict(sorted(filter(lambda x: x[1] != r, ranks.items()), key=lambda x: x[0]))
+ alpha_pattern = dict(sorted(filter(lambda x: x[1] != alpha, alphas.items()), key=lambda x: x[0]))
+
+ # Determine whether any of modules have effective conv2d decomposition
+ use_effective_conv2d = any((val.lokr_t2 is not None) for val in info.values())
+
+ # decompose_both should be enabled if any w1 matrix in any layer is decomposed into 2
+ decompose_both = any((val.lokr_w1_a is not None and val.lokr_w1_b is not None) for val in info.values())
+
+ # Determining decompose factor is a bit tricky (but it is most often -1)
+ # Check that decompose_factor is equal to provided
+ for val in info.values():
+ # Determine shape of first matrix
+ if val.lokr_w1 is not None:
+ w1_shape = tuple(val.lokr_w1.shape)
+ else:
+ w1_shape = (val.lokr_w1_a.shape[0], val.lokr_w1_b.shape[1])
+
+ # Determine shape of second matrix
+ if val.lokr_w2 is not None:
+ w2_shape = tuple(val.lokr_w2.shape[:2])
+ elif val.lokr_t2 is not None:
+ w2_shape = (val.lokr_w2_a.shape[1], val.lokr_w2_b.shape[1])
+ else:
+ # We may iterate over Conv2d layer, for which second item in shape is multiplied by ksize^2
+ w2_shape = (val.lokr_w2_a.shape[0], val.lokr_w2_b.shape[1])
+
+ # We need to check, whether decompose_factor is really -1 or not
+ shape = (w1_shape[0], w2_shape[0])
+ if factorization(shape[0] * shape[1], factor=-1) != shape:
+ raise ValueError("Cannot infer decompose_factor, probably it is not equal to -1")
+
+ config = LoKrConfig(
+ r=r,
+ alpha=alpha,
+ target_modules=target_modules,
+ rank_dropout=0.0,
+ module_dropout=0.0,
+ init_weights=False,
+ rank_pattern=rank_pattern,
+ alpha_pattern=alpha_pattern,
+ use_effective_conv2d=use_effective_conv2d,
+ decompose_both=decompose_both,
+ decompose_factor=decompose_factor,
+ )
+
+ return config
+
+
+def combine_peft_state_dict(info: dict[str, Union[LoRAInfo, LoHaInfo]]) -> dict[str, torch.Tensor]:
+ result = {}
+ for key_info in info.values():
+ result.update(key_info.peft_state_dict())
+ return result
+
+
+def detect_adapter_type(keys: list[str]) -> PeftType:
+ # Detect type of adapter by keys
+ # Inspired by this:
+ # https://github.com/bmaltais/kohya_ss/blob/ed4e3b0239a40506de9a17e550e6cf2d0b867a4f/tools/lycoris_utils.py#L312
+ for key in keys:
+ if "alpha" in key:
+ continue
+ elif any(x in key for x in ["lora_down", "lora_up"]):
+ # LoRA
+ return PeftType.LORA
+ elif any(x in key for x in ["hada_w1", "hada_w2", "hada_t1", "hada_t2"]):
+ # LoHa may have the following keys:
+ # hada_w1_a, hada_w1_b, hada_w2_a, hada_w2_b, hada_t1, hada_t2
+ return PeftType.LOHA
+ elif any(x in key for x in ["lokr_w1", "lokr_w2", "lokr_t1", "lokr_t2"]):
+ # LoKr may have the following keys:
+ # lokr_w1, lokr_w2, lokr_w1_a, lokr_w1_b, lokr_w2_a, lokr_w2_b, lokr_t1, lokr_t2
+ return PeftType.LOKR
+ elif "diff" in key:
+ raise ValueError("Currently full diff adapters are not implemented")
+ else:
+ raise ValueError("Unknown adapter type, probably not implemented")
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser()
+
+ parser.add_argument("--sd_checkpoint", default=None, type=str, required=True, help="SD checkpoint to use")
+
+ parser.add_argument(
+ "--adapter_path",
+ default=None,
+ type=str,
+ required=True,
+ help="Path to downloaded adapter to convert",
+ )
+
+ parser.add_argument("--dump_path", default=None, type=str, required=True, help="Path to the output peft adapter.")
+
+ parser.add_argument("--half", action="store_true", help="Save weights in half precision.")
+ parser.add_argument(
+ "--loha_conv2d_weights_fix",
+ action="store_true",
+ help="""LoHa checkpoints trained with lycoris-lora<=1.9.0 contain a bug described in this PR https://github.com/KohakuBlueleaf/LyCORIS/pull/115.
+ This option fixes this bug during weight conversion (replaces hada_t2 with hada_t1 for Conv2d 3x3 layers).
+ The output results may differ from webui, but in general, they should be better in terms of quality.
+ This option should be set to True in case the provided checkpoint has been trained with lycoris-lora version for which the mentioned PR wasn't merged.
+ This option should be set to False in case the provided checkpoint has been trained with lycoris-lora version for which the mentioned PR is merged or full compatibility with webui outputs is required.""",
+ )
+ args = parser.parse_args()
+
+ # Load all models that we need to add adapter to
+ text_encoder = CLIPTextModel.from_pretrained(args.sd_checkpoint, subfolder="text_encoder")
+ unet = UNet2DConditionModel.from_pretrained(args.sd_checkpoint, subfolder="unet")
+
+ # Construct possible mapping from kohya keys to peft keys
+ models_keys = {}
+ for model, model_key, model_name in [
+ (text_encoder, PREFIX_TEXT_ENCODER, "text_encoder"),
+ (unet, PREFIX_UNET, "unet"),
+ ]:
+ models_keys.update(
+ {
+ f"{model_key}.{peft_key}".replace(".", "_"): peft_key
+ for peft_key in (x[0] for x in model.named_modules())
+ }
+ )
+
+ # Store conversion info (model_type -> peft_key -> LoRAInfo | LoHaInfo | LoKrInfo)
+ adapter_info: dict[str, dict[str, Union[LoRAInfo, LoHaInfo, LoKrInfo]]] = {
+ "text_encoder": {},
+ "unet": {},
+ }
+
+ # Store decompose_factor for LoKr
+ decompose_factor = -1
+
+ # Open adapter checkpoint
+ with safetensors.safe_open(args.adapter_path, framework="pt", device="cpu") as f:
+ # Extract information about adapter structure
+ metadata = f.metadata()
+
+ # It may be difficult to determine rank for LoKr adapters
+ # If checkpoint was trained with large rank it may not be utilized during weights creation at all
+ # So we need to get it from checkpoint metadata (along with decompose_factor)
+ rank, conv_rank = None, None
+ if metadata is not None:
+ rank = metadata.get("ss_network_dim", None)
+ rank = int(rank) if rank else None
+ if "ss_network_args" in metadata:
+ network_args = json.loads(metadata["ss_network_args"])
+ conv_rank = network_args.get("conv_dim", None)
+ conv_rank = int(conv_rank) if conv_rank else rank
+ decompose_factor = network_args.get("factor", -1)
+ decompose_factor = int(decompose_factor)
+
+ # Detect adapter type based on keys
+ adapter_type = detect_adapter_type(f.keys())
+ adapter_info_cls = {
+ PeftType.LORA: LoRAInfo,
+ PeftType.LOHA: LoHaInfo,
+ PeftType.LOKR: LoKrInfo,
+ }[adapter_type]
+
+ # Iterate through available info and unpack all the values
+ for key in f.keys():
+ kohya_key, kohya_type = key.split(".")[:2]
+
+ # Find which model this key belongs to
+ if kohya_key.startswith(PREFIX_TEXT_ENCODER):
+ model_type, model = "text_encoder", text_encoder
+ elif kohya_key.startswith(PREFIX_UNET):
+ model_type, model = "unet", unet
+ else:
+ raise ValueError(f"Cannot determine model for key: {key}")
+
+ # Find corresponding peft key
+ if kohya_key not in models_keys:
+ raise ValueError(f"Cannot find corresponding key for diffusers/transformers model: {kohya_key}")
+ peft_key = models_keys[kohya_key]
+
+ # Retrieve corresponding layer of model
+ layer = attrgetter(peft_key)(model)
+
+ # Create a corresponding adapter info
+ if peft_key not in adapter_info[model_type]:
+ adapter_info[model_type][peft_key] = adapter_info_cls(kohya_key=kohya_key, peft_key=peft_key)
+
+ tensor = f.get_tensor(key)
+ if kohya_type == "alpha":
+ adapter_info[model_type][peft_key].alpha = tensor.item()
+ elif kohya_type == "lora_down":
+ adapter_info[model_type][peft_key].lora_A = tensor
+ adapter_info[model_type][peft_key].rank = tensor.shape[0]
+ elif kohya_type == "lora_up":
+ adapter_info[model_type][peft_key].lora_B = tensor
+ adapter_info[model_type][peft_key].rank = tensor.shape[1]
+ elif kohya_type == "hada_w1_a":
+ adapter_info[model_type][peft_key].hada_w1_a = tensor
+ elif kohya_type == "hada_w1_b":
+ adapter_info[model_type][peft_key].hada_w1_b = tensor
+ adapter_info[model_type][peft_key].rank = tensor.shape[0]
+ elif kohya_type == "hada_w2_a":
+ adapter_info[model_type][peft_key].hada_w2_a = tensor
+ elif kohya_type == "hada_w2_b":
+ adapter_info[model_type][peft_key].hada_w2_b = tensor
+ adapter_info[model_type][peft_key].rank = tensor.shape[0]
+ elif kohya_type in {"hada_t1", "hada_t2"}:
+ if args.loha_conv2d_weights_fix:
+ if kohya_type == "hada_t1":
+ # This code block fixes a bug that exists for some LoHa checkpoints
+ # that resulted in accidentally using hada_t1 weight instead of hada_t2, see
+ # https://github.com/KohakuBlueleaf/LyCORIS/pull/115
+ adapter_info[model_type][peft_key].hada_t1 = tensor
+ adapter_info[model_type][peft_key].hada_t2 = tensor
+ adapter_info[model_type][peft_key].rank = tensor.shape[0]
+ else:
+ if kohya_type == "hada_t1":
+ adapter_info[model_type][peft_key].hada_t1 = tensor
+ adapter_info[model_type][peft_key].rank = tensor.shape[0]
+ elif kohya_type == "hada_t2":
+ adapter_info[model_type][peft_key].hada_t2 = tensor
+ adapter_info[model_type][peft_key].rank = tensor.shape[0]
+ elif kohya_type == "lokr_t2":
+ adapter_info[model_type][peft_key].lokr_t2 = tensor
+ adapter_info[model_type][peft_key].rank = tensor.shape[0]
+ elif kohya_type == "lokr_w1":
+ adapter_info[model_type][peft_key].lokr_w1 = tensor
+ if isinstance(layer, nn.Linear) or (
+ isinstance(layer, nn.Conv2d) and tuple(layer.weight.shape[2:]) == (1, 1)
+ ):
+ adapter_info[model_type][peft_key].rank = rank
+ elif isinstance(layer, nn.Conv2d):
+ adapter_info[model_type][peft_key].rank = conv_rank
+ elif kohya_type == "lokr_w2":
+ adapter_info[model_type][peft_key].lokr_w2 = tensor
+ if isinstance(layer, nn.Linear) or (
+ isinstance(layer, nn.Conv2d) and tuple(layer.weight.shape[2:]) == (1, 1)
+ ):
+ adapter_info[model_type][peft_key].rank = rank
+ elif isinstance(layer, nn.Conv2d):
+ adapter_info[model_type][peft_key].rank = conv_rank
+ elif kohya_type == "lokr_w1_a":
+ adapter_info[model_type][peft_key].lokr_w1_a = tensor
+ adapter_info[model_type][peft_key].rank = tensor.shape[1]
+ elif kohya_type == "lokr_w1_b":
+ adapter_info[model_type][peft_key].lokr_w1_b = tensor
+ adapter_info[model_type][peft_key].rank = tensor.shape[0]
+ elif kohya_type == "lokr_w2_a":
+ adapter_info[model_type][peft_key].lokr_w2_a = tensor
+ elif kohya_type == "lokr_w2_b":
+ adapter_info[model_type][peft_key].lokr_w2_b = tensor
+ else:
+ raise ValueError(f"Unknown weight name in key: {key} - {kohya_type}")
+
+ # Get function which will create adapter config based on extracted info
+ construct_config_fn = {
+ PeftType.LORA: construct_peft_loraconfig,
+ PeftType.LOHA: construct_peft_lohaconfig,
+ PeftType.LOKR: construct_peft_lokrconfig,
+ }[adapter_type]
+
+ # Process each model sequentially
+ for model, model_name in [(text_encoder, "text_encoder"), (unet, "unet")]:
+ # Skip model if no data was provided
+ if len(adapter_info[model_name]) == 0:
+ continue
+
+ config = construct_config_fn(adapter_info[model_name], decompose_factor=decompose_factor)
+
+ # Output warning for LoHa with use_effective_conv2d
+ if (
+ isinstance(config, LoHaConfig)
+ and getattr(config, "use_effective_conv2d", False)
+ and args.loha_conv2d_weights_fix is False
+ ):
+ logger.warning(
+ 'lycoris-lora<=1.9.0 LoHa implementation contains a bug, which can be fixed with "--loha_conv2d_weights_fix".\n'
+ "For more info, please refer to https://github.com/huggingface/peft/pull/1021 and https://github.com/KohakuBlueleaf/LyCORIS/pull/115"
+ )
+
+ model = get_peft_model(model, config)
+ missing_keys, unexpected_keys = set_peft_model_state_dict(
+ model, combine_peft_state_dict(adapter_info[model_name])
+ )
+ if len(unexpected_keys) > 0:
+ raise ValueError(f"Unexpected keys {unexpected_keys} found during conversion")
+
+ if args.half:
+ model.to(torch.float16)
+
+ # Save model to disk
+ model.save_pretrained(os.path.join(args.dump_path, model_name))
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/stable_diffusion/inc_flux_lora_hpu.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/stable_diffusion/inc_flux_lora_hpu.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c0b24928100c3756a3c7148a740dfeb48cbe9f2
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/stable_diffusion/inc_flux_lora_hpu.py
@@ -0,0 +1,67 @@
+"""
+This exampe demonstrates loading of LoRA adapter (via PEFT) into an FP8 INC-quantized FLUX model.
+
+More info on Intel Neural Compressor (INC) FP8 quantization is available at:
+https://github.com/intel/neural-compressor/tree/master/examples/helloworld/fp8_example
+
+Requirements:
+pip install optimum-habana sentencepiece neural-compressor[pt] peft
+"""
+
+import importlib
+
+import torch
+from neural_compressor.torch.quantization import FP8Config, convert, finalize_calibration, prepare
+
+
+# Checks if HPU device is available
+# Adapted from https://github.com/huggingface/accelerate/blob/b451956fd69a135efc283aadaa478f0d33fcbe6a/src/accelerate/utils/imports.py#L435
+def is_hpu_available():
+ if (
+ importlib.util.find_spec("habana_frameworks") is None
+ or importlib.util.find_spec("habana_frameworks.torch") is None
+ ):
+ return False
+
+ import habana_frameworks.torch # noqa: F401
+
+ return hasattr(torch, "hpu") and torch.hpu.is_available()
+
+
+# Ensure HPU device is available before proceeding
+if is_hpu_available():
+ from optimum.habana.diffusers import GaudiFluxPipeline
+else:
+ raise RuntimeError("HPU device not found. This code requires Intel Gaudi device to run.")
+
+# Example: FLUX model inference on HPU via optimum-habana pipeline
+hpu_configs = {
+ "use_habana": True,
+ "use_hpu_graphs": True,
+ "sdp_on_bf16": True,
+ "gaudi_config": "Habana/stable-diffusion",
+}
+pipe = GaudiFluxPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", torch_dtype=torch.bfloat16, **hpu_configs)
+prompt = "A picture of sks dog in a bucket"
+
+# Quantize FLUX transformer to FP8 using INC (Intel Neural Compressor)
+quant_configs = {
+ "mode": "AUTO",
+ "observer": "maxabs",
+ "scale_method": "maxabs_hw",
+ "allowlist": {"types": [], "names": []},
+ "blocklist": {"types": [], "names": []},
+ "dump_stats_path": "/tmp/hqt_output/measure",
+}
+config = FP8Config(**quant_configs)
+pipe.transformer = prepare(pipe.transformer, config)
+pipe(prompt)
+finalize_calibration(pipe.transformer)
+pipe.transformer = convert(pipe.transformer)
+
+# Load LoRA weights with PEFT
+pipe.load_lora_weights("dsocek/lora-flux-dog", adapter_name="user_lora")
+
+# Run inference
+image = pipe(prompt).images[0]
+image.save("dog.png")
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/stable_diffusion/train_dreambooth.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/stable_diffusion/train_dreambooth.py
new file mode 100644
index 0000000000000000000000000000000000000000..2008ceeea0228b6ce77db04dea199998f5586ec7
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/stable_diffusion/train_dreambooth.py
@@ -0,0 +1,1275 @@
+import argparse
+import gc
+import hashlib
+import itertools
+import logging
+import math
+import os
+import threading
+import warnings
+from pathlib import Path
+from typing import Union
+
+import datasets
+import diffusers
+import numpy as np
+import psutil
+import torch
+import torch.nn.functional as F
+import torch.utils.checkpoint
+import transformers
+from accelerate import Accelerator
+from accelerate.logging import get_logger
+from accelerate.utils import set_seed
+from diffusers import (
+ AutoencoderKL,
+ DDPMScheduler,
+ DiffusionPipeline,
+ DPMSolverMultistepScheduler,
+ UNet2DConditionModel,
+)
+from diffusers.optimization import get_scheduler
+from diffusers.utils import check_min_version
+from diffusers.utils.import_utils import is_xformers_available
+from huggingface_hub import HfApi
+from PIL import Image
+from torch.utils.data import Dataset
+from torchvision import transforms
+from tqdm.auto import tqdm
+from transformers import AutoTokenizer, PretrainedConfig
+
+from peft import LoHaConfig, LoKrConfig, LoraConfig, get_peft_model
+
+
+# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
+check_min_version("0.10.0.dev0")
+
+logger = get_logger(__name__)
+
+UNET_TARGET_MODULES = [
+ "to_q",
+ "to_k",
+ "to_v",
+ "proj",
+ "proj_in",
+ "proj_out",
+ "conv",
+ "conv1",
+ "conv2",
+ "conv_shortcut",
+ "to_out.0",
+ "time_emb_proj",
+ "ff.net.2",
+]
+
+TEXT_ENCODER_TARGET_MODULES = ["fc1", "fc2", "q_proj", "k_proj", "v_proj", "out_proj"]
+
+
+def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str):
+ text_encoder_config = PretrainedConfig.from_pretrained(
+ pretrained_model_name_or_path,
+ subfolder="text_encoder",
+ revision=revision,
+ )
+ model_class = text_encoder_config.architectures[0]
+
+ if model_class == "CLIPTextModel":
+ from transformers import CLIPTextModel
+
+ return CLIPTextModel
+ elif model_class == "RobertaSeriesModelWithTransformation":
+ from diffusers.pipelines.alt_diffusion.modeling_roberta_series import RobertaSeriesModelWithTransformation
+
+ return RobertaSeriesModelWithTransformation
+ else:
+ raise ValueError(f"{model_class} is not supported.")
+
+
+def create_unet_adapter_config(args: argparse.Namespace) -> Union[LoraConfig, LoHaConfig, LoKrConfig]:
+ if args.adapter == "full":
+ raise ValueError("Cannot create unet adapter config for full parameter")
+
+ if args.adapter == "lora":
+ config = LoraConfig(
+ r=args.unet_r,
+ lora_alpha=args.unet_alpha,
+ target_modules=UNET_TARGET_MODULES,
+ lora_dropout=args.unet_dropout,
+ bias=args.unet_bias,
+ init_lora_weights=True,
+ )
+ elif args.adapter == "loha":
+ config = LoHaConfig(
+ r=args.unet_r,
+ alpha=args.unet_alpha,
+ target_modules=UNET_TARGET_MODULES,
+ rank_dropout=args.unet_rank_dropout,
+ module_dropout=args.unet_module_dropout,
+ use_effective_conv2d=args.unet_use_effective_conv2d,
+ init_weights=True,
+ )
+ elif args.adapter == "lokr":
+ config = LoKrConfig(
+ r=args.unet_r,
+ alpha=args.unet_alpha,
+ target_modules=UNET_TARGET_MODULES,
+ rank_dropout=args.unet_rank_dropout,
+ module_dropout=args.unet_module_dropout,
+ use_effective_conv2d=args.unet_use_effective_conv2d,
+ decompose_both=args.unet_decompose_both,
+ decompose_factor=args.unet_decompose_factor,
+ init_weights=True,
+ )
+ else:
+ raise ValueError(f"Unknown adapter type {args.adapter}")
+
+ return config
+
+
+def create_text_encoder_adapter_config(args: argparse.Namespace) -> Union[LoraConfig, LoHaConfig, LoKrConfig]:
+ if args.adapter == "full":
+ raise ValueError("Cannot create text_encoder adapter config for full parameter")
+
+ if args.adapter == "lora":
+ config = LoraConfig(
+ r=args.te_r,
+ lora_alpha=args.te_alpha,
+ target_modules=TEXT_ENCODER_TARGET_MODULES,
+ lora_dropout=args.te_dropout,
+ bias=args.te_bias,
+ init_lora_weights=True,
+ )
+ elif args.adapter == "loha":
+ config = LoHaConfig(
+ r=args.te_r,
+ alpha=args.te_alpha,
+ target_modules=TEXT_ENCODER_TARGET_MODULES,
+ rank_dropout=args.te_rank_dropout,
+ module_dropout=args.te_module_dropout,
+ init_weights=True,
+ )
+ elif args.adapter == "lokr":
+ config = LoKrConfig(
+ r=args.te_r,
+ alpha=args.te_alpha,
+ target_modules=TEXT_ENCODER_TARGET_MODULES,
+ rank_dropout=args.te_rank_dropout,
+ module_dropout=args.te_module_dropout,
+ decompose_both=args.te_decompose_both,
+ decompose_factor=args.te_decompose_factor,
+ init_weights=True,
+ )
+ else:
+ raise ValueError(f"Unknown adapter type {args.adapter}")
+
+ return config
+
+
+def parse_args(input_args=None):
+ parser = argparse.ArgumentParser(description="Simple example of a training script.")
+ parser.add_argument(
+ "--pretrained_model_name_or_path",
+ type=str,
+ default=None,
+ required=True,
+ help="Path to pretrained model or model identifier from huggingface.co/models.",
+ )
+ parser.add_argument(
+ "--revision",
+ type=str,
+ default=None,
+ required=False,
+ help="Revision of pretrained model identifier from huggingface.co/models.",
+ )
+ parser.add_argument(
+ "--tokenizer_name",
+ type=str,
+ default=None,
+ help="Pretrained tokenizer name or path if not the same as model_name",
+ )
+ parser.add_argument(
+ "--instance_data_dir",
+ type=str,
+ default=None,
+ required=True,
+ help="A folder containing the training data of instance images.",
+ )
+ parser.add_argument(
+ "--class_data_dir",
+ type=str,
+ default=None,
+ required=False,
+ help="A folder containing the training data of class images.",
+ )
+ parser.add_argument(
+ "--instance_prompt",
+ type=str,
+ default=None,
+ required=True,
+ help="The prompt with identifier specifying the instance",
+ )
+ parser.add_argument(
+ "--class_prompt",
+ type=str,
+ default=None,
+ help="The prompt to specify images in the same class as provided instance images.",
+ )
+ parser.add_argument(
+ "--with_prior_preservation",
+ default=False,
+ action="store_true",
+ help="Flag to add prior preservation loss.",
+ )
+ parser.add_argument("--prior_loss_weight", type=float, default=1.0, help="The weight of prior preservation loss.")
+ parser.add_argument(
+ "--num_class_images",
+ type=int,
+ default=100,
+ help=(
+ "Minimal class images for prior preservation loss. If there are not enough images already present in"
+ " class_data_dir, additional images will be sampled with class_prompt."
+ ),
+ )
+ parser.add_argument(
+ "--validation_prompt",
+ type=str,
+ default=None,
+ help="A prompt that is used during validation to verify that the model is learning.",
+ )
+ parser.add_argument(
+ "--num_validation_images",
+ type=int,
+ default=4,
+ help="Number of images that should be generated during validation with `validation_prompt`.",
+ )
+ parser.add_argument(
+ "--validation_steps",
+ type=int,
+ default=100,
+ help=(
+ "Run dreambooth validation every X steps. Dreambooth validation consists of running the prompt"
+ " `args.validation_prompt` multiple times: `args.num_validation_images`."
+ ),
+ )
+ parser.add_argument(
+ "--output_dir",
+ type=str,
+ default="text-inversion-model",
+ help="The output directory where the model predictions and checkpoints will be written.",
+ )
+ parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.")
+ parser.add_argument(
+ "--resolution",
+ type=int,
+ default=512,
+ help=(
+ "The resolution for input images, all the images in the train/validation dataset will be resized to this"
+ " resolution"
+ ),
+ )
+ parser.add_argument(
+ "--center_crop", action="store_true", help="Whether to center crop images before resizing to resolution"
+ )
+ parser.add_argument("--train_text_encoder", action="store_true", help="Whether to train the text encoder")
+
+ parser.add_argument(
+ "--train_batch_size", type=int, default=4, help="Batch size (per device) for the training dataloader."
+ )
+ parser.add_argument(
+ "--sample_batch_size", type=int, default=4, help="Batch size (per device) for sampling images."
+ )
+ parser.add_argument("--num_train_epochs", type=int, default=1)
+ parser.add_argument(
+ "--max_train_steps",
+ type=int,
+ default=None,
+ help="Total number of training steps to perform. If provided, overrides num_train_epochs.",
+ )
+ parser.add_argument(
+ "--checkpointing_steps",
+ type=int,
+ default=500,
+ help=(
+ "Save a checkpoint of the training state every X updates. These checkpoints can be used both as final"
+ " checkpoints in case they are better than the last checkpoint, and are also suitable for resuming"
+ " training using `--resume_from_checkpoint`."
+ ),
+ )
+ parser.add_argument(
+ "--resume_from_checkpoint",
+ type=str,
+ default=None,
+ help=(
+ "Whether training should be resumed from a previous checkpoint. Use a path saved by"
+ ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.'
+ ),
+ )
+ parser.add_argument(
+ "--gradient_accumulation_steps",
+ type=int,
+ default=1,
+ help="Number of updates steps to accumulate before performing a backward/update pass.",
+ )
+ parser.add_argument(
+ "--gradient_checkpointing",
+ action="store_true",
+ help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.",
+ )
+ parser.add_argument(
+ "--learning_rate",
+ type=float,
+ default=5e-6,
+ help="Initial learning rate (after the potential warmup period) to use.",
+ )
+ parser.add_argument(
+ "--scale_lr",
+ action="store_true",
+ default=False,
+ help="Scale the learning rate by the number of accelerators, gradient accumulation steps, and batch size.",
+ )
+ parser.add_argument(
+ "--lr_scheduler",
+ type=str,
+ default="constant",
+ help=(
+ 'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
+ ' "constant", "constant_with_warmup"]'
+ ),
+ )
+ parser.add_argument(
+ "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler."
+ )
+ parser.add_argument(
+ "--lr_num_cycles",
+ type=int,
+ default=1,
+ help="Number of hard resets of the lr in cosine_with_restarts scheduler.",
+ )
+ parser.add_argument("--lr_power", type=float, default=1.0, help="Power factor of the polynomial scheduler.")
+ parser.add_argument(
+ "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes."
+ )
+ parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.")
+ parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.")
+ parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.")
+ parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer")
+ parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.")
+ parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.")
+ parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.")
+ parser.add_argument(
+ "--hub_model_id",
+ type=str,
+ default=None,
+ help="The name of the repository to keep in sync with the local `output_dir`.",
+ )
+ parser.add_argument(
+ "--logging_dir",
+ type=str,
+ default="logs",
+ help=(
+ "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to"
+ " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***."
+ ),
+ )
+ parser.add_argument(
+ "--allow_tf32",
+ action="store_true",
+ help=(
+ "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see"
+ " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices"
+ ),
+ )
+ parser.add_argument(
+ "--report_to",
+ type=str,
+ default="tensorboard",
+ help=(
+ 'The integration to report the results and logs to. Supported platforms are `"tensorboard"`'
+ ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.'
+ ),
+ )
+ parser.add_argument(
+ "--wandb_key",
+ type=str,
+ default=None,
+ help=("If report to option is set to wandb, api-key for wandb used for login to wandb "),
+ )
+ parser.add_argument(
+ "--wandb_project_name",
+ type=str,
+ default=None,
+ help=("If report to option is set to wandb, project name in wandb for log tracking "),
+ )
+ parser.add_argument(
+ "--mixed_precision",
+ type=str,
+ default=None,
+ choices=["no", "fp16", "bf16"],
+ help=(
+ "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+ " 1.10. and an Nvidia Ampere GPU or Intel XPU. Default to the value of accelerate config of the current system or the"
+ " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config."
+ ),
+ )
+ parser.add_argument(
+ "--prior_generation_precision",
+ type=str,
+ default=None,
+ choices=["no", "fp32", "fp16", "bf16"],
+ help=(
+ "Choose prior generation precision between fp32, fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+ " 1.10. and an Nvidia Ampere GPU or Intel XPU. Default to fp16 if an accelerator is available else fp32."
+ ),
+ )
+ parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank")
+ parser.add_argument(
+ "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers."
+ )
+
+ # Adapter arguments
+ subparsers = parser.add_subparsers(dest="adapter")
+
+ # Dummy subparser to train whole model
+ subparsers.add_parser("full", help="Train full model without adapters")
+
+ # LoRA adapter
+ lora = subparsers.add_parser("lora", help="Use LoRA adapter")
+ lora.add_argument("--unet_r", type=int, default=8, help="LoRA rank for unet")
+ lora.add_argument("--unet_alpha", type=int, default=8, help="LoRA alpha for unet")
+ lora.add_argument("--unet_dropout", type=float, default=0.0, help="LoRA dropout probability for unet")
+ lora.add_argument(
+ "--unet_bias",
+ type=str,
+ default="none",
+ help="Bias type for LoRA. Can be 'none', 'all' or 'lora_only'",
+ )
+ lora.add_argument(
+ "--te_r", type=int, default=8, help="LoRA rank for text_encoder, only used if `train_text_encoder` is True"
+ )
+ lora.add_argument(
+ "--te_alpha",
+ type=int,
+ default=8,
+ help="LoRA alpha for text_encoder, only used if `train_text_encoder` is True",
+ )
+ lora.add_argument(
+ "--te_dropout",
+ type=float,
+ default=0.0,
+ help="LoRA dropout probability for text_encoder, only used if `train_text_encoder` is True",
+ )
+ lora.add_argument(
+ "--te_bias",
+ type=str,
+ default="none",
+ help="Bias type for LoRA. Can be 'none', 'all' or 'lora_only', only used if `train_text_encoder` is True",
+ )
+
+ # LoHa adapter
+ loha = subparsers.add_parser("loha", help="Use LoHa adapter")
+ loha.add_argument("--unet_r", type=int, default=8, help="LoHa rank for unet")
+ loha.add_argument("--unet_alpha", type=int, default=8, help="LoHa alpha for unet")
+ loha.add_argument("--unet_rank_dropout", type=float, default=0.0, help="LoHa rank_dropout probability for unet")
+ loha.add_argument(
+ "--unet_module_dropout", type=float, default=0.0, help="LoHa module_dropout probability for unet"
+ )
+ loha.add_argument(
+ "--unet_use_effective_conv2d",
+ action="store_true",
+ help="Use parameter effective decomposition in unet for Conv2d 3x3 with ksize > 1",
+ )
+ loha.add_argument(
+ "--te_r", type=int, default=8, help="LoHa rank for text_encoder, only used if `train_text_encoder` is True"
+ )
+ loha.add_argument(
+ "--te_alpha",
+ type=int,
+ default=8,
+ help="LoHa alpha for text_encoder, only used if `train_text_encoder` is True",
+ )
+ loha.add_argument(
+ "--te_rank_dropout",
+ type=float,
+ default=0.0,
+ help="LoHa rank_dropout probability for text_encoder, only used if `train_text_encoder` is True",
+ )
+ loha.add_argument(
+ "--te_module_dropout",
+ type=float,
+ default=0.0,
+ help="LoHa module_dropout probability for text_encoder, only used if `train_text_encoder` is True",
+ )
+
+ # LoKr adapter
+ lokr = subparsers.add_parser("lokr", help="Use LoKr adapter")
+ lokr.add_argument("--unet_r", type=int, default=8, help="LoKr rank for unet")
+ lokr.add_argument("--unet_alpha", type=int, default=8, help="LoKr alpha for unet")
+ lokr.add_argument("--unet_rank_dropout", type=float, default=0.0, help="LoKr rank_dropout probability for unet")
+ lokr.add_argument(
+ "--unet_module_dropout", type=float, default=0.0, help="LoKr module_dropout probability for unet"
+ )
+ lokr.add_argument(
+ "--unet_use_effective_conv2d",
+ action="store_true",
+ help="Use parameter effective decomposition in unet for Conv2d 3x3 with ksize > 1",
+ )
+ lokr.add_argument(
+ "--unet_decompose_both", action="store_true", help="Decompose left matrix in kronecker product for unet"
+ )
+ lokr.add_argument(
+ "--unet_decompose_factor", type=int, default=-1, help="Decompose factor in kronecker product for unet"
+ )
+ lokr.add_argument(
+ "--te_r", type=int, default=8, help="LoKr rank for text_encoder, only used if `train_text_encoder` is True"
+ )
+ lokr.add_argument(
+ "--te_alpha",
+ type=int,
+ default=8,
+ help="LoKr alpha for text_encoder, only used if `train_text_encoder` is True",
+ )
+ lokr.add_argument(
+ "--te_rank_dropout",
+ type=float,
+ default=0.0,
+ help="LoKr rank_dropout probability for text_encoder, only used if `train_text_encoder` is True",
+ )
+ lokr.add_argument(
+ "--te_module_dropout",
+ type=float,
+ default=0.0,
+ help="LoKr module_dropout probability for text_encoder, only used if `train_text_encoder` is True",
+ )
+ lokr.add_argument(
+ "--te_decompose_both",
+ action="store_true",
+ help="Decompose left matrix in kronecker product for text_encoder, only used if `train_text_encoder` is True",
+ )
+ lokr.add_argument(
+ "--te_decompose_factor",
+ type=int,
+ default=-1,
+ help="Decompose factor in kronecker product for text_encoder, only used if `train_text_encoder` is True",
+ )
+
+ if input_args is not None:
+ args = parser.parse_args(input_args)
+ else:
+ args = parser.parse_args()
+
+ env_local_rank = int(os.environ.get("LOCAL_RANK", "-1"))
+ if env_local_rank != -1 and env_local_rank != args.local_rank:
+ args.local_rank = env_local_rank
+
+ if args.with_prior_preservation:
+ if args.class_data_dir is None:
+ raise ValueError("You must specify a data directory for class images.")
+ if args.class_prompt is None:
+ raise ValueError("You must specify prompt for class images.")
+ else:
+ # logger is not available yet
+ if args.class_data_dir is not None:
+ warnings.warn("You need not use --class_data_dir without --with_prior_preservation.")
+ if args.class_prompt is not None:
+ warnings.warn("You need not use --class_prompt without --with_prior_preservation.")
+
+ return args
+
+
+# Converting Bytes to Megabytes
+def b2mb(x):
+ return int(x / 2**20)
+
+
+# This context manager is used to track the peak memory usage of the process
+class TorchTracemalloc:
+ def __enter__(self):
+ gc.collect()
+ self.device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+ self.device_module = getattr(torch, self.device_type, torch.cuda)
+ self.device_module.empty_cache()
+ self.device_module.reset_peak_memory_stats() # reset the peak gauge to zero
+ self.begin = self.device_module.memory_allocated()
+ self.process = psutil.Process()
+
+ self.cpu_begin = self.cpu_mem_used()
+ self.peak_monitoring = True
+ peak_monitor_thread = threading.Thread(target=self.peak_monitor_func)
+ peak_monitor_thread.daemon = True
+ peak_monitor_thread.start()
+ return self
+
+ def cpu_mem_used(self):
+ """get resident set size memory for the current process"""
+ return self.process.memory_info().rss
+
+ def peak_monitor_func(self):
+ self.cpu_peak = -1
+
+ while True:
+ self.cpu_peak = max(self.cpu_mem_used(), self.cpu_peak)
+
+ # can't sleep or will not catch the peak right (this comment is here on purpose)
+ # time.sleep(0.001) # 1msec
+
+ if not self.peak_monitoring:
+ break
+
+ def __exit__(self, *exc):
+ self.peak_monitoring = False
+
+ gc.collect()
+ self.device_module.empty_cache()
+ self.end = self.device_module.memory_allocated()
+ self.peak = self.device_module.max_memory_allocated()
+ self.used = b2mb(self.end - self.begin)
+ self.peaked = b2mb(self.peak - self.begin)
+
+ self.cpu_end = self.cpu_mem_used()
+ self.cpu_used = b2mb(self.cpu_end - self.cpu_begin)
+ self.cpu_peaked = b2mb(self.cpu_peak - self.cpu_begin)
+ # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")
+
+
+class DreamBoothDataset(Dataset):
+ """
+ A dataset to prepare the instance and class images with the prompts for fine-tuning the model.
+ It pre-processes the images and the tokenizes prompts.
+ """
+
+ def __init__(
+ self,
+ instance_data_root,
+ instance_prompt,
+ tokenizer,
+ class_data_root=None,
+ class_prompt=None,
+ size=512,
+ center_crop=False,
+ ):
+ self.size = size
+ self.center_crop = center_crop
+ self.tokenizer = tokenizer
+
+ self.instance_data_root = Path(instance_data_root)
+ if not self.instance_data_root.exists():
+ raise ValueError("Instance images root doesn't exists.")
+
+ self.instance_images_path = list(Path(instance_data_root).iterdir())
+ self.num_instance_images = len(self.instance_images_path)
+ self.instance_prompt = instance_prompt
+ self._length = self.num_instance_images
+
+ if class_data_root is not None:
+ self.class_data_root = Path(class_data_root)
+ self.class_data_root.mkdir(parents=True, exist_ok=True)
+ self.class_images_path = list(self.class_data_root.iterdir())
+ self.num_class_images = len(self.class_images_path)
+ self._length = max(self.num_class_images, self.num_instance_images)
+ self.class_prompt = class_prompt
+ else:
+ self.class_data_root = None
+
+ self.image_transforms = transforms.Compose(
+ [
+ transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR),
+ transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size),
+ transforms.ToTensor(),
+ transforms.Normalize([0.5], [0.5]),
+ ]
+ )
+
+ def __len__(self):
+ return self._length
+
+ def __getitem__(self, index):
+ example = {}
+ instance_image = Image.open(self.instance_images_path[index % self.num_instance_images])
+ if instance_image.mode != "RGB":
+ instance_image = instance_image.convert("RGB")
+ example["instance_images"] = self.image_transforms(instance_image)
+ example["instance_prompt_ids"] = self.tokenizer(
+ self.instance_prompt,
+ truncation=True,
+ padding="max_length",
+ max_length=self.tokenizer.model_max_length,
+ return_tensors="pt",
+ ).input_ids
+
+ if self.class_data_root:
+ class_image = Image.open(self.class_images_path[index % self.num_class_images])
+ if class_image.mode != "RGB":
+ class_image = class_image.convert("RGB")
+ example["class_images"] = self.image_transforms(class_image)
+ example["class_prompt_ids"] = self.tokenizer(
+ self.class_prompt,
+ truncation=True,
+ padding="max_length",
+ max_length=self.tokenizer.model_max_length,
+ return_tensors="pt",
+ ).input_ids
+
+ return example
+
+
+def collate_fn(examples, with_prior_preservation=False):
+ input_ids = [example["instance_prompt_ids"] for example in examples]
+ pixel_values = [example["instance_images"] for example in examples]
+
+ # Concat class and instance examples for prior preservation.
+ # We do this to avoid doing two forward passes.
+ if with_prior_preservation:
+ input_ids += [example["class_prompt_ids"] for example in examples]
+ pixel_values += [example["class_images"] for example in examples]
+
+ pixel_values = torch.stack(pixel_values)
+ pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float()
+
+ input_ids = torch.cat(input_ids, dim=0)
+
+ batch = {
+ "input_ids": input_ids,
+ "pixel_values": pixel_values,
+ }
+ return batch
+
+
+class PromptDataset(Dataset):
+ "A simple dataset to prepare the prompts to generate class images on multiple accelerators."
+
+ def __init__(self, prompt, num_samples):
+ self.prompt = prompt
+ self.num_samples = num_samples
+
+ def __len__(self):
+ return self.num_samples
+
+ def __getitem__(self, index):
+ example = {}
+ example["prompt"] = self.prompt
+ example["index"] = index
+ return example
+
+
+def main(args):
+ logging_dir = Path(args.output_dir, args.logging_dir)
+
+ accelerator = Accelerator(
+ gradient_accumulation_steps=args.gradient_accumulation_steps,
+ mixed_precision=args.mixed_precision,
+ log_with=args.report_to,
+ project_dir=logging_dir,
+ )
+ if args.report_to == "wandb":
+ import wandb
+
+ wandb.login(key=args.wandb_key)
+ wandb.init(project=args.wandb_project_name)
+ # Currently, it's not possible to do gradient accumulation when training two models with accelerate.accumulate
+ # This will be enabled soon in accelerate. For now, we don't allow gradient accumulation when training two models.
+ # TODO (patil-suraj): Remove this check when gradient accumulation with two models is enabled in accelerate.
+ if args.train_text_encoder and args.gradient_accumulation_steps > 1 and accelerator.num_processes > 1:
+ raise ValueError(
+ "Gradient accumulation is not supported when training the text encoder in distributed training. "
+ "Please set gradient_accumulation_steps to 1. This feature will be supported in the future."
+ )
+
+ # Make one log on every process with the configuration for debugging.
+ logging.basicConfig(
+ format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+ datefmt="%m/%d/%Y %H:%M:%S",
+ level=logging.INFO,
+ )
+ logger.info(accelerator.state, main_process_only=False)
+ if accelerator.is_local_main_process:
+ datasets.utils.logging.set_verbosity_warning()
+ transformers.utils.logging.set_verbosity_warning()
+ diffusers.utils.logging.set_verbosity_info()
+ else:
+ datasets.utils.logging.set_verbosity_error()
+ transformers.utils.logging.set_verbosity_error()
+ diffusers.utils.logging.set_verbosity_error()
+
+ # If passed along, set the training seed now.
+ if args.seed is not None:
+ set_seed(args.seed)
+
+ # Generate class images if prior preservation is enabled.
+ if args.with_prior_preservation:
+ class_images_dir = Path(args.class_data_dir)
+ if not class_images_dir.exists():
+ class_images_dir.mkdir(parents=True)
+ cur_class_images = len(list(class_images_dir.iterdir()))
+
+ if cur_class_images < args.num_class_images:
+ dtype = torch.float16 if accelerator.device.type in ["cuda", "xpu"] else torch.float32
+ if args.prior_generation_precision == "fp32":
+ dtype = torch.float32
+ elif args.prior_generation_precision == "fp16":
+ dtype = torch.float16
+ elif args.prior_generation_precision == "bf16":
+ dtype = torch.bfloat16
+ pipeline = DiffusionPipeline.from_pretrained(
+ args.pretrained_model_name_or_path,
+ dtype=dtype,
+ safety_checker=None,
+ revision=args.revision,
+ )
+ pipeline.set_progress_bar_config(disable=True)
+
+ num_new_images = args.num_class_images - cur_class_images
+ logger.info(f"Number of class images to sample: {num_new_images}.")
+
+ sample_dataset = PromptDataset(args.class_prompt, num_new_images)
+ sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size)
+
+ sample_dataloader = accelerator.prepare(sample_dataloader)
+ pipeline.to(accelerator.device)
+
+ for example in tqdm(
+ sample_dataloader, desc="Generating class images", disable=not accelerator.is_local_main_process
+ ):
+ images = pipeline(example["prompt"]).images
+
+ for i, image in enumerate(images):
+ hash_image = hashlib.sha1(image.tobytes()).hexdigest()
+ image_filename = class_images_dir / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg"
+ image.save(image_filename)
+
+ del pipeline
+
+ if torch.cuda.is_available():
+ torch.cuda.empty_cache()
+ elif torch.xpu.is_available():
+ torch.xpu.empty_cache()
+
+ # Handle the repository creation
+ if accelerator.is_main_process:
+ if args.push_to_hub:
+ api = HfApi(token=args.hub_token)
+
+ # Create repo (repo_name from args or inferred)
+ repo_name = args.hub_model_id
+ if repo_name is None:
+ repo_name = Path(args.output_dir).absolute().name
+ repo_id = api.create_repo(repo_name, exist_ok=True).repo_id
+
+ with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore:
+ if "step_*" not in gitignore:
+ gitignore.write("step_*\n")
+ if "epoch_*" not in gitignore:
+ gitignore.write("epoch_*\n")
+ elif args.output_dir is not None:
+ os.makedirs(args.output_dir, exist_ok=True)
+
+ # Load the tokenizer
+ if args.tokenizer_name:
+ tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False)
+ elif args.pretrained_model_name_or_path:
+ tokenizer = AutoTokenizer.from_pretrained(
+ args.pretrained_model_name_or_path,
+ subfolder="tokenizer",
+ revision=args.revision,
+ use_fast=False,
+ )
+
+ # import correct text encoder class
+ text_encoder_cls = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision)
+
+ # Load scheduler and models
+ noise_scheduler = DDPMScheduler(
+ beta_start=0.00085,
+ beta_end=0.012,
+ beta_schedule="scaled_linear",
+ num_train_timesteps=1000,
+ ) # DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler")
+ text_encoder = text_encoder_cls.from_pretrained(
+ args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision
+ )
+ vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision)
+ unet = UNet2DConditionModel.from_pretrained(
+ args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision
+ )
+
+ if args.adapter != "full":
+ config = create_unet_adapter_config(args)
+ unet = get_peft_model(unet, config)
+ unet.print_trainable_parameters()
+ print(unet)
+
+ vae.requires_grad_(False)
+ if not args.train_text_encoder:
+ text_encoder.requires_grad_(False)
+ elif args.train_text_encoder and args.adapter != "full":
+ config = create_text_encoder_adapter_config(args)
+ text_encoder = get_peft_model(text_encoder, config)
+ text_encoder.print_trainable_parameters()
+ print(text_encoder)
+
+ if args.enable_xformers_memory_efficient_attention:
+ if accelerator.device.type == "xpu":
+ logger.warning("XPU hasn't support xformers yet, ignore it.")
+ elif is_xformers_available():
+ unet.enable_xformers_memory_efficient_attention()
+ else:
+ raise ValueError("xformers is not available. Make sure it is installed correctly")
+
+ if args.gradient_checkpointing:
+ unet.enable_gradient_checkpointing()
+ if args.train_text_encoder and args.adapter == "full":
+ text_encoder.gradient_checkpointing_enable()
+
+ # Enable TF32 for faster training on Ampere GPUs,
+ # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices
+ if args.allow_tf32 and torch.cuda.is_available():
+ torch.backends.cuda.matmul.allow_tf32 = True
+
+ if args.scale_lr:
+ args.learning_rate = (
+ args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes
+ )
+
+ # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB accelerators
+ if args.use_8bit_adam:
+ try:
+ import bitsandbytes as bnb
+ except ImportError:
+ raise ImportError(
+ "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`."
+ )
+
+ optimizer_class = bnb.optim.AdamW8bit
+ else:
+ optimizer_class = torch.optim.AdamW
+
+ # Optimizer creation
+ params_to_optimize = (
+ itertools.chain(unet.parameters(), text_encoder.parameters()) if args.train_text_encoder else unet.parameters()
+ )
+ optimizer = optimizer_class(
+ params_to_optimize,
+ lr=args.learning_rate,
+ betas=(args.adam_beta1, args.adam_beta2),
+ weight_decay=args.adam_weight_decay,
+ eps=args.adam_epsilon,
+ )
+
+ # Dataset and DataLoaders creation:
+ train_dataset = DreamBoothDataset(
+ instance_data_root=args.instance_data_dir,
+ instance_prompt=args.instance_prompt,
+ class_data_root=args.class_data_dir if args.with_prior_preservation else None,
+ class_prompt=args.class_prompt,
+ tokenizer=tokenizer,
+ size=args.resolution,
+ center_crop=args.center_crop,
+ )
+
+ train_dataloader = torch.utils.data.DataLoader(
+ train_dataset,
+ batch_size=args.train_batch_size,
+ shuffle=True,
+ collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation),
+ num_workers=1,
+ )
+
+ # Scheduler and math around the number of training steps.
+ overrode_max_train_steps = False
+ num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+ if args.max_train_steps is None:
+ args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+ overrode_max_train_steps = True
+
+ lr_scheduler = get_scheduler(
+ args.lr_scheduler,
+ optimizer=optimizer,
+ num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps,
+ num_training_steps=args.max_train_steps * args.gradient_accumulation_steps,
+ num_cycles=args.lr_num_cycles,
+ power=args.lr_power,
+ )
+
+ # Prepare everything with our `accelerator`.
+ if args.train_text_encoder:
+ unet, text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+ unet, text_encoder, optimizer, train_dataloader, lr_scheduler
+ )
+ else:
+ unet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+ unet, optimizer, train_dataloader, lr_scheduler
+ )
+
+ # For mixed precision training we cast the text_encoder and vae weights to half-precision
+ # as these models are only used for inference, keeping weights in full precision is not required.
+ weight_dtype = torch.float32
+ if accelerator.mixed_precision == "fp16":
+ weight_dtype = torch.float16
+ elif accelerator.mixed_precision == "bf16":
+ weight_dtype = torch.bfloat16
+
+ # Move vae and text_encoder to device and cast to weight_dtype
+ vae.to(accelerator.device, dtype=weight_dtype)
+ if not args.train_text_encoder:
+ text_encoder.to(accelerator.device, dtype=weight_dtype)
+
+ # We need to recalculate our total training steps as the size of the training dataloader may have changed.
+ num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+ if overrode_max_train_steps:
+ args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+ # Afterwards we recalculate our number of training epochs
+ args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
+
+ # We need to initialize the trackers we use, and also store our configuration.
+ # The trackers initializes automatically on the main process.
+ if accelerator.is_main_process:
+ accelerator.init_trackers("dreambooth", config=vars(args))
+
+ # Train!
+ total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
+
+ logger.info("***** Running training *****")
+ logger.info(f" Num examples = {len(train_dataset)}")
+ logger.info(f" Num batches each epoch = {len(train_dataloader)}")
+ logger.info(f" Num Epochs = {args.num_train_epochs}")
+ logger.info(f" Instantaneous batch size per device = {args.train_batch_size}")
+ logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
+ logger.info(f" Gradient Accumulation steps = {args.gradient_accumulation_steps}")
+ logger.info(f" Total optimization steps = {args.max_train_steps}")
+ global_step = 0
+ first_epoch = 0
+
+ # Potentially load in the weights and states from a previous save
+ if args.resume_from_checkpoint:
+ if args.resume_from_checkpoint != "latest":
+ path = os.path.basename(args.resume_from_checkpoint)
+ else:
+ # Get the mos recent checkpoint
+ dirs = os.listdir(args.output_dir)
+ dirs = [d for d in dirs if d.startswith("checkpoint")]
+ dirs = sorted(dirs, key=lambda x: int(x.split("-")[1]))
+ path = dirs[-1]
+ accelerator.print(f"Resuming from checkpoint {path}")
+ accelerator.load_state(os.path.join(args.output_dir, path))
+ global_step = int(path.split("-")[1])
+
+ resume_global_step = global_step * args.gradient_accumulation_steps
+ first_epoch = resume_global_step // num_update_steps_per_epoch
+ resume_step = resume_global_step % num_update_steps_per_epoch
+
+ # Only show the progress bar once on each machine.
+ progress_bar = tqdm(range(global_step, args.max_train_steps), disable=not accelerator.is_local_main_process)
+ progress_bar.set_description("Steps")
+
+ for epoch in range(first_epoch, args.num_train_epochs):
+ unet.train()
+ if args.train_text_encoder:
+ text_encoder.train()
+ with TorchTracemalloc() as tracemalloc:
+ for step, batch in enumerate(train_dataloader):
+ # Skip steps until we reach the resumed step
+ if args.resume_from_checkpoint and epoch == first_epoch and step < resume_step:
+ if step % args.gradient_accumulation_steps == 0:
+ progress_bar.update(1)
+ if args.report_to == "wandb":
+ accelerator.print(progress_bar)
+ continue
+
+ with accelerator.accumulate(unet):
+ # Convert images to latent space
+ latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample()
+ latents = latents * 0.18215
+
+ # Sample noise that we'll add to the latents
+ noise = torch.randn_like(latents)
+ bsz = latents.shape[0]
+ # Sample a random timestep for each image
+ timesteps = torch.randint(
+ 0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device
+ )
+ timesteps = timesteps.long()
+
+ # Add noise to the latents according to the noise magnitude at each timestep
+ # (this is the forward diffusion process)
+ noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)
+
+ # Get the text embedding for conditioning
+ encoder_hidden_states = text_encoder(batch["input_ids"])[0]
+
+ # Predict the noise residual
+ model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
+
+ # Get the target for loss depending on the prediction type
+ if noise_scheduler.config.prediction_type == "epsilon":
+ target = noise
+ elif noise_scheduler.config.prediction_type == "v_prediction":
+ target = noise_scheduler.get_velocity(latents, noise, timesteps)
+ else:
+ raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}")
+
+ if args.with_prior_preservation:
+ # Chunk the noise and model_pred into two parts and compute the loss on each part separately.
+ model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0)
+ target, target_prior = torch.chunk(target, 2, dim=0)
+
+ # Compute instance loss
+ loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+ # Compute prior loss
+ prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean")
+
+ # Add the prior loss to the instance loss.
+ loss = loss + args.prior_loss_weight * prior_loss
+ else:
+ loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+ accelerator.backward(loss)
+ if accelerator.sync_gradients:
+ params_to_clip = (
+ itertools.chain(unet.parameters(), text_encoder.parameters())
+ if args.train_text_encoder
+ else unet.parameters()
+ )
+ accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm)
+ optimizer.step()
+ lr_scheduler.step()
+ optimizer.zero_grad()
+
+ # Checks if the accelerator has performed an optimization step behind the scenes
+ if accelerator.sync_gradients:
+ progress_bar.update(1)
+ if args.report_to == "wandb":
+ accelerator.print(progress_bar)
+ global_step += 1
+
+ # if global_step % args.checkpointing_steps == 0:
+ # if accelerator.is_main_process:
+ # save_path = os.path.join(args.output_dir, f"checkpoint-{global_step}")
+ # accelerator.save_state(save_path)
+ # logger.info(f"Saved state to {save_path}")
+
+ logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]}
+ progress_bar.set_postfix(**logs)
+ accelerator.log(logs, step=global_step)
+
+ if (
+ args.validation_prompt is not None
+ and (step + num_update_steps_per_epoch * epoch) % args.validation_steps == 0
+ ):
+ logger.info(
+ f"Running validation... \n Generating {args.num_validation_images} images with prompt:"
+ f" {args.validation_prompt}."
+ )
+ # create pipeline
+ pipeline = DiffusionPipeline.from_pretrained(
+ args.pretrained_model_name_or_path,
+ safety_checker=None,
+ revision=args.revision,
+ )
+ # set `keep_fp32_wrapper` to True because we do not want to remove
+ # mixed precision hooks while we are still training
+ pipeline.unet = accelerator.unwrap_model(unet, keep_fp32_wrapper=True)
+ pipeline.text_encoder = accelerator.unwrap_model(text_encoder, keep_fp32_wrapper=True)
+ pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config)
+ pipeline = pipeline.to(accelerator.device)
+ pipeline.set_progress_bar_config(disable=True)
+
+ # Set evaliation mode
+ pipeline.unet.eval()
+ pipeline.text_encoder.eval()
+
+ # run inference
+ if args.seed is not None:
+ generator = torch.Generator(device=accelerator.device).manual_seed(args.seed)
+ else:
+ generator = None
+ images = []
+ for _ in range(args.num_validation_images):
+ image = pipeline(args.validation_prompt, num_inference_steps=25, generator=generator).images[0]
+ images.append(image)
+
+ for tracker in accelerator.trackers:
+ if tracker.name == "tensorboard":
+ np_images = np.stack([np.asarray(img) for img in images])
+ tracker.writer.add_images("validation", np_images, epoch, dataformats="NHWC")
+ if tracker.name == "wandb":
+ import wandb
+
+ tracker.log(
+ {
+ "validation": [
+ wandb.Image(image, caption=f"{i}: {args.validation_prompt}")
+ for i, image in enumerate(images)
+ ]
+ }
+ )
+
+ # Set evaliation mode
+ pipeline.unet.train()
+ pipeline.text_encoder.train()
+
+ del pipeline
+ if torch.cuda.is_available():
+ torch.cuda.empty_cache()
+ elif torch.xpu.is_available():
+ torch.xpu.empty_cache()
+
+ if global_step >= args.max_train_steps:
+ break
+ # Printing the accelerator memory usage details such as allocated memory, peak memory, and total memory usage
+ accelerator.print(
+ f"{accelerator.device.type.upper()} Memory before entering the train : {b2mb(tracemalloc.begin)}"
+ )
+ accelerator.print(
+ f"{accelerator.device.type.upper()} Memory consumed at the end of the train (end-begin): {tracemalloc.used}"
+ )
+ accelerator.print(
+ f"{accelerator.device.type.upper()} Peak Memory consumed during the train (max-begin): {tracemalloc.peaked}"
+ )
+ accelerator.print(
+ f"{accelerator.device.type.upper()} Total Peak Memory consumed during the train (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}"
+ )
+
+ accelerator.print(f"CPU Memory before entering the train : {b2mb(tracemalloc.cpu_begin)}")
+ accelerator.print(f"CPU Memory consumed at the end of the train (end-begin): {tracemalloc.cpu_used}")
+ accelerator.print(f"CPU Peak Memory consumed during the train (max-begin): {tracemalloc.cpu_peaked}")
+ accelerator.print(
+ f"CPU Total Peak Memory consumed during the train (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}"
+ )
+
+ # Create the pipeline using using the trained modules and save it.
+ accelerator.wait_for_everyone()
+ if accelerator.is_main_process:
+ if args.adapter != "full":
+ unwarpped_unet = accelerator.unwrap_model(unet)
+ unwarpped_unet.save_pretrained(
+ os.path.join(args.output_dir, "unet"), state_dict=accelerator.get_state_dict(unet)
+ )
+ if args.train_text_encoder:
+ unwarpped_text_encoder = accelerator.unwrap_model(text_encoder)
+ unwarpped_text_encoder.save_pretrained(
+ os.path.join(args.output_dir, "text_encoder"),
+ state_dict=accelerator.get_state_dict(text_encoder),
+ )
+ else:
+ pipeline = DiffusionPipeline.from_pretrained(
+ args.pretrained_model_name_or_path,
+ unet=accelerator.unwrap_model(unet),
+ text_encoder=accelerator.unwrap_model(text_encoder),
+ revision=args.revision,
+ )
+ pipeline.save_pretrained(args.output_dir)
+
+ if args.push_to_hub:
+ api.upload_folder(
+ repo_id=repo_id,
+ folder_path=args.output_dir,
+ commit_message="End of training",
+ run_as_future=True,
+ )
+
+ accelerator.end_training()
+
+
+if __name__ == "__main__":
+ args = parse_args()
+ main(args)
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/token_classification/peft_lora_ner.ipynb b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/token_classification/peft_lora_ner.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..e2a6c048daef2200a4c08f55d1c33ba2732a5ee2
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/token_classification/peft_lora_ner.ipynb
@@ -0,0 +1,554 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Named Entity Recognition with Peft Model 🤗\n",
+ "\n",
+ "##### In this notebook, we will learn how to perform Named Entity Recognition(NER) on the CoNLL-2003 dataset using the Trainer class\n",
+ "\n",
+ "##### This notebook has been adapted from the main NLP course here - https://huggingface.co/learn/nlp-course/chapter7/2?fw=pt#fine-tuning-the-model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#install the required libraries\n",
+ "!pip install -q datasets evaluate transformers seqeval"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Import required libraries\n",
+ "from datasets import load_dataset\n",
+ "from transformers import AutoTokenizer, AutoModelForTokenClassification, DataCollatorForTokenClassification, TrainingArguments, Trainer, pipeline\n",
+ "from peft import get_peft_model, LoraConfig, TaskType\n",
+ "import evaluate\n",
+ "import numpy as np\n",
+ "from huggingface_hub import notebook_login"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "DatasetDict({\n",
+ " train: Dataset({\n",
+ " features: ['id', 'tokens', 'pos_tags', 'chunk_tags', 'ner_tags'],\n",
+ " num_rows: 14041\n",
+ " })\n",
+ " validation: Dataset({\n",
+ " features: ['id', 'tokens', 'pos_tags', 'chunk_tags', 'ner_tags'],\n",
+ " num_rows: 3250\n",
+ " })\n",
+ " test: Dataset({\n",
+ " features: ['id', 'tokens', 'pos_tags', 'chunk_tags', 'ner_tags'],\n",
+ " num_rows: 3453\n",
+ " })\n",
+ "})\n"
+ ]
+ }
+ ],
+ "source": [
+ "raw_datasets = load_dataset(\"conll2003\")\n",
+ "print(raw_datasets)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['EU', 'rejects', 'German', 'call', 'to', 'boycott', 'British', 'lamb', '.']"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Look at the tokens of the first training example\n",
+ "raw_datasets[\"train\"][0][\"tokens\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[3, 0, 7, 0, 0, 0, 7, 0, 0]"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Look at the NER tags of the first training example\n",
+ "raw_datasets[\"train\"][0][\"ner_tags\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['O', 'B-PER', 'I-PER', 'B-ORG', 'I-ORG', 'B-LOC', 'I-LOC', 'B-MISC', 'I-MISC']"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Get the label names for the NER tags\n",
+ "ner_feature = raw_datasets[\"train\"].features[\"ner_tags\"]\n",
+ "label_names = ner_feature.feature.names\n",
+ "label_names"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "EU rejects German call to boycott British lamb . \n",
+ "B-ORG O B-MISC O O O B-MISC O O \n"
+ ]
+ }
+ ],
+ "source": [
+ "words = raw_datasets[\"train\"][0][\"tokens\"]\n",
+ "labels = raw_datasets[\"train\"][0][\"ner_tags\"]\n",
+ "line1 = \"\"\n",
+ "line2 = \"\"\n",
+ "for word, label in zip(words, labels):\n",
+ " full_label = label_names[label]\n",
+ " max_length = max(len(word), len(full_label))\n",
+ " line1 += word + \" \" * (max_length - len(word) + 1)\n",
+ " line2 += full_label + \" \" * (max_length - len(full_label) + 1)\n",
+ "\n",
+ "print(line1)\n",
+ "print(line2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Load the tokenizer\n",
+ "model_checkpoint = \"bert-base-cased\"\n",
+ "tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['[CLS]',\n",
+ " 'EU',\n",
+ " 'rejects',\n",
+ " 'German',\n",
+ " 'call',\n",
+ " 'to',\n",
+ " 'boycott',\n",
+ " 'British',\n",
+ " 'la',\n",
+ " '##mb',\n",
+ " '.',\n",
+ " '[SEP]']"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Tokenize the first training example\n",
+ "inputs = tokenizer(raw_datasets[\"train\"][0][\"tokens\"], is_split_into_words=True)\n",
+ "inputs.tokens()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def align_labels_with_tokens(labels, word_ids):\n",
+ " new_labels = []\n",
+ " current_word = None\n",
+ " for word_id in word_ids:\n",
+ " if word_id != current_word:\n",
+ " # Start of a new word!\n",
+ " current_word = word_id\n",
+ " label = -100 if word_id is None else labels[word_id]\n",
+ " new_labels.append(label)\n",
+ " elif word_id is None:\n",
+ " # Special token\n",
+ " new_labels.append(-100)\n",
+ " else:\n",
+ " # Same word as previous token\n",
+ " label = labels[word_id]\n",
+ " # If the label is B-XXX we change it to I-XXX\n",
+ " if label % 2 == 1:\n",
+ " label += 1\n",
+ " new_labels.append(label)\n",
+ "\n",
+ " return new_labels"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[3, 0, 7, 0, 0, 0, 7, 0, 0]\n",
+ "[-100, 3, 0, 7, 0, 0, 0, 7, 0, 0, 0, -100]\n"
+ ]
+ }
+ ],
+ "source": [
+ "labels = raw_datasets[\"train\"][0][\"ner_tags\"]\n",
+ "word_ids = inputs.word_ids()\n",
+ "print(labels)\n",
+ "print(align_labels_with_tokens(labels, word_ids))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def tokenize_and_align_labels(examples):\n",
+ " tokenized_inputs = tokenizer(\n",
+ " examples[\"tokens\"], truncation=True, is_split_into_words=True\n",
+ " )\n",
+ " all_labels = examples[\"ner_tags\"]\n",
+ " new_labels = []\n",
+ " for i, labels in enumerate(all_labels):\n",
+ " word_ids = tokenized_inputs.word_ids(i)\n",
+ " new_labels.append(align_labels_with_tokens(labels, word_ids))\n",
+ "\n",
+ " tokenized_inputs[\"labels\"] = new_labels\n",
+ " return tokenized_inputs"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tokenized_datasets = raw_datasets.map(\n",
+ " tokenize_and_align_labels,\n",
+ " batched=True,\n",
+ " remove_columns=raw_datasets[\"train\"].column_names,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data_collator = DataCollatorForTokenClassification(tokenizer=tokenizer)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[-100, 3, 0, 7, 0, 0, 0, 7, 0, 0, 0, -100]\n",
+ "[-100, 1, 2, -100]\n"
+ ]
+ }
+ ],
+ "source": [
+ "for i in range(2):\n",
+ " print(tokenized_datasets[\"train\"][i][\"labels\"])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "metric = evaluate.load(\"seqeval\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Create label mappings\n",
+ "id2label = {i: label for i, label in enumerate(label_names)}\n",
+ "label2id = {v: k for k, v in id2label.items()}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Load the pre-trained model\n",
+ "model = AutoModelForTokenClassification.from_pretrained(\n",
+ " model_checkpoint,\n",
+ " id2label=id2label,\n",
+ " label2id=label2id,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "9"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "model.config.num_labels"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Configure LoRA (Low-Rank Adaptation) for fine-tuning\n",
+ "peft_config = LoraConfig(target_modules = [\"query\", \"key\"], task_type = TaskType.TOKEN_CLS)\n",
+ "\n",
+ "model = get_peft_model(model, peft_config)\n",
+ "model.print_trainable_parameters()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def compute_metrics(eval_preds):\n",
+ " logits, labels = eval_preds\n",
+ " predictions = np.argmax(logits, axis=-1)\n",
+ "\n",
+ " # Remove ignored index (special tokens) and convert to labels\n",
+ " true_labels = [[label_names[l] for l in label if l != -100] for label in labels]\n",
+ " true_predictions = [\n",
+ " [label_names[p] for (p, l) in zip(prediction, label) if l != -100]\n",
+ " for prediction, label in zip(predictions, labels)\n",
+ " ]\n",
+ " all_metrics = metric.compute(predictions=true_predictions, references=true_labels)\n",
+ " return {\n",
+ " \"precision\": all_metrics[\"overall_precision\"],\n",
+ " \"recall\": all_metrics[\"overall_recall\"],\n",
+ " \"f1\": all_metrics[\"overall_f1\"],\n",
+ " \"accuracy\": all_metrics[\"overall_accuracy\"],\n",
+ " }"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "notebook_login()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "args = TrainingArguments(\n",
+ " \"bert-finetuned-ner-lora\",\n",
+ " eval_strategy=\"epoch\",\n",
+ " per_device_train_batch_size=32, # decrease this for OOM error\n",
+ " per_device_eval_batch_size=64,\n",
+ " save_strategy=\"epoch\",\n",
+ " learning_rate=2e-3,\n",
+ " num_train_epochs=5,\n",
+ " weight_decay=0.01,\n",
+ " load_best_model_at_end=True,\n",
+ " do_eval=True,\n",
+ " do_predict=True,\n",
+ " metric_for_best_model=\"accuracy\",\n",
+ " label_names=[\"labels\"],\n",
+ " push_to_hub=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "trainer = Trainer(\n",
+ " model=model,\n",
+ " args=args,\n",
+ " train_dataset=tokenized_datasets[\"train\"],\n",
+ " eval_dataset=tokenized_datasets[\"validation\"],\n",
+ " data_collator=data_collator,\n",
+ " processing_class=tokenizer,\n",
+ " compute_metrics=compute_metrics\n",
+ ")\n",
+ "trainer.train()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Some weights of BertForTokenClassification were not initialized from the model checkpoint at bert-base-cased and are newly initialized: ['classifier.bias', 'classifier.weight']\n",
+ "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
+ "Device set to use xpu:0\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "entity_idx: 0, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n",
+ "entity_idx: 0, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n",
+ "entity_idx: 0, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n",
+ "entity_idx: 1, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n",
+ "entity_idx: 2, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n",
+ "entity_idx: 0, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "[{'entity_group': 'PER',\n",
+ " 'score': 0.9702984,\n",
+ " 'word': 'Jino',\n",
+ " 'start': 11,\n",
+ " 'end': 15}]"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from peft import PeftModel\n",
+ "\n",
+ "# Replace this with your own checkpoint\n",
+ "lora_checkpoint = \"./bert-finetuned-ner-lora\"\n",
+ "\n",
+ "tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)\n",
+ "base_model = AutoModelForTokenClassification.from_pretrained(\n",
+ " model_checkpoint,\n",
+ " id2label=id2label,\n",
+ " label2id=label2id,\n",
+ ")\n",
+ "lora_model = PeftModel.from_pretrained(base_model, lora_checkpoint)\n",
+ "token_classifier = pipeline(\n",
+ " \"token-classification\", model=lora_model, tokenizer=tokenizer, aggregation_strategy=\"simple\"\n",
+ ")\n",
+ "\n",
+ "token_classifier(\"My name is Jino.\")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.11.13"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/token_classification/peft_lora_token_cls.ipynb b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/token_classification/peft_lora_token_cls.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..0c6c686ae5b40f04fa4edb8aa5a31ac4ef253942
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/token_classification/peft_lora_token_cls.ipynb
@@ -0,0 +1,1430 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "colab_type": "text",
+ "id": "view-in-github"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ngqdEv0rP01q"
+ },
+ "source": [
+ "## Introduction\n",
+ "\n",
+ "In this notebook, we are going to fine-tune the LayoutLM model by Microsoft Research on the [FUNSD](https://guillaumejaume.github.io/FUNSD/) dataset, which is a collection of annotated form documents. The goal of our model is to learn the annotations of a number of labels (\"question\", \"answer\", \"header\" and \"other\") on those forms, such that it can be used to annotate unseen forms in the future.\n",
+ "\n",
+ "* Original LayoutLM paper: https://huggingface.co/papers/1912.13318\n",
+ "\n",
+ "* Original FUNSD paper: https://huggingface.co/papers/1905.13538\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "6K4S2s33ebY0"
+ },
+ "source": [
+ "## Install libraries\n",
+ "\n",
+ "Currently you have to first install the `unilm` package, and then the `transformers` package (which updates the outdated `transformers` package that is included in the `unilm` package). The reason we also install the `unilm` package is because we need its preprocessing files. I've forked it, and removed some statements which introduced some issues."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000
+ },
+ "id": "5cngOTr6SqEf",
+ "outputId": "6c7a2f76-682b-4f93-a3db-59ab010e5ffe"
+ },
+ "outputs": [],
+ "source": [
+ "! rm -r unilm\n",
+ "! git clone https://github.com/microsoft/unilm.git"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "RGMkEG5aRB0D"
+ },
+ "source": [
+ "## Getting the data\n",
+ "\n",
+ "Here we download the data of the [FUNSD dataset](https://guillaumejaume.github.io/FUNSD/) from the web. This results in a directory called \"data\" being created, which has 2 subdirectories, one for training and one for testing. Each of those has 2 subdirectories in turn, one containing the images as png files and one containing the annotations in json format."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "DTFnEZagQm4v",
+ "outputId": "97ce03ba-a6bb-4444-8eba-77eceece44e0"
+ },
+ "outputs": [],
+ "source": [
+ "! wget https://guillaumejaume.github.io/FUNSD/dataset.zip\n",
+ "! unzip dataset.zip && mv dataset data && rm -rf dataset.zip __MACOSX"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "UrNMR64LsJXm"
+ },
+ "source": [
+ "Let's take a look at a training example. For this, we are going to use PIL (Python Image Library)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000
+ },
+ "id": "eG-eGcj3sNPs",
+ "outputId": "69ead0ea-15d6-4d5e-af61-a99a7533d31b"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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",
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from PIL import Image, ImageDraw, ImageFont\n",
+ "import os\n",
+ "\n",
+ "base_path = \"./data\"\n",
+ "\n",
+ "image = Image.open(os.path.join(base_path, \"training_data/images/0000971160.png\"))\n",
+ "image = image.convert(\"RGB\")\n",
+ "image"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "uAVffmnZyUvw"
+ },
+ "source": [
+ "Now let's plot its corresponding annotations. Basically, if you type `data['form']`, you get a list of all general annotations. Each general annotation has a label, a bounding box, and one or more words, which in also have their own bounding box. The bounding boxes are in [xleft, ytop, xright, ybottom] format.\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "JPKkuJQ4sdZc",
+ "outputId": "c95bf306-98bb-4480-cc6b-ebb3aea548b3"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "{'box': [292, 91, 376, 175], 'text': 'R&D', 'label': 'other', 'words': [{'box': [292, 91, 376, 175], 'text': 'R&D'}], 'linking': [], 'id': 0}\n",
+ "{'box': [219, 316, 225, 327], 'text': ':', 'label': 'question', 'words': [{'box': [219, 316, 225, 327], 'text': ':'}], 'linking': [], 'id': 1}\n",
+ "{'box': [95, 355, 169, 370], 'text': 'Suggestion:', 'label': 'question', 'words': [{'box': [95, 355, 169, 370], 'text': 'Suggestion:'}], 'linking': [[2, 16]], 'id': 2}\n",
+ "{'box': [482, 268, 518, 282], 'text': 'Date:', 'label': 'question', 'words': [{'box': [482, 268, 518, 282], 'text': 'Date:'}], 'linking': [[3, 12]], 'id': 3}\n",
+ "{'box': [511, 309, 570, 323], 'text': 'Licensee', 'label': 'answer', 'words': [{'box': [511, 309, 570, 323], 'text': 'Licensee'}], 'linking': [[13, 4]], 'id': 4}\n",
+ "{'box': [211, 651, 217, 662], 'text': '', 'label': 'question', 'words': [{'box': [211, 651, 217, 662], 'text': ''}], 'linking': [], 'id': 5}\n",
+ "{'box': [461, 605, 483, 619], 'text': 'Yes', 'label': 'question', 'words': [{'box': [461, 605, 483, 619], 'text': 'Yes'}], 'linking': [[19, 6]], 'id': 6}\n",
+ "{'box': [545, 603, 563, 617], 'text': 'No', 'label': 'question', 'words': [{'box': [545, 603, 563, 617], 'text': 'No'}], 'linking': [[19, 7]], 'id': 7}\n",
+ "{'box': [525, 904, 641, 926], 'text': '597005708', 'label': 'other', 'words': [{'box': [525, 904, 641, 926], 'text': '597005708'}], 'linking': [], 'id': 8}\n",
+ "{'text': 'R&D QUALITY IMPROVEMENT SUGGESTION/ SOLUTION FORM', 'box': [256, 201, 423, 230], 'linking': [], 'label': 'header', 'words': [{'text': 'R&D', 'box': [257, 203, 279, 214]}, {'text': 'QUALITY', 'box': [285, 203, 334, 216]}, {'text': 'IMPROVEMENT', 'box': [341, 201, 418, 211]}, {'text': 'SUGGESTION/', 'box': [256, 215, 324, 229]}, {'text': '', 'box': [324, 216, 332, 230]}, {'text': 'SOLUTION', 'box': [331, 214, 387, 228]}, {'text': 'FORM', 'box': [395, 215, 423, 228]}], 'id': 9}\n",
+ "{'text': 'Name / Phone Ext. :', 'box': [89, 272, 204, 289], 'linking': [[10, 11]], 'label': 'question', 'words': [{'text': 'Name', 'box': [89, 274, 118, 289]}, {'text': '/', 'box': [117, 274, 127, 288]}, {'text': 'Phone', 'box': [128, 274, 163, 289]}, {'text': 'Ext.', 'box': [169, 272, 196, 287]}, {'text': ':', 'box': [196, 274, 204, 288]}], 'id': 10}\n",
+ "{'text': 'M. Hamann P. Harper, P. Martinez', 'box': [215, 271, 451, 287], 'linking': [[10, 11]], 'label': 'answer', 'words': [{'text': 'M.', 'box': [215, 272, 230, 287]}, {'text': 'Hamann', 'box': [237, 272, 287, 286]}, {'text': 'P.', 'box': [293, 272, 307, 286]}, {'text': 'Harper,', 'box': [314, 274, 363, 285]}, {'text': 'P.', 'box': [370, 272, 384, 285]}, {'text': 'Martinez', 'box': [390, 271, 451, 282]}], 'id': 11}\n",
+ "{'text': '9/ 3/ 92', 'box': [543, 264, 590, 279], 'linking': [[3, 12]], 'label': 'answer', 'words': [{'text': '9/', 'box': [543, 265, 560, 279]}, {'text': '3/', 'box': [560, 264, 575, 279]}, {'text': '92', 'box': [575, 264, 590, 279]}], 'id': 12}\n",
+ "{'text': 'R&D Group:', 'box': [420, 310, 491, 323], 'linking': [[13, 4]], 'label': 'question', 'words': [{'text': 'R&D', 'box': [420, 310, 442, 323]}, {'text': 'Group:', 'box': [448, 310, 491, 323]}], 'id': 13}\n",
+ "{'text': 'J. S. Wigand', 'box': [236, 313, 327, 327], 'linking': [[15, 14]], 'label': 'answer', 'words': [{'text': 'J.', 'box': [236, 313, 251, 327]}, {'text': 'S.', 'box': [256, 313, 273, 326]}, {'text': 'Wigand', 'box': [278, 313, 327, 327]}], 'id': 14}\n",
+ "{'text': 'Supervisor / Manager', 'box': [91, 316, 218, 331], 'linking': [[15, 14]], 'label': 'question', 'words': [{'text': 'Supervisor', 'box': [91, 316, 161, 330]}, {'text': '/', 'box': [163, 318, 169, 331]}, {'text': 'Manager', 'box': [169, 317, 218, 327]}], 'id': 15}\n",
+ "{'text': 'Discontinue coal retention analyses on licensee submitted product samples (Note : Coal Retention testing is not performed by most licensees. Other B&W physical measurements as ends stability and inspection for soft spots in ciparettes are thought to be sufficient measures to assure cigarette physical integrity. The proposed action will increase laboratory productivity . )', 'box': [190, 346, 594, 447], 'linking': [[2, 16]], 'label': 'answer', 'words': [{'text': 'Discontinue', 'box': [190, 355, 268, 366]}, {'text': 'coal', 'box': [274, 353, 303, 366]}, {'text': 'retention', 'box': [309, 352, 375, 365]}, {'text': 'analyses', 'box': [381, 351, 435, 365]}, {'text': 'on', 'box': [443, 352, 458, 363]}, {'text': 'licensee', 'box': [464, 348, 520, 362]}, {'text': 'submitted', 'box': [527, 346, 594, 361]}, {'text': 'product', 'box': [190, 369, 240, 383]}, {'text': 'samples', 'box': [247, 367, 301, 380]}, {'text': '(Note', 'box': [318, 365, 352, 379]}, {'text': ':', 'box': [352, 367, 359, 380]}, {'text': 'Coal', 'box': [373, 366, 402, 376]}, {'text': 'Retention', 'box': [408, 366, 472, 376]}, {'text': 'testing', 'box': [479, 365, 529, 376]}, {'text': 'is', 'box': [536, 363, 549, 374]}, {'text': 'not', 'box': [554, 363, 578, 374]}, {'text': 'performed', 'box': [190, 383, 256, 394]}, {'text': 'by', 'box': [261, 381, 275, 394]}, {'text': 'most', 'box': [282, 383, 311, 393]}, {'text': 'licensees.', 'box': [318, 380, 386, 391]}, {'text': 'Other', 'box': [401, 378, 437, 389]}, {'text': 'B&W', 'box': [443, 378, 465, 389]}, {'text': 'physical', 'box': [471, 377, 528, 391]}, {'text': 'measurements', 'box': [191, 398, 275, 406]}, {'text': 'as', 'box': [282, 397, 297, 405]}, {'text': 'ends', 'box': [304, 394, 332, 405]}, {'text': 'stability', 'box': [339, 394, 402, 405]}, {'text': 'and', 'box': [409, 392, 430, 402]}, {'text': 'inspection', 'box': [437, 392, 508, 403]}, {'text': 'for', 'box': [515, 391, 535, 402]}, {'text': 'soft', 'box': [542, 391, 571, 401]}, {'text': 'spots', 'box': [193, 411, 228, 422]}, {'text': 'in', 'box': [235, 409, 250, 420]}, {'text': 'ciparettes', 'box': [256, 409, 327, 419]}, {'text': 'are', 'box': [332, 408, 352, 418]}, {'text': 'thought', 'box': [360, 406, 410, 419]}, {'text': 'to', 'box': [415, 406, 430, 416]}, {'text': 'be', 'box': [436, 404, 453, 417]}, {'text': 'sufficient', 'box': [458, 405, 529, 415]}, {'text': 'measures', 'box': [535, 405, 592, 415]}, {'text': 'to', 'box': [193, 425, 208, 433]}, {'text': 'assure', 'box': [214, 423, 255, 431]}, {'text': 'cigarette', 'box': [261, 420, 325, 434]}, {'text': 'physical', 'box': [331, 419, 390, 432]}, {'text': 'integrity.', 'box': [395, 418, 463, 431]}, {'text': 'The', 'box': [478, 416, 500, 429]}, {'text': 'proposed', 'box': [506, 418, 566, 431]}, {'text': 'action', 'box': [193, 436, 236, 447]}, {'text': 'will', 'box': [240, 436, 269, 447]}, {'text': 'increase', 'box': [277, 434, 333, 445]}, {'text': 'laboratory', 'box': [339, 433, 410, 446]}, {'text': 'productivity', 'box': [418, 430, 502, 445]}, {'text': '.', 'box': [503, 433, 507, 444]}, {'text': ')', 'box': [508, 430, 514, 444]}], 'id': 16}\n",
+ "{'text': 'Suggested Solutions (s) :', 'box': [95, 486, 250, 504], 'linking': [[17, 18]], 'label': 'question', 'words': [{'text': 'Suggested', 'box': [95, 489, 159, 504]}, {'text': 'Solutions', 'box': [165, 487, 222, 501]}, {'text': '(s)', 'box': [223, 486, 241, 503]}, {'text': ':', 'box': [243, 489, 250, 503]}], 'id': 17}\n",
+ "{'text': 'Delete coal retention from the list of standard analyses performed on licensee submitted product samples. Special requests for coal retention testing could still be submitted on an exception basis.', 'box': [263, 483, 593, 553], 'linking': [[17, 18]], 'label': 'answer', 'words': [{'text': 'Delete', 'box': [263, 486, 306, 500]}, {'text': 'coal', 'box': [313, 486, 341, 499]}, {'text': 'retention', 'box': [348, 486, 412, 497]}, {'text': 'from', 'box': [416, 485, 447, 498]}, {'text': 'the', 'box': [453, 485, 475, 498]}, {'text': 'list', 'box': [480, 483, 508, 496]}, {'text': 'of', 'box': [515, 483, 532, 494]}, {'text': 'standard', 'box': [536, 483, 593, 494]}, {'text': 'analyses', 'box': [264, 501, 320, 514]}, {'text': 'performed', 'box': [324, 501, 392, 512]}, {'text': 'on', 'box': [397, 501, 412, 511]}, {'text': 'licensee', 'box': [419, 499, 475, 512]}, {'text': 'submitted', 'box': [482, 499, 546, 510]}, {'text': 'product', 'box': [264, 517, 314, 528]}, {'text': 'samples.', 'box': [320, 514, 374, 528]}, {'text': 'Special', 'box': [390, 513, 439, 526]}, {'text': 'requests', 'box': [446, 513, 502, 524]}, {'text': 'for', 'box': [508, 511, 530, 522]}, {'text': 'coal', 'box': [538, 510, 566, 523]}, {'text': 'retention', 'box': [263, 529, 330, 540]}, {'text': 'testing', 'box': [335, 527, 387, 540]}, {'text': 'could', 'box': [390, 527, 428, 538]}, {'text': 'still', 'box': [433, 525, 468, 536]}, {'text': 'be', 'box': [473, 525, 488, 535]}, {'text': 'submitted', 'box': [496, 524, 560, 537]}, {'text': 'on', 'box': [566, 524, 584, 537]}, {'text': 'an', 'box': [264, 543, 281, 553]}, {'text': 'exception', 'box': [286, 539, 350, 553]}, {'text': 'basis.', 'box': [355, 541, 397, 551]}], 'id': 18}\n",
+ "{'text': 'Have you contacted your Manager/ Supervisor?', 'box': [96, 608, 398, 624], 'linking': [[19, 6], [19, 7]], 'label': 'header', 'words': [{'text': 'Have', 'box': [96, 612, 127, 623]}, {'text': 'you', 'box': [131, 613, 156, 624]}, {'text': 'contacted', 'box': [161, 612, 225, 623]}, {'text': 'your', 'box': [229, 610, 260, 623]}, {'text': 'Manager/', 'box': [264, 609, 314, 622]}, {'text': '', 'box': [314, 608, 322, 622]}, {'text': 'Supervisor?', 'box': [323, 608, 398, 621]}], 'id': 19}\n",
+ "{'text': 'Manager Comments:', 'box': [98, 651, 211, 665], 'linking': [[20, 21], [20, 22]], 'label': 'question', 'words': [{'text': 'Manager', 'box': [98, 654, 150, 665]}, {'text': 'Comments:', 'box': [154, 651, 211, 664]}], 'id': 20}\n",
+ "{'text': 'Manager, please contact suggester and forward', 'box': [232, 644, 547, 662], 'linking': [[20, 21]], 'label': 'answer', 'words': [{'text': 'Manager,', 'box': [232, 648, 288, 662]}, {'text': 'please', 'box': [296, 649, 338, 662]}, {'text': 'contact', 'box': [344, 648, 394, 662]}, {'text': 'suggester', 'box': [401, 648, 464, 661]}, {'text': 'and', 'box': [469, 647, 491, 658]}, {'text': 'forward', 'box': [497, 644, 547, 657]}], 'id': 21}\n",
+ "{'text': 'comments to the Quality Council.', 'box': [99, 662, 323, 677], 'linking': [[20, 22]], 'label': 'answer', 'words': [{'text': 'comments', 'box': [99, 666, 155, 677]}, {'text': 'to', 'box': [162, 665, 177, 676]}, {'text': 'the', 'box': [183, 665, 205, 675]}, {'text': 'Quality', 'box': [211, 663, 261, 676]}, {'text': 'Council.', 'box': [267, 662, 323, 676]}], 'id': 22}\n",
+ "{'text': 'qip . wp', 'box': [102, 823, 145, 838], 'linking': [], 'label': 'other', 'words': [{'text': 'qip', 'box': [102, 824, 123, 837]}, {'text': '.', 'box': [124, 824, 130, 838]}, {'text': 'wp', 'box': [130, 823, 145, 837]}], 'id': 23}\n"
+ ]
+ }
+ ],
+ "source": [
+ "import json\n",
+ "\n",
+ "with open(os.path.join(base_path, \"training_data/annotations/0000971160.json\")) as f:\n",
+ " data = json.load(f)\n",
+ "\n",
+ "for annotation in data[\"form\"]:\n",
+ " print(annotation)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Hs4L3S5a2Gfb"
+ },
+ "source": [
+ "The PIL library has a handy ImageDraw module, which -you guessed it- allows to draw things (such as rectangles) on an image:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000
+ },
+ "id": "gWaHFM_LtKPP",
+ "outputId": "c498e560-035f-4170-b0b9-85ba3956711c"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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",
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "draw = ImageDraw.Draw(image, \"RGBA\")\n",
+ "\n",
+ "font = ImageFont.load_default()\n",
+ "\n",
+ "label2color = {\"question\": \"blue\", \"answer\": \"green\", \"header\": \"orange\", \"other\": \"violet\"}\n",
+ "\n",
+ "for annotation in data[\"form\"]:\n",
+ " label = annotation[\"label\"]\n",
+ " general_box = annotation[\"box\"]\n",
+ " draw.rectangle(general_box, outline=label2color[label], width=2)\n",
+ " draw.text((general_box[0] + 10, general_box[1] - 10), label, fill=label2color[label], font=font)\n",
+ " words = annotation[\"words\"]\n",
+ " for word in words:\n",
+ " box = word[\"box\"]\n",
+ " draw.rectangle(box, outline=label2color[label], width=1)\n",
+ "\n",
+ "image"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "uyWQNLSCRJN7"
+ },
+ "source": [
+ "## Preprocessing the data\n",
+ "\n",
+ "Next, we need to turn the document images into individual tokens and corresponding labels (BIOES format, see further). We do this both for the training and test datasets. Make sure to run this from the `/content` directory:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "4DWRyOR9RuY6",
+ "outputId": "4215a24b-8049-4b1a-a23f-5aaa48e14083"
+ },
+ "outputs": [],
+ "source": [
+ "! python unilm/layoutlm/deprecated/examples/seq_labeling/preprocess.py --data_dir data/training_data/annotations \\\n",
+ " --data_split train \\\n",
+ " --output_dir data \\\n",
+ " --model_name_or_path microsoft/layoutlm-base-uncased \\\n",
+ " --max_len 510\n",
+ "\n",
+ "! python unilm/layoutlm/deprecated/examples/seq_labeling/preprocess.py --data_dir data/testing_data/annotations \\\n",
+ " --data_split test \\\n",
+ " --output_dir data \\\n",
+ " --model_name_or_path microsoft/layoutlm-base-uncased \\\n",
+ " --max_len 510"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "gc4Cu0ZyO5M_"
+ },
+ "source": [
+ "Next, we create a labels.txt file that contains the unique labels of the FUNSD dataset:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "8iGOU0s3UR2u"
+ },
+ "outputs": [],
+ "source": [
+ "! cat data/train.txt | cut -d$'\\t' -f 2 | grep -v \"^$\"| sort | uniq > data/labels.txt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "mC9FhkG9U8yg"
+ },
+ "source": [
+ "## Define a PyTorch dataset\n",
+ "\n",
+ "First, we create a list containing the unique labels based on `data/labels.txt` (run this from the content directory):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "id": "675rRa0QXnMp"
+ },
+ "outputs": [],
+ "source": [
+ "from torch.nn import CrossEntropyLoss\n",
+ "\n",
+ "\n",
+ "def get_labels(path):\n",
+ " with open(path, \"r\") as f:\n",
+ " labels = f.read().splitlines()\n",
+ " if \"O\" not in labels:\n",
+ " labels = [\"O\"] + labels\n",
+ " return labels\n",
+ "\n",
+ "\n",
+ "labels = get_labels(\"data/labels.txt\")\n",
+ "num_labels = len(labels)\n",
+ "label_map = {i: label for i, label in enumerate(labels)}\n",
+ "# Use cross entropy ignore index as padding label id so that only real label ids contribute to the loss later\n",
+ "pad_token_label_id = CrossEntropyLoss().ignore_index"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "kZ2LGEsez2u2"
+ },
+ "source": [
+ "We can see that the dataset uses the so-called BIOES annotation scheme to annotate the tokens. This means that a given token can be either at the beginning (B), inside (I), outside (O), at the end (E) or start (S) of a given entity. Entities include ANSWER, QUESTION, HEADER and OTHER: "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "_-qXLkP9Yq_L",
+ "outputId": "32ab46a4-4cf0-400c-816b-570f950035ec"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "['B-ANSWER', 'B-HEADER', 'B-QUESTION', 'E-ANSWER', 'E-HEADER', 'E-QUESTION', 'I-ANSWER', 'I-HEADER', 'I-QUESTION', 'O', 'S-ANSWER', 'S-HEADER', 'S-QUESTION']\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(labels)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "9_ck0ZFfZInR"
+ },
+ "source": [
+ "Next, we can create a PyTorch dataset and corresponding dataloader (both for training and evaluation):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import logging\n",
+ "import os\n",
+ "\n",
+ "import torch\n",
+ "from torch.utils.data import Dataset\n",
+ "\n",
+ "logger = logging.getLogger(__name__)\n",
+ "\n",
+ "\n",
+ "class FunsdDataset(Dataset):\n",
+ " def __init__(self, args, tokenizer, labels, pad_token_label_id, mode):\n",
+ " if args.local_rank not in [-1, 0] and mode == \"train\":\n",
+ " torch.distributed.barrier() # Make sure only the first process in distributed training process the dataset, and the others will use the cache\n",
+ "\n",
+ " # Load data features from cache or dataset file\n",
+ " cached_features_file = os.path.join(\n",
+ " args.data_dir,\n",
+ " \"cached_{}_{}_{}\".format(\n",
+ " mode,\n",
+ " list(filter(None, args.model_name_or_path.split(\"/\"))).pop(),\n",
+ " str(args.max_seq_length),\n",
+ " ),\n",
+ " )\n",
+ " if os.path.exists(cached_features_file) and not args.overwrite_cache:\n",
+ " logger.info(\"Loading features from cached file %s\", cached_features_file)\n",
+ " features = torch.load(cached_features_file)\n",
+ " else:\n",
+ " logger.info(\"Creating features from dataset file at %s\", args.data_dir)\n",
+ " examples = read_examples_from_file(args.data_dir, mode)\n",
+ " features = convert_examples_to_features(\n",
+ " examples,\n",
+ " labels,\n",
+ " args.max_seq_length,\n",
+ " tokenizer,\n",
+ " cls_token_at_end=bool(args.model_type in [\"xlnet\"]),\n",
+ " # xlnet has a cls token at the end\n",
+ " cls_token=tokenizer.cls_token,\n",
+ " cls_token_segment_id=2 if args.model_type in [\"xlnet\"] else 0,\n",
+ " sep_token=tokenizer.sep_token,\n",
+ " sep_token_extra=bool(args.model_type in [\"roberta\"]),\n",
+ " # roberta uses an extra separator b/w pairs of sentences, cf. github.com/pytorch/fairseq/commit/1684e166e3da03f5b600dbb7855cb98ddfcd0805\n",
+ " pad_on_left=bool(args.model_type in [\"xlnet\"]),\n",
+ " # pad on the left for xlnet\n",
+ " pad_token=tokenizer.convert_tokens_to_ids([tokenizer.pad_token])[0],\n",
+ " pad_token_segment_id=4 if args.model_type in [\"xlnet\"] else 0,\n",
+ " pad_token_label_id=pad_token_label_id,\n",
+ " )\n",
+ " # if args.local_rank in [-1, 0]:\n",
+ " # logger.info(\"Saving features into cached file %s\", cached_features_file)\n",
+ " # torch.save(features, cached_features_file)\n",
+ "\n",
+ " if args.local_rank == 0 and mode == \"train\":\n",
+ " torch.distributed.barrier() # Make sure only the first process in distributed training process the dataset, and the others will use the cache\n",
+ "\n",
+ " self.features = features\n",
+ " # Convert to Tensors and build dataset\n",
+ " self.all_input_ids = torch.tensor([f.input_ids for f in features], dtype=torch.long)\n",
+ " self.all_input_mask = torch.tensor([f.input_mask for f in features], dtype=torch.long)\n",
+ " self.all_segment_ids = torch.tensor([f.segment_ids for f in features], dtype=torch.long)\n",
+ " self.all_label_ids = torch.tensor([f.label_ids for f in features], dtype=torch.long)\n",
+ " self.all_bboxes = torch.tensor([f.boxes for f in features], dtype=torch.long)\n",
+ "\n",
+ " def __len__(self):\n",
+ " return len(self.features)\n",
+ "\n",
+ " def __getitem__(self, index):\n",
+ " return (\n",
+ " self.all_input_ids[index],\n",
+ " self.all_input_mask[index],\n",
+ " self.all_segment_ids[index],\n",
+ " self.all_label_ids[index],\n",
+ " self.all_bboxes[index],\n",
+ " )\n",
+ "\n",
+ "\n",
+ "class InputExample(object):\n",
+ " \"\"\"A single training/test example for token classification.\"\"\"\n",
+ "\n",
+ " def __init__(self, guid, words, labels, boxes, actual_bboxes, file_name, page_size):\n",
+ " \"\"\"Constructs a InputExample.\n",
+ "\n",
+ " Args:\n",
+ " guid: Unique id for the example.\n",
+ " words: list. The words of the sequence.\n",
+ " labels: (Optional) list. The labels for each word of the sequence. This should be\n",
+ " specified for train and dev examples, but not for test examples.\n",
+ " \"\"\"\n",
+ " self.guid = guid\n",
+ " self.words = words\n",
+ " self.labels = labels\n",
+ " self.boxes = boxes\n",
+ " self.actual_bboxes = actual_bboxes\n",
+ " self.file_name = file_name\n",
+ " self.page_size = page_size\n",
+ "\n",
+ "\n",
+ "class InputFeatures(object):\n",
+ " \"\"\"A single set of features of data.\"\"\"\n",
+ "\n",
+ " def __init__(\n",
+ " self,\n",
+ " input_ids,\n",
+ " input_mask,\n",
+ " segment_ids,\n",
+ " label_ids,\n",
+ " boxes,\n",
+ " actual_bboxes,\n",
+ " file_name,\n",
+ " page_size,\n",
+ " ):\n",
+ " assert (\n",
+ " 0 <= all(boxes) <= 1000\n",
+ " ), \"Error with input bbox ({}): the coordinate value is not between 0 and 1000\".format(boxes)\n",
+ " self.input_ids = input_ids\n",
+ " self.input_mask = input_mask\n",
+ " self.segment_ids = segment_ids\n",
+ " self.label_ids = label_ids\n",
+ " self.boxes = boxes\n",
+ " self.actual_bboxes = actual_bboxes\n",
+ " self.file_name = file_name\n",
+ " self.page_size = page_size\n",
+ "\n",
+ "\n",
+ "def read_examples_from_file(data_dir, mode):\n",
+ " file_path = os.path.join(data_dir, \"{}.txt\".format(mode))\n",
+ " box_file_path = os.path.join(data_dir, \"{}_box.txt\".format(mode))\n",
+ " image_file_path = os.path.join(data_dir, \"{}_image.txt\".format(mode))\n",
+ " guid_index = 1\n",
+ " examples = []\n",
+ " with open(file_path, encoding=\"utf-8\") as f, open(box_file_path, encoding=\"utf-8\") as fb, open(\n",
+ " image_file_path, encoding=\"utf-8\"\n",
+ " ) as fi:\n",
+ " words = []\n",
+ " boxes = []\n",
+ " actual_bboxes = []\n",
+ " file_name = None\n",
+ " page_size = None\n",
+ " labels = []\n",
+ " for line, bline, iline in zip(f, fb, fi):\n",
+ " if line.startswith(\"-DOCSTART-\") or line == \"\" or line == \"\\n\":\n",
+ " if words:\n",
+ " examples.append(\n",
+ " InputExample(\n",
+ " guid=\"{}-{}\".format(mode, guid_index),\n",
+ " words=words,\n",
+ " labels=labels,\n",
+ " boxes=boxes,\n",
+ " actual_bboxes=actual_bboxes,\n",
+ " file_name=file_name,\n",
+ " page_size=page_size,\n",
+ " )\n",
+ " )\n",
+ " guid_index += 1\n",
+ " words = []\n",
+ " boxes = []\n",
+ " actual_bboxes = []\n",
+ " file_name = None\n",
+ " page_size = None\n",
+ " labels = []\n",
+ " else:\n",
+ " splits = line.split(\"\\t\")\n",
+ " bsplits = bline.split(\"\\t\")\n",
+ " isplits = iline.split(\"\\t\")\n",
+ " assert len(splits) == 2\n",
+ " assert len(bsplits) == 2\n",
+ " assert len(isplits) == 4\n",
+ " assert splits[0] == bsplits[0]\n",
+ " words.append(splits[0])\n",
+ " if len(splits) > 1:\n",
+ " labels.append(splits[-1].replace(\"\\n\", \"\"))\n",
+ " box = bsplits[-1].replace(\"\\n\", \"\")\n",
+ " box = [int(b) for b in box.split()]\n",
+ " boxes.append(box)\n",
+ " actual_bbox = [int(b) for b in isplits[1].split()]\n",
+ " actual_bboxes.append(actual_bbox)\n",
+ " page_size = [int(i) for i in isplits[2].split()]\n",
+ " file_name = isplits[3].strip()\n",
+ " else:\n",
+ " # Examples could have no label for mode = \"test\"\n",
+ " labels.append(\"O\")\n",
+ " if words:\n",
+ " examples.append(\n",
+ " InputExample(\n",
+ " guid=\"%s-%d\".format(mode, guid_index),\n",
+ " words=words,\n",
+ " labels=labels,\n",
+ " boxes=boxes,\n",
+ " actual_bboxes=actual_bboxes,\n",
+ " file_name=file_name,\n",
+ " page_size=page_size,\n",
+ " )\n",
+ " )\n",
+ " return examples\n",
+ "\n",
+ "\n",
+ "def convert_examples_to_features(\n",
+ " examples,\n",
+ " label_list,\n",
+ " max_seq_length,\n",
+ " tokenizer,\n",
+ " cls_token_at_end=False,\n",
+ " cls_token=\"[CLS]\",\n",
+ " cls_token_segment_id=1,\n",
+ " sep_token=\"[SEP]\",\n",
+ " sep_token_extra=False,\n",
+ " pad_on_left=False,\n",
+ " pad_token=0,\n",
+ " cls_token_box=[0, 0, 0, 0],\n",
+ " sep_token_box=[1000, 1000, 1000, 1000],\n",
+ " pad_token_box=[0, 0, 0, 0],\n",
+ " pad_token_segment_id=0,\n",
+ " pad_token_label_id=-1,\n",
+ " sequence_a_segment_id=0,\n",
+ " mask_padding_with_zero=True,\n",
+ "):\n",
+ " \"\"\"Loads a data file into a list of `InputBatch`s\n",
+ " `cls_token_at_end` define the location of the CLS token:\n",
+ " - False (Default, BERT/XLM pattern): [CLS] + A + [SEP] + B + [SEP]\n",
+ " - True (XLNet/GPT pattern): A + [SEP] + B + [SEP] + [CLS]\n",
+ " `cls_token_segment_id` define the segment id associated to the CLS token (0 for BERT, 2 for XLNet)\n",
+ " \"\"\"\n",
+ "\n",
+ " label_map = {label: i for i, label in enumerate(label_list)}\n",
+ "\n",
+ " features = []\n",
+ " for ex_index, example in enumerate(examples):\n",
+ " file_name = example.file_name\n",
+ " page_size = example.page_size\n",
+ " width, height = page_size\n",
+ " if ex_index % 10000 == 0:\n",
+ " logger.info(\"Writing example %d of %d\", ex_index, len(examples))\n",
+ "\n",
+ " tokens = []\n",
+ " token_boxes = []\n",
+ " actual_bboxes = []\n",
+ " label_ids = []\n",
+ " for word, label, box, actual_bbox in zip(example.words, example.labels, example.boxes, example.actual_bboxes):\n",
+ " word_tokens = tokenizer.tokenize(word)\n",
+ " tokens.extend(word_tokens)\n",
+ " token_boxes.extend([box] * len(word_tokens))\n",
+ " actual_bboxes.extend([actual_bbox] * len(word_tokens))\n",
+ " # Use the real label id for the first token of the word, and padding ids for the remaining tokens\n",
+ " label_ids.extend([label_map[label]] + [pad_token_label_id] * (len(word_tokens) - 1))\n",
+ "\n",
+ " # Account for [CLS] and [SEP] with \"- 2\" and with \"- 3\" for RoBERTa.\n",
+ " special_tokens_count = 3 if sep_token_extra else 2\n",
+ " if len(tokens) > max_seq_length - special_tokens_count:\n",
+ " tokens = tokens[: (max_seq_length - special_tokens_count)]\n",
+ " token_boxes = token_boxes[: (max_seq_length - special_tokens_count)]\n",
+ " actual_bboxes = actual_bboxes[: (max_seq_length - special_tokens_count)]\n",
+ " label_ids = label_ids[: (max_seq_length - special_tokens_count)]\n",
+ "\n",
+ " # The convention in BERT is:\n",
+ " # (a) For sequence pairs:\n",
+ " # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n",
+ " # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\n",
+ " # (b) For single sequences:\n",
+ " # tokens: [CLS] the dog is hairy . [SEP]\n",
+ " # type_ids: 0 0 0 0 0 0 0\n",
+ " #\n",
+ " # Where \"type_ids\" are used to indicate whether this is the first\n",
+ " # sequence or the second sequence. The embedding vectors for `type=0` and\n",
+ " # `type=1` were learned during pre-training and are added to the wordpiece\n",
+ " # embedding vector (and position vector). This is not *strictly* necessary\n",
+ " # since the [SEP] token unambiguously separates the sequences, but it makes\n",
+ " # it easier for the model to learn the concept of sequences.\n",
+ " #\n",
+ " # For classification tasks, the first vector (corresponding to [CLS]) is\n",
+ " # used as as the \"sentence vector\". Note that this only makes sense because\n",
+ " # the entire model is fine-tuned.\n",
+ " tokens += [sep_token]\n",
+ " token_boxes += [sep_token_box]\n",
+ " actual_bboxes += [[0, 0, width, height]]\n",
+ " label_ids += [pad_token_label_id]\n",
+ " if sep_token_extra:\n",
+ " # roberta uses an extra separator b/w pairs of sentences\n",
+ " tokens += [sep_token]\n",
+ " token_boxes += [sep_token_box]\n",
+ " actual_bboxes += [[0, 0, width, height]]\n",
+ " label_ids += [pad_token_label_id]\n",
+ " segment_ids = [sequence_a_segment_id] * len(tokens)\n",
+ "\n",
+ " if cls_token_at_end:\n",
+ " tokens += [cls_token]\n",
+ " token_boxes += [cls_token_box]\n",
+ " actual_bboxes += [[0, 0, width, height]]\n",
+ " label_ids += [pad_token_label_id]\n",
+ " segment_ids += [cls_token_segment_id]\n",
+ " else:\n",
+ " tokens = [cls_token] + tokens\n",
+ " token_boxes = [cls_token_box] + token_boxes\n",
+ " actual_bboxes = [[0, 0, width, height]] + actual_bboxes\n",
+ " label_ids = [pad_token_label_id] + label_ids\n",
+ " segment_ids = [cls_token_segment_id] + segment_ids\n",
+ "\n",
+ " input_ids = tokenizer.convert_tokens_to_ids(tokens)\n",
+ "\n",
+ " # The mask has 1 for real tokens and 0 for padding tokens. Only real\n",
+ " # tokens are attended to.\n",
+ " input_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\n",
+ "\n",
+ " # Zero-pad up to the sequence length.\n",
+ " padding_length = max_seq_length - len(input_ids)\n",
+ " if pad_on_left:\n",
+ " input_ids = ([pad_token] * padding_length) + input_ids\n",
+ " input_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + input_mask\n",
+ " segment_ids = ([pad_token_segment_id] * padding_length) + segment_ids\n",
+ " label_ids = ([pad_token_label_id] * padding_length) + label_ids\n",
+ " token_boxes = ([pad_token_box] * padding_length) + token_boxes\n",
+ " else:\n",
+ " input_ids += [pad_token] * padding_length\n",
+ " input_mask += [0 if mask_padding_with_zero else 1] * padding_length\n",
+ " segment_ids += [pad_token_segment_id] * padding_length\n",
+ " label_ids += [pad_token_label_id] * padding_length\n",
+ " token_boxes += [pad_token_box] * padding_length\n",
+ "\n",
+ " assert len(input_ids) == max_seq_length\n",
+ " assert len(input_mask) == max_seq_length\n",
+ " assert len(segment_ids) == max_seq_length\n",
+ " assert len(label_ids) == max_seq_length\n",
+ " assert len(token_boxes) == max_seq_length\n",
+ "\n",
+ " if ex_index < 5:\n",
+ " logger.info(\"*** Example ***\")\n",
+ " logger.info(\"guid: %s\", example.guid)\n",
+ " logger.info(\"tokens: %s\", \" \".join([str(x) for x in tokens]))\n",
+ " logger.info(\"input_ids: %s\", \" \".join([str(x) for x in input_ids]))\n",
+ " logger.info(\"input_mask: %s\", \" \".join([str(x) for x in input_mask]))\n",
+ " logger.info(\"segment_ids: %s\", \" \".join([str(x) for x in segment_ids]))\n",
+ " logger.info(\"label_ids: %s\", \" \".join([str(x) for x in label_ids]))\n",
+ " logger.info(\"boxes: %s\", \" \".join([str(x) for x in token_boxes]))\n",
+ " logger.info(\"actual_bboxes: %s\", \" \".join([str(x) for x in actual_bboxes]))\n",
+ "\n",
+ " features.append(\n",
+ " InputFeatures(\n",
+ " input_ids=input_ids,\n",
+ " input_mask=input_mask,\n",
+ " segment_ids=segment_ids,\n",
+ " label_ids=label_ids,\n",
+ " boxes=token_boxes,\n",
+ " actual_bboxes=actual_bboxes,\n",
+ " file_name=file_name,\n",
+ " page_size=page_size,\n",
+ " )\n",
+ " )\n",
+ " return features"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "id": "HUJftzeBWh2S"
+ },
+ "outputs": [],
+ "source": [
+ "from transformers import LayoutLMTokenizer\n",
+ "\n",
+ "# from .unilm.layoutlm.data.funsd import FunsdDataset, InputFeatures\n",
+ "from torch.utils.data import DataLoader, RandomSampler, SequentialSampler\n",
+ "\n",
+ "batch_size = 16\n",
+ "args = {\n",
+ " \"local_rank\": -1,\n",
+ " \"overwrite_cache\": True,\n",
+ " \"data_dir\": \"data/\",\n",
+ " \"model_name_or_path\": \"microsoft/layoutlm-base-uncased\",\n",
+ " \"max_seq_length\": 512,\n",
+ " \"model_type\": \"layoutlm\",\n",
+ "}\n",
+ "\n",
+ "\n",
+ "# class to turn the keys of a dict into attributes (thanks Stackoverflow)\n",
+ "class AttrDict(dict):\n",
+ " def __init__(self, *args, **kwargs):\n",
+ " super(AttrDict, self).__init__(*args, **kwargs)\n",
+ " self.__dict__ = self\n",
+ "\n",
+ "\n",
+ "args = AttrDict(args)\n",
+ "\n",
+ "tokenizer = LayoutLMTokenizer.from_pretrained(\"microsoft/layoutlm-base-uncased\")\n",
+ "\n",
+ "# the LayoutLM authors already defined a specific FunsdDataset, so we are going to use this here\n",
+ "train_dataset = FunsdDataset(args, tokenizer, labels, pad_token_label_id, mode=\"train\")\n",
+ "train_sampler = RandomSampler(train_dataset)\n",
+ "train_dataloader = DataLoader(train_dataset, sampler=train_sampler, batch_size=batch_size)\n",
+ "\n",
+ "eval_dataset = FunsdDataset(args, tokenizer, labels, pad_token_label_id, mode=\"test\")\n",
+ "eval_sampler = SequentialSampler(eval_dataset)\n",
+ "eval_dataloader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=batch_size)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "18NMUBzgOdqu",
+ "outputId": "eef47b70-3a9a-4b19-be6b-95900c58337b"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "10"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(train_dataloader)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "toFjxtn71B1U",
+ "outputId": "f4651896-cafc-449a-98b4-c81f41177e6d"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(eval_dataloader)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 137
+ },
+ "id": "RhINSBw9I24G",
+ "outputId": "28738ce2-617c-47d3-b8c9-f949d3066d60"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'[CLS] account agency ss : date 1 / 31 / 88 insert signed 91581919 4th new albany tribune advertisements. bookkeeper mar 08 reco affidavit of performance from newspaper new albany tribune harley davidson cigarettes lorillard media service state of county of indiana ) floyd ) before me a notary public, personally appeared holly inzer who being duly sworn, says that ( he ) ( she ) is of the abovementioned newspaper and that display ads for the above account were made through the aforesaid newspaper during the month of january, 1988 as follows : column inches exclusive advertising for harley davidson cigarettes we hereby certify charges shown above on dates per attached bill are true and correct as billed to the account in upper right hand corner of the affidavit and are exclusive sworn to and subscribed before me this day of march, 1988 in testimony whereof i have set my hand and seal the day and year aforesaid. my commission expires : 2 - 9 - 90 betty j. murphy ( notary public ) [SEP] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD]'"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "batch = next(iter(train_dataloader))\n",
+ "input_ids = batch[0][0]\n",
+ "tokenizer.decode(input_ids)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "66cEmLDoUFcm"
+ },
+ "source": [
+ "## Define and fine-tune the model\n",
+ "\n",
+ "As this is a sequence labeling task, we are going to load `LayoutLMForTokenClassification` (the base sized model) from the hub. We are going to fine-tune it on a downstream task, namely FUNSD."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "LoraConfig(task_type=, peft_type=, auto_mapping=None, base_model_name_or_path=None, revision=None, inference_mode=False, r=16, target_modules=None, exclude_modules=None, lora_alpha=16, lora_dropout=0.1, fan_in_fan_out=False, bias='all', use_rslora=False, modules_to_save=None, init_lora_weights=True, layers_to_transform=None, layers_pattern=None, rank_pattern={}, alpha_pattern={}, megatron_config=None, megatron_core='megatron.core', trainable_token_indices=None, loftq_config={}, eva_config=None, corda_config=None, use_dora=False, use_qalora=False, qalora_group_size=16, layer_replication=None, runtime_config=LoraRuntimeConfig(ephemeral_gpu_offload=False), lora_bias=False, target_parameters=None)"
+ ]
+ },
+ "execution_count": 27,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from peft import get_peft_config, PeftModel, get_peft_model, LoraConfig, TaskType\n",
+ "\n",
+ "peft_config = LoraConfig(\n",
+ " task_type=TaskType.TOKEN_CLS, inference_mode=False, r=16, lora_alpha=16, lora_dropout=0.1, bias=\"all\"\n",
+ ")\n",
+ "peft_config"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000,
+ "referenced_widgets": [
+ "da1094982d044ab28eb0effebbfcbb78",
+ "513e00b619924f5693259cd919a927ab",
+ "63e819a04f6e4829838c0e30e65516ed",
+ "d1c3e1a66db04227a74ef8d6481d6daf",
+ "c75f0da13a1e4dbe94800711d55390a6",
+ "31642aacae2a44879960da09f938ecc4",
+ "138a6b922e454ebbaeb315ecd5f476b8",
+ "a8126ba98376402888e9ba344cf1c538"
+ ]
+ },
+ "id": "xIdOsFBiTsuw",
+ "outputId": "95e8811c-025a-41a0-9d03-4285a17f2a9b"
+ },
+ "outputs": [],
+ "source": [
+ "from transformers import LayoutLMForTokenClassification\n",
+ "import torch\n",
+ "from transformers import set_seed\n",
+ "\n",
+ "seed = 100\n",
+ "set_seed(seed)\n",
+ "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+ "\n",
+ "model = LayoutLMForTokenClassification.from_pretrained(\"microsoft/layoutlm-base-uncased\", num_labels=num_labels)\n",
+ "model = get_peft_model(model, peft_config)\n",
+ "model.to(device)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(model.model.layoutlm.encoder.layer[0].attention.self.query.weight)\n",
+ "print(model.model.layoutlm.encoder.layer[0].attention.self.query.lora_A.default.weight)\n",
+ "print(model.model.classifier.weight)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "3weFr_pz1mla"
+ },
+ "source": [
+ "Now we can start training:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "Yu0qePs2cRKo",
+ "outputId": "cdbb9a03-eb9b-4740-bbe3-da06b9192bae"
+ },
+ "outputs": [],
+ "source": [
+ "from transformers import get_linear_schedule_with_warmup\n",
+ "from tqdm import tqdm\n",
+ "\n",
+ "num_train_epochs = 100\n",
+ "\n",
+ "optimizer = torch.optim.AdamW(model.parameters(), lr=3e-3)\n",
+ "lr_scheduler = get_linear_schedule_with_warmup(\n",
+ " optimizer=optimizer,\n",
+ " num_warmup_steps=0.06 * (len(train_dataloader) * num_train_epochs),\n",
+ " num_training_steps=(len(train_dataloader) * num_train_epochs),\n",
+ ")\n",
+ "\n",
+ "\n",
+ "global_step = 0\n",
+ "\n",
+ "t_total = len(train_dataloader) * num_train_epochs # total number of training steps\n",
+ "\n",
+ "# put the model in training mode\n",
+ "model.train()\n",
+ "for epoch in range(num_train_epochs):\n",
+ " for batch in tqdm(train_dataloader, desc=\"Training\"):\n",
+ " input_ids = batch[0].to(device)\n",
+ " bbox = batch[4].to(device)\n",
+ " attention_mask = batch[1].to(device)\n",
+ " token_type_ids = batch[2].to(device)\n",
+ " labels = batch[3].to(device)\n",
+ "\n",
+ " # forward pass\n",
+ " outputs = model(\n",
+ " input_ids=input_ids, bbox=bbox, attention_mask=attention_mask, token_type_ids=token_type_ids, labels=labels\n",
+ " )\n",
+ " loss = outputs.loss\n",
+ "\n",
+ " # print loss every 100 steps\n",
+ " if global_step % 10 == 0:\n",
+ " print(f\"Loss after {global_step} steps: {loss.item()}\")\n",
+ "\n",
+ " # backward pass to get the gradients\n",
+ " loss.backward()\n",
+ "\n",
+ " # print(\"Gradients on classification head:\")\n",
+ " # print(model.classifier.weight.grad[6,:].sum())\n",
+ "\n",
+ " # update\n",
+ " optimizer.step()\n",
+ " lr_scheduler.step()\n",
+ " optimizer.zero_grad()\n",
+ " global_step += 1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "u1rNslap5Y3N",
+ "outputId": "877183d4-1d29-4d09-bd3a-0e5f88611dc8"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Evaluating: 100%|██████████| 4/4 [00:00<00:00, 10.90it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "{'loss': 1.467050313949585, 'precision': 0.7295341474445952, 'recall': 0.806903451725863, 'f1': 0.7662707838479811}\n"
+ ]
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "from seqeval.metrics import (\n",
+ " classification_report,\n",
+ " f1_score,\n",
+ " precision_score,\n",
+ " recall_score,\n",
+ ")\n",
+ "\n",
+ "eval_loss = 0.0\n",
+ "nb_eval_steps = 0\n",
+ "preds = None\n",
+ "out_label_ids = None\n",
+ "\n",
+ "# put model in evaluation mode\n",
+ "model.eval()\n",
+ "for batch in tqdm(eval_dataloader, desc=\"Evaluating\"):\n",
+ " with torch.no_grad():\n",
+ " input_ids = batch[0].to(device)\n",
+ " bbox = batch[4].to(device)\n",
+ " attention_mask = batch[1].to(device)\n",
+ " token_type_ids = batch[2].to(device)\n",
+ " labels = batch[3].to(device)\n",
+ "\n",
+ " # forward pass\n",
+ " outputs = model(\n",
+ " input_ids=input_ids, bbox=bbox, attention_mask=attention_mask, token_type_ids=token_type_ids, labels=labels\n",
+ " )\n",
+ " # get the loss and logits\n",
+ " tmp_eval_loss = outputs.loss\n",
+ " logits = outputs.logits\n",
+ "\n",
+ " eval_loss += tmp_eval_loss.item()\n",
+ " nb_eval_steps += 1\n",
+ "\n",
+ " # compute the predictions\n",
+ " if preds is None:\n",
+ " preds = logits.detach().cpu().numpy()\n",
+ " out_label_ids = labels.detach().cpu().numpy()\n",
+ " else:\n",
+ " preds = np.append(preds, logits.detach().cpu().numpy(), axis=0)\n",
+ " out_label_ids = np.append(out_label_ids, labels.detach().cpu().numpy(), axis=0)\n",
+ "\n",
+ "# compute average evaluation loss\n",
+ "eval_loss = eval_loss / nb_eval_steps\n",
+ "preds = np.argmax(preds, axis=2)\n",
+ "\n",
+ "out_label_list = [[] for _ in range(out_label_ids.shape[0])]\n",
+ "preds_list = [[] for _ in range(out_label_ids.shape[0])]\n",
+ "\n",
+ "for i in range(out_label_ids.shape[0]):\n",
+ " for j in range(out_label_ids.shape[1]):\n",
+ " if out_label_ids[i, j] != pad_token_label_id:\n",
+ " out_label_list[i].append(label_map[out_label_ids[i][j]])\n",
+ " preds_list[i].append(label_map[preds[i][j]])\n",
+ "\n",
+ "results = {\n",
+ " \"loss\": eval_loss,\n",
+ " \"precision\": precision_score(out_label_list, preds_list),\n",
+ " \"recall\": recall_score(out_label_list, preds_list),\n",
+ " \"f1\": f1_score(out_label_list, preds_list),\n",
+ "}\n",
+ "print(results)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "trainable params: 702,733 || all params: 113,237,786 || trainable%: 0.6206\n"
+ ]
+ }
+ ],
+ "source": [
+ "model.print_trainable_parameters()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model.save_pretrained(\"peft_layoutlm\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2.8M\t./peft_layoutlm/adapter_model.safetensors\n"
+ ]
+ }
+ ],
+ "source": [
+ "!du -h ./peft_layoutlm/adapter_model.safetensors"
+ ]
+ }
+ ],
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "collapsed_sections": [],
+ "include_colab_link": true,
+ "name": "Fine-tuning LayoutLMForTokenClassification on FUNSD.ipynb",
+ "provenance": [],
+ "toc_visible": true
+ },
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.11.13"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+ }
+ },
+ "widgets": {
+ "application/vnd.jupyter.widget-state+json": {
+ "138a6b922e454ebbaeb315ecd5f476b8": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "DescriptionStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "description_width": ""
+ }
+ },
+ "31642aacae2a44879960da09f938ecc4": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "513e00b619924f5693259cd919a927ab": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "63e819a04f6e4829838c0e30e65516ed": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "FloatProgressModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "ProgressView",
+ "bar_style": "success",
+ "description": "Downloading: 100%",
+ "description_tooltip": null,
+ "layout": "IPY_MODEL_31642aacae2a44879960da09f938ecc4",
+ "max": 453093832,
+ "min": 0,
+ "orientation": "horizontal",
+ "style": "IPY_MODEL_c75f0da13a1e4dbe94800711d55390a6",
+ "value": 453093832
+ }
+ },
+ "a8126ba98376402888e9ba344cf1c538": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.2.0",
+ "_model_name": "LayoutModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "LayoutView",
+ "align_content": null,
+ "align_items": null,
+ "align_self": null,
+ "border": null,
+ "bottom": null,
+ "display": null,
+ "flex": null,
+ "flex_flow": null,
+ "grid_area": null,
+ "grid_auto_columns": null,
+ "grid_auto_flow": null,
+ "grid_auto_rows": null,
+ "grid_column": null,
+ "grid_gap": null,
+ "grid_row": null,
+ "grid_template_areas": null,
+ "grid_template_columns": null,
+ "grid_template_rows": null,
+ "height": null,
+ "justify_content": null,
+ "justify_items": null,
+ "left": null,
+ "margin": null,
+ "max_height": null,
+ "max_width": null,
+ "min_height": null,
+ "min_width": null,
+ "object_fit": null,
+ "object_position": null,
+ "order": null,
+ "overflow": null,
+ "overflow_x": null,
+ "overflow_y": null,
+ "padding": null,
+ "right": null,
+ "top": null,
+ "visibility": null,
+ "width": null
+ }
+ },
+ "c75f0da13a1e4dbe94800711d55390a6": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "ProgressStyleModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/base",
+ "_view_module_version": "1.2.0",
+ "_view_name": "StyleView",
+ "bar_color": null,
+ "description_width": "initial"
+ }
+ },
+ "d1c3e1a66db04227a74ef8d6481d6daf": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "HTMLModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "HTMLView",
+ "description": "",
+ "description_tooltip": null,
+ "layout": "IPY_MODEL_a8126ba98376402888e9ba344cf1c538",
+ "placeholder": "",
+ "style": "IPY_MODEL_138a6b922e454ebbaeb315ecd5f476b8",
+ "value": " 453M/453M [00:15<00:00, 30.0MB/s]"
+ }
+ },
+ "da1094982d044ab28eb0effebbfcbb78": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_dom_classes": [],
+ "_model_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_model_name": "HBoxModel",
+ "_view_count": null,
+ "_view_module": "@jupyter-widgets/controls",
+ "_view_module_version": "1.5.0",
+ "_view_name": "HBoxView",
+ "box_style": "",
+ "children": [
+ "IPY_MODEL_63e819a04f6e4829838c0e30e65516ed",
+ "IPY_MODEL_d1c3e1a66db04227a74ef8d6481d6daf"
+ ],
+ "layout": "IPY_MODEL_513e00b619924f5693259cd919a927ab"
+ }
+ }
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/token_classification/requirements.txt b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/token_classification/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2cde65e15268b67b28864f3fd7e6932fb7949802
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/token_classification/requirements.txt
@@ -0,0 +1,7 @@
+transformers
+accelerate
+evaluate
+tqdm
+datasets
+Pillow
+torchvision
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/waveft_finetuning/README.md b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/waveft_finetuning/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..8b26ab177341df2db5f466e754a84904a3ecad98
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/waveft_finetuning/README.md
@@ -0,0 +1,64 @@
+
+
+# WaveFT: Wavelet Fine-Tuning
+
+## Introduction
+[WaveFT](https://huggingface.co/papers/2505.12532) is a novel parameter-efficient fine-tuning (PEFT) method that introduces sparse updates in the **wavelet domain** of residual matrices. Unlike LoRA, which is constrained by discrete low-rank choices, WaveFT enables fine-grained control over the number of trainable parameters by directly learning a sparse set of coefficients in the transformed space. These coefficients are then mapped back to the weight domain via the Inverse Discrete Wavelet Transform (IDWT), producing high-rank updates without incurring inference overhead.
+
+## Quick start
+```python
+import torch
+from peft import WaveFTConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from trl import SFTConfig, SFTTrainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m", dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
+dataset = load_dataset("imdb", split="train[:1%]")
+waveft_config = WaveFTConfig(
+ n_frequency=2592,
+)
+peft_model = get_peft_model(model, waveft_config)
+training_args = SFTConfig(dataset_text_field="text", max_length=128)
+trainer = SFTTrainer(
+ model=peft_model,
+ train_dataset=dataset,
+ processing_class=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("waveft-opt-350m")
+```
+
+For more options and a more detailed example code, you can refer to waveft finetuning script.
+Run the script simply by running:
+```bash
+python3 examples/waveft_finetuning/waveft_finetuning.py --base_model facebook/opt-350m
+```
+
+If you want to run DDP by [accelerate](https://huggingface.co/docs/accelerate/en/index), please run `accelerate config` to set your ddp config, and run:
+```bash
+accelerate launch examples/waveft_finetuning/waveft_finetuning.py --base_model facebook/opt-350m
+```
+please add `--device_map cpu` if you want to run finetune on CPU.
+
+## Use the model
+You can load and use the model as any other 🤗 PEFT model
+```python
+from peft import PeftModel
+from transformers import AutoTokenizer, AutoModelForCausalLM
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")
+tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
+waveft_model = PeftModel.from_pretrained(model, "waveft-opt-350m")
+```
+
+## Citation
+@misc{bilican2025exploringsparsityparameterefficient,
+ title={Exploring Sparsity for Parameter Efficient Fine Tuning Using Wavelets},
+ author={Ahmet Bilican and M. Akın Yılmaz and A. Murat Tekalp and R. Gökberk Cinbiş},
+ year={2025},
+ eprint={2505.12532},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV},
+ url={https://arxiv.org/abs/2505.12532},
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/waveft_finetuning/waveft_finetuning.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/waveft_finetuning/waveft_finetuning.py
new file mode 100644
index 0000000000000000000000000000000000000000..dfdb6d4ff603c68d93c77a54775a6a27a2a2a1d2
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/waveft_finetuning/waveft_finetuning.py
@@ -0,0 +1,189 @@
+# Copyright 2025-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import os
+from typing import Optional
+
+import torch
+import transformers
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed
+
+from peft import (
+ WaveFTConfig,
+ get_peft_model,
+)
+
+
+def train(
+ base_model: str,
+ data_path: str = "yahma/alpaca-cleaned",
+ output_dir: str = "waveft",
+ batch_size: int = 16,
+ num_epochs: int = 1,
+ learning_rate: float = 3e-4,
+ cutoff_len: int = 256,
+ val_set_size: int = 16,
+ eval_step: int = 100,
+ save_step: int = 100,
+ device_map: str = "auto",
+ waveft_n_frequency: int = 2592,
+ waveft_target_modules: Optional[list[str]] = None,
+ waveft_scaling: float = 25.0,
+ waveft_wavelet_family: str = "db1",
+ waveft_use_idwt: bool = True,
+ dtype: str = "float16",
+ seed: Optional[int] = None,
+):
+ # Set device_map to the right place when enabling DDP.
+ world_size = int(os.environ.get("WORLD_SIZE", "0")) or int(os.environ.get("PMI_SIZE", "0"))
+ if world_size > 1 and device_map != "cpu":
+ from accelerate import Accelerator
+
+ device_map = {"": Accelerator().process_index}
+ # Set seed
+ if seed is not None:
+ set_seed(seed)
+ model_kwargs = {"dtype": getattr(torch, dtype), "device_map": device_map}
+ model = AutoModelForCausalLM.from_pretrained(base_model, **model_kwargs)
+
+ tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
+ # For some tokenizer with no pad token like llama
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+
+ def tokenize(prompt, add_eos_token=True):
+ result = tokenizer(
+ prompt,
+ truncation=True,
+ max_length=cutoff_len,
+ padding=False,
+ return_tensors=None,
+ )
+ if (
+ result["input_ids"][-1] != tokenizer.eos_token_id
+ and len(result["input_ids"]) < cutoff_len
+ and add_eos_token
+ ):
+ result["input_ids"].append(tokenizer.eos_token_id)
+ result["attention_mask"].append(1)
+
+ result["labels"] = result["input_ids"].copy()
+
+ return result
+
+ def generate_and_tokenize_prompt(example):
+ full_prompt = generate_prompt(example)
+ tokenized_full_prompt = tokenize(full_prompt)
+ return tokenized_full_prompt
+
+ config = WaveFTConfig(
+ n_frequency=waveft_n_frequency,
+ scaling=waveft_scaling,
+ wavelet_family=waveft_wavelet_family,
+ use_idwt=waveft_use_idwt,
+ target_modules=waveft_target_modules,
+ task_type="CAUSAL_LM",
+ )
+
+ model = get_peft_model(model, config)
+
+ data = load_dataset(data_path)
+
+ train_val = data["train"].train_test_split(test_size=val_set_size, shuffle=True, seed=42)
+ train_data = train_val["train"].shuffle().map(generate_and_tokenize_prompt)
+ val_data = train_val["test"].shuffle().map(generate_and_tokenize_prompt)
+
+ trainer = transformers.Trainer(
+ model=model,
+ train_dataset=train_data,
+ eval_dataset=val_data,
+ args=transformers.TrainingArguments(
+ per_device_train_batch_size=batch_size,
+ warmup_steps=100,
+ num_train_epochs=num_epochs,
+ learning_rate=learning_rate,
+ logging_steps=100,
+ optim="adamw_torch",
+ eval_strategy="steps",
+ save_strategy="steps",
+ eval_steps=eval_step,
+ save_steps=save_step,
+ output_dir=output_dir,
+ save_total_limit=3,
+ load_best_model_at_end=True,
+ ddp_find_unused_parameters=False if world_size > 1 else None,
+ ),
+ data_collator=transformers.DataCollatorForSeq2Seq(
+ tokenizer, pad_to_multiple_of=8, return_tensors="pt", padding=True
+ ),
+ )
+ trainer.train()
+ model.save_pretrained(output_dir)
+
+
+def generate_prompt(example):
+ return f"""Below is an instruction that describes a task. Write a response that appropriately completes the request.
+ ### Instruction:
+ {example["instruction"]}
+ ### Response:
+ {example["output"]}"""
+
+
+if __name__ == "__main__":
+ import argparse
+
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--base_model", type=str)
+ parser.add_argument("--data_path", type=str, default="yahma/alpaca-cleaned")
+ parser.add_argument("--output_dir", type=str, default="waveft")
+ parser.add_argument("--batch_size", type=int, default=16)
+ parser.add_argument("--num_epochs", type=int, default=1)
+ parser.add_argument("--learning_rate", type=float, default=3e-4)
+ parser.add_argument("--cutoff_len", type=int, default=256)
+ parser.add_argument("--val_set_size", type=int, default=16)
+ parser.add_argument("--eval_step", type=int, default=100)
+ parser.add_argument("--save_step", type=int, default=100)
+ parser.add_argument("--device_map", type=str, default="auto")
+ parser.add_argument("--waveft_n_frequency", type=int, default=2592)
+ parser.add_argument("--waveft_target_modules", type=str, default=None)
+ parser.add_argument("--waveft_scaling", type=float, default=25.0)
+ parser.add_argument("--waveft_wavelet_family", type=str, default="db1")
+ parser.add_argument("--waveft_use_idwt", action="store_true", default=True)
+ parser.add_argument("--dtype", type=str, default="float16")
+ parser.add_argument("--seed", type=int, default=None)
+
+ args = parser.parse_args()
+
+ train(
+ base_model=args.base_model,
+ data_path=args.data_path,
+ output_dir=args.output_dir,
+ batch_size=args.batch_size,
+ num_epochs=args.num_epochs,
+ learning_rate=args.learning_rate,
+ cutoff_len=args.cutoff_len,
+ val_set_size=args.val_set_size,
+ eval_step=args.eval_step,
+ save_step=args.save_step,
+ device_map=args.device_map,
+ waveft_n_frequency=args.waveft_n_frequency,
+ waveft_target_modules=args.waveft_target_modules,
+ waveft_scaling=args.waveft_scaling,
+ waveft_wavelet_family=args.waveft_wavelet_family,
+ waveft_use_idwt=args.waveft_use_idwt,
+ dtype=args.dtype,
+ seed=args.seed,
+ )
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/xlora/README.md b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/xlora/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..ae81cfcd45e5940262504a95dc4805d45bdf280d
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/xlora/README.md
@@ -0,0 +1,15 @@
+# X-LoRA examples
+
+## `xlora_inference_mistralrs.py`
+
+Perform inference of an X-LoRA model using the inference engine mistral.rs.
+
+Mistral.rs supports many base models besides Mistral, and can load models directly from saved LoRA checkpoints. Check out [adapter model docs](https://github.com/EricLBuehler/mistral.rs/blob/master/docs/ADAPTER_MODELS.md) and the [models support matrix](https://github.com/EricLBuehler/mistral.rs?tab=readme-ov-file#support-matrix).
+
+Mistral.rs features X-LoRA support and incorporates techniques such as a dual-KV cache, continuous batching, Paged Attention, and optional non granular scalings, will allow vastly improved throughput.
+
+Links:
+
+- Installation: https://github.com/EricLBuehler/mistral.rs/blob/master/mistralrs-pyo3/README.md
+- Runnable example: https://github.com/EricLBuehler/mistral.rs/blob/master/examples/python/xlora_zephyr.py
+- Adapter model docs and making the ordering file: https://github.com/EricLBuehler/mistral.rs/blob/master/docs/ADAPTER_MODELS.md
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/xlora/xlora_inference_mistralrs.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/xlora/xlora_inference_mistralrs.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a3f4de4261ea5613aa3acbfc12930bc89f1344b
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/xlora/xlora_inference_mistralrs.py
@@ -0,0 +1,25 @@
+from mistralrs import ChatCompletionRequest, Runner, Which
+
+
+runner = Runner(
+ which=Which.XLora(
+ tok_model_id=None, # Automatically determine from ordering file
+ model_id=..., # Model ID of the base model (local path of HF model ID)
+ xlora_model_id=..., # X-LoRA Model ID of the base model (local path of HF model ID)
+ order=..., # Ordering file to ensure compatability with PEFT
+ tgt_non_granular_index=3, # Only generate scalings for the first 3 decoding tokens, and then use the last generated one
+ )
+)
+
+res = runner.send_chat_completion_request(
+ ChatCompletionRequest(
+ model="mistral",
+ messages=[{"role": "user", "content": "Tell me a story about 2 low rank matrices."}],
+ max_tokens=256,
+ presence_penalty=1.0,
+ top_p=0.1,
+ temperature=0.5,
+ )
+)
+print(res.choices[0].message.content)
+print(res.usage)
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/Makefile b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..baa5c004b1f93beba77fc9471a39848b7b32be86
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/Makefile
@@ -0,0 +1,96 @@
+# Makefile for running MetaMathQA experiments.
+
+# --- Configuration ---
+PYTHON := python
+RUN_SCRIPT := run.py
+EXPERIMENTS_DIR := experiments
+RESULTS_DIR := results
+
+OPTIONAL_FLAGS =
+
+ifdef UPLOAD_BUCKET
+ OPTIONAL_FLAGS += --bucket_name "${UPLOAD_BUCKET}"
+endif
+
+# --- Automatic Experiment and Result Discovery ---
+
+# 1. Find all experiment directories by looking for adapter_config.json files.
+# This gives us a list like: experiments/lora/llama-3.2-3B-rank32 ...
+EXPERIMENT_PATHS := $(shell find $(EXPERIMENTS_DIR) \
+ -name "adapter_config.json" -or \
+ -name "training_params.json" | xargs dirname | sort -u)
+
+# 2. Define a function to replace all occurrences of a character in a string.
+# This is needed to replicate the result naming logic from run.py (e.g., "lora/foo" -> "lora-foo").
+# Usage: $(call replace-all, string, char_to_replace, replacement_char)
+replace-all = $(if $(findstring $(2),$(1)),$(call replace-all,$(subst $(2),$(3),$(1)),$(2),$(3)),$(1))
+
+# 3. Define a function to convert an experiment path to its flat result file path.
+# e.g., "experiments/lora/llama-3.2-3B-rank32" -> "results/lora-llama-3.2-3B-rank32.json"
+exp_to_res = $(RESULTS_DIR)/$(call replace-all,$(patsubst $(EXPERIMENTS_DIR)/%,%,$(1)),/,--).json
+
+# 4. Generate the list of all target result files we want to build.
+RESULT_FILES := $(foreach exp,$(EXPERIMENT_PATHS),$(call exp_to_res,$(exp)))
+
+
+# --- Main Rules ---
+
+# The default 'all' target depends on all possible result files.
+# Running `make` or `make all` will check and run any outdated or missing experiments.
+all: $(RESULT_FILES)
+
+
+# --- Dynamic Rule Generation ---
+
+# This is the core logic. We dynamically generate a specific Makefile rule for each experiment found.
+# This avoids a complex pattern rule and makes the logic clearer.
+define EXPERIMENT_template
+# Input $1: The full experiment path (e.g., experiments/lora/llama-3.2-3B-rank32)
+
+# Define the rule:
+# The target is the result file (e.g., results/lora-llama-3.2-3B-rank32.json).
+# The dependencies are its config files, code changes need to be audited manually since they can
+# vary in degree of importance. Note that we explicitly ignore when the script fails to run
+# so that the other experiments still have a chance to run.
+$(call exp_to_res,$(1)): $(wildcard $(1)/adapter_config.json) $(wildcard $(1)/training_params.json)
+ @echo "---"
+ @echo "Running experiment: $(1)"
+ -$(PYTHON) $(RUN_SCRIPT) $(OPTIONAL_FLAGS) -v $(1)
+ @echo "Finished: $$@"
+ @echo "---"
+
+endef
+
+# This command iterates through every found experiment path and evaluates the template,
+# effectively stamping out a unique, explicit rule for each one.
+$(foreach exp_path,$(EXPERIMENT_PATHS),$(eval $(call EXPERIMENT_template,$(exp_path))))
+
+
+# --- Utility Rules ---
+
+.PHONY: all clean list dump_rules
+
+# The 'clean' rule removes all generated results.
+clean:
+ @echo "Cleaning results directory..."
+ @([ -n "$(wildcard $(RESULTS_DIR)/*.json)" ] && rm $(RESULTS_DIR)/*.json) || exit 0
+
+# The 'list' rule is for debugging. It shows the discovered experiments
+# and the result files the Makefile expects to create for them.
+list:
+ @echo "Discovered experiment configurations:"
+ @$(foreach exp,$(EXPERIMENT_PATHS),echo " - $(exp)/adapter_config.json";)
+ @echo "\nTarget result files:"
+ @$(foreach res,$(RESULT_FILES),echo " - $(res)";)
+
+# The 'dump_rules' rule is for debugging. It dumps all dynamically defined rules.
+define newline
+
+
+endef
+define DUMPED_RULES
+ $(foreach exp_path,$(EXPERIMENT_PATHS),$(call EXPERIMENT_template,$(exp_path)))
+endef
+
+dump_rules:
+ @echo -e "$(subst $(newline),\n,${DUMPED_RULES})"
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/README.md b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..ce896169931a7816c2bb7cb022177df12297eb57
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/README.md
@@ -0,0 +1,248 @@
+# PEFT method comparison on the MetaMathQA and GSM8K datasets
+
+## Goal
+
+This goal is to provide a benchmarking framework for the different PEFT methods that are implemented. It is important that evaluating different PEFT methods is reproducible, idempotent, and version-controlled. Results for more PEFT methods can be added over time.
+
+## Dataset
+
+This task trains on the [MetaMathQA]((https://huggingface.co/datasets/meta-math/MetaMathQA)) dataset and validates/tests on the [GSM8K](https://huggingface.co/datasets/openai/gsm8k) dataset ("main").
+
+For the model to attain good accuracy, it needs to learn to adhere to the output format and it must express basic chain of thought reasoning capabilities to get to the correct result in the first place. The task is challenging for models in the sub 7B parameter range.
+
+The train set uses the whole of MetaMathQA. The validation set is a random sample from the train set of GSM8K. The test set is the whole of the GSM8K test set.
+
+## Running
+
+Create an experiment in the `experiment/` folder of your choice and give it a name (the name itself does not matter but helps identify the experiment). An example would be `experiments/lora/llama-3.2-3B-rank32/`. Inside that directory, create 2 files:
+
+- `adapter_config.json`
+- Optional: `training_parameters.json`
+
+Once you created these two files, you can either
+
+- run the whole suite using by simply calling `make` (takes >24h)
+- run one specific experiment by calling `make results/-.json`,
+ for example `results/vblora-llama-3.2-3B-default.json`
+
+You can get a list of all runnable experiments by running `make list`, e.g.:
+```
+% make list (git)-[method-comparison-results] ⛓ peft
+Discovered experiment configurations:
+ - experiments/ptuning/llama-3.2-3B-default/adapter_config.json
+ [...]
+ - experiments/vblora/llama-3.2-3B-default/adapter_config.json
+
+Target result files:
+ - results/ptuning-llama-3.2-3B-default.json
+ [...]
+ - results/vblora-llama-3.2-3B-default.json
+```
+
+In case you want to force the execution of an experiment, you can simply `touch` the respective adapter config
+without modifying it. For example:
+
+ touch experiments/vblora/llama-3.2-3B-default/adapter_config.json
+ make
+
+to run the VBLoRA default experiment again.
+
+If you set `UPLOAD_BUCKET="your_user/bucket_name"` as an environment variable prior to starting experiments via `make`, all experiments will be called with the `--bucket_name $UPLOAD_BUCKET` parameter and therefore store the checkpoints in that bucket. _For maintainers_: The default bucket name should be `"peft-internal-testing/metamathqa-checkpoints"`.
+
+### `adapter_config.json`
+
+This must be a valid PEFT configuration. It is easiest to create it programmatically, e.g.:
+
+```python
+from peft import LoraConfig
+
+config = LoraConfig(...)
+config.save_pretrained()
+```
+
+### `training_parameters.json`
+
+There is a default file for the non-PEFT parameters: `default_training_params.json`. This contains all the other parameters that are relevant for training, e.g. the base model id, number of steps, batch size, learning rate, etc. If parameters that differ from the defaults are needed for a specific experiment, place a `training_parameters.json` into the experiment directory and adjust the parameters that need changing. The other parametes are taken from the aforementioned default config.
+
+For an overview of all possible arguments, you can also check the `TrainConfig` `dataclass` in `utils.py`.
+
+#### About `torch.compile`
+
+Right now, compilation is a simple on/off switch in `training_params.json`. There is probably room for optimization here.
+
+Due to the model being switched to `eval` mode for the validation metrics and then back to `train` mode, we will incur a re-compilation. This is acceptable to ensure that validation runs correctly. However, this prevents us from using `torch._dynamo.config.patch(error_on_recompile=True, inline_inbuilt_nn_modules=False)` to detect frequent recompilations. It should be noticeable from the duration of training steps, though, so we're fine with that.
+
+### Runtime performance
+
+Several factors should be considered to achieve a fast runtime performance. Besides the obvious factors like `max_steps` or the base model size, we found the following factors to have a significant impact:
+
+#### Eval batch size
+
+Regarding the `batch_size_eval` parameter, it is quite critical since evaluation takes up a significant portion of the training time and batching helps with reducing that. It should be possible to choose a value that is multiple times higher than the batch size used for training (`batch_size`). You should also pay attention to the size of the validation set -- e.g. if it's 50, don't choose a `batch_size_eval` of 40, as that results in a large batch of 30 and a small batch of 10. 25 might be a better choice. Also, ensure via a quick train run that the batch size does not lead to out of memory errors -- getting this error at the very end on evaluating the test set would be quite a loss of time.
+
+#### Generation length
+
+During testing, we discovered that the validation time is greatly inflated by just a few very long generations. Those can inflate the validation time by a factor of 3 or more. At the same time, we discovered that these long generations do not help with accuracy -- in fact, if they exceed the maximum configured length, they're just cut off mid sentence and would thus produce an accuracy of 0 anyway.
+
+To remedy this, we now set both `max_length` and `max_new_tokens` for the generation kwargs in the default training parameters. Normally, this is not possible when using transformers, as the latter argument overrides the former. However, we have added special logic inside of `get_generation_config` which takes both and chooses the smaller of the two. This way, we can get rid of these excessively long generations, thus considerably reducing eval times, while still guaranteeing a maximum total generation length to guard against OOM errors. Testing showed that this does not hamper test accuracy. It is therefore recommended not to change these settings.
+
+#### Bucketing
+
+The length of the sequences in the training data can vary a lot. Therefore, if samples are taken randomly from the training dataset, we will end up with batches containing very short and very long sequences. This is bad because the batch will be padded to the longest sequence, slowing down training. The obvious solution would be to sort the whole dataset by sequence length, but this is also bad because it introduces an order bias (e.g. first training on only short and then on only long answers).
+
+The solution is to find a trade off between the two factors. This is achieved by the `BucketIterator`. It first creates buckets that contain multiple batches, e.g. 20x the batch size. The bucket is then sorted by sequence length and then batches are yielded from the bucket. Therefore, we have a small order bias within a bucket but not between buckets, stricking a good balance between training speed and training loss.
+
+From practical experiments, for a batch size of 4, a bucket size of 80 provides a good balance with only slightly lower training loss but cutting training time by 25%. For eval, we don't use the iterator since there, the batch size is relatively big and thus there is little upside.
+
+### Start a run
+
+Once everything is set up properly, start a run by using the `run.py` script. Pass `-v` for verbose output to the console (recommended if observing the progress is desired). To save the resulting experiment checkpoints to a huggingface bucket, you can pass the bucket name via the `--bucket_name` parameter (e.g., `"user/my_bucket_name"`). As an example, for `experiments/lora/llama-3.2-3B-rank32/` the invocation would be:
+
+```sh
+python run.py -v experiments/lora/llama-3.2-3B-rank32/
+```
+
+By default, the adapter will be saved in a temporary file for further inspection if needed. The prevent this, add the `--clean` flag to the call.
+
+### Run status
+
+The run can be categorized 3 different states:
+
+1. Main run: You are on the `main` branch and the run ended successfully. The results are stored in the `results` folder and are used for further analysis.
+2. Test run: You are not on the `main` branch and the run ended successfully. The results are stored in the `temporary_results` folder and are not used for further analysis.
+3. The run was cancelled (`ctrl + c`). The results are stored in the `cancelled_results` folder and are not used for further analysis.
+
+## Outputs
+
+Results are stored in one of the result directories. An example output could look like so:
+
+```js
+{
+ "run_info": {
+ "created_at": "2025-03-05T13:50:05+00:00",
+ "total_time": 2711.0915009640157,
+ "experiment_name": "ia3/lr_0.001",
+ "peft_branch": "ben-method-comparison",
+ "train_config": {
+ "model_id": "meta-llama/Llama-3.2-3B",
+ "dtype": "bfloat16",
+ "max_seq_length": 768,
+ "batch_size": 4,
+ "batch_size_eval": 51,
+ "max_steps": 5000,
+ "eval_steps": 250,
+ "compile": false,
+ "query_template": "Question: {query} Think step by step.\nAnswer:",
+ "seed": 0,
+ "grad_norm_clip": 1.0,
+ "optimizer_kwargs": {
+ "lr": 0.001
+ },
+ "lr_scheduler": "cosine",
+ "use_amp": false,
+ "generation_kwargs": {
+ "max_length": 800
+ },
+ "attn_implementation": null
+ },
+ "peft_config": {
+ "task_type": null,
+ "peft_type": "IA3",
+ "auto_mapping": null,
+ "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+ "revision": null,
+ "inference_mode": false,
+ "target_modules": [
+ "v_proj",
+ "k_proj",
+ "down_proj"
+ ],
+ "exclude_modules": null,
+ "feedforward_modules": [
+ "down_proj"
+ ],
+ "fan_in_fan_out": false,
+ "modules_to_save": null,
+ "init_ia3_weights": true
+ }
+ },
+ "train_info": {
+ "accelerator_memory_reserved_avg": 14229219940,
+ "accelerator_memory_max": 24847056896,
+ "accelerator_memory_reserved_99th": 19115624366,
+ "train_time": 2238.65277833899,
+ "file_size": 1157064,
+ "status": "success",
+ "metrics": [
+ {
+ "step": 250,
+ "valid accuracy": 0.0784313725490196,
+ "train loss": 1.1336498007774354,
+ "train samples": 1000
+ },
+ [...]
+ {
+ "step": 5000,
+ "valid accuracy": 0.21568627450980393,
+ "train loss": 0.6345920492410659,
+ "train samples": 20000
+ },
+ {
+ "step": 5000,
+ "test accuracy": 0.35129740518962077,
+ "train loss": 0.6345920492410659,
+ "train samples": 20000,
+ "train total tokens": 4197579
+ }
+ ]
+ },
+ "meta_info": {
+ "model_sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+ "model_created_at": "2024-09-18T15:23:48+00:00",
+ "dataset_sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+ "dataset_created_at": "2023-09-21T17:22:46+00:00",
+ "package_info": {
+ "transformers-version": "4.50.0.dev0",
+ "transformers-commit-hash": "752ef3fd4e70869626ec70657a770a85c0ad9219",
+ "peft-version": "0.14.1.dev0",
+ "peft-commit-hash": "a447a4e5ecd87b7d57733f4df9616a328cf130f4",
+ "datasets-version": "3.3.2",
+ "datasets-commit-hash": null,
+ "bitsandbytes-version": "0.45.2",
+ "bitsandbytes-commit-hash": null,
+ "torch-version": "2.6.0+cu124",
+ "torch-commit-hash": null
+ },
+ "system_info": {
+ "system": "Linux",
+ "release": "6.11.0-17-generic",
+ "version": "#17~24.04.2-Ubuntu SMP PREEMPT_DYNAMIC Mon Jan 20 22:48:29 UTC 2",
+ "machine": "x86_64",
+ "processor": "x86_64",
+ "accelerator": "NVIDIA GeForce RTX 4090"
+ },
+ "pytorch_info": "PyTorch built with: [...]"
+ }
+}
+```
+
+## Dependencies
+
+Apart from the normal PEFT dependencies, ensure that the packages in the `requirements.txt` are installed, e.g. via:
+
+```sh
+python -m pip install -r requirements.txt
+```
+
+Python 3.12+ is required.
+
+## Open tasks
+
+- consider using `DataLoader`
+- consider adding https://github.com/huggingface/Math-Verify
+- consider adding `weight` argument to cross entropy calculation to downweight the EOS token, but it would require calculating the loss manually instead of relying on transformers (see https://github.com/huggingface/transformers/blob/6a876462c308bd7cd7d3ca8e93abaa7d5b02e90e/src/transformers/loss/loss_utils.py#L24-L48)
+- do a sanity check against/comparison with transformers Trainer
+- consider using vLLM to potentially speed up generations, at least for the test set
+- AMP does not appear to help, investigate
+- packing of sequences (but this probably requires adjusting the attention matrix)
+- clean up what gets printed and where (stdout, stderr)
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/cancelled_results/.gitkeep b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/cancelled_results/.gitkeep
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/data.py b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/data.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d060d38463c16d5dc753d5b4a4a896b1b334f8f
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/data.py
@@ -0,0 +1,117 @@
+# Copyright 2025-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+All utilities related to data handling.
+"""
+
+from collections.abc import Callable
+from functools import partial
+
+import datasets
+import numpy as np
+from datasets import Dataset, load_dataset
+
+
+# with a token limit of 768 for query + response, we have to exclude all texts with length > 1304; this leaves 93.8% of
+# the dataset
+CHAR_LIMIT = 1300
+# train/valid/test split -- note that evaluation takes quite long, so don't choose too large sizes for the valid set,
+# since it's run multiple times during training; test is only run once at the end and thus can be larger
+VALID_SIZE = 50
+
+
+def get_filtered_dataset(*, ds: datasets.Dataset, print_fn: Callable[..., None]) -> Dataset:
+ """Return the filtered dataset, with long queries removed.
+
+ We determined that 99% of queries have 529 or fewer characters. Characters roughly correspond to tokens, so this is
+ a good proxy. We cannot use tokens directly, as that depends on the tokenizer, which can be different for each
+ model, but we want the same filter for each model.
+
+ """
+ char_lengths = [len(f"{q} {r}") for q, r in zip(ds["query"], ds["response"])]
+ idx_filtered = [i for i, length in enumerate(char_lengths) if length <= CHAR_LIMIT]
+ print_fn(f"Filtered dataset: {100 * len(idx_filtered) / len(ds):.1f}% of the original dataset")
+ return ds.select(idx_filtered)
+
+
+def get_train_valid_test_datasets(
+ *, tokenizer, query_template: str, print_fn: Callable[..., None]
+) -> tuple[Dataset, Dataset, Dataset]:
+ """
+ Return the indices of the train, valid, and test splits of the dataset.
+
+ We cannot use ds.train_test_split(..., stratify_by_column="type") as it gives:
+
+ > ValueError: Stratifying by column is only supported for ClassLabel column, and column type is Value.
+
+ even after calling ds_filtered.class_encode_column("type"). Thus, using sklearn's StratifiedKFold instead.
+ """
+ metamath = load_dataset("meta-math/MetaMathQA")["train"]
+ metamath = get_filtered_dataset(ds=metamath, print_fn=print_fn)
+
+ # gsmk8k does not need to be filtered as query and response are short enough
+ gsm8k = load_dataset("openai/gsm8k", "main")
+ gsm8k = gsm8k.rename_columns({"question": "query", "answer": "response"})
+ gsm8k_train = gsm8k["train"]
+ gsm8k_test = gsm8k["test"]
+
+ np.random.seed(0)
+ indices = np.arange(len(gsm8k_train))
+ np.random.shuffle(indices)
+ idx_valid = indices[:VALID_SIZE]
+
+ ds_train = metamath
+ ds_valid = gsm8k_train.select(idx_valid)
+ ds_test = gsm8k_test
+
+ print_fn(f"Train size: {len(ds_train)}")
+ print_fn(f"Valid size: {len(ds_valid)}")
+ print_fn(f"Test size: {len(ds_test)}")
+
+ tokenize_with_answer_ = partial(tokenize_with_answer, tokenizer=tokenizer, template=query_template)
+ tokenize_wo_answer_ = partial(tokenize_wo_answer, tokenizer=tokenizer, template=query_template)
+ ds_train = ds_train.map(tokenize_with_answer_, batched=True).remove_columns(["type", "query", "original_question"])
+ ds_valid = ds_valid.map(tokenize_wo_answer_, batched=True).remove_columns(["query"])
+ ds_test = ds_test.map(tokenize_wo_answer_, batched=True).remove_columns(["query"])
+
+ return ds_train, ds_valid, ds_test
+
+
+def tokenize_with_answer(samples, tokenizer, template):
+ queries = [template.format(query=sample) + answer for sample, answer in zip(samples["query"], samples["response"])]
+ tokenized = tokenizer(queries)
+ tokenized["input_ids"] = [input_ids[: tokenizer.model_max_length] for input_ids in tokenized["input_ids"]]
+ tokenized["attention_mask"] = [
+ input_ids[: tokenizer.model_max_length] for input_ids in tokenized["attention_mask"]
+ ]
+ return tokenized
+
+
+def tokenize_wo_answer(samples, tokenizer, template):
+ queries = [template.format(query=sample) for sample in samples["query"]]
+ tokenized = tokenizer(queries)
+ tokenized["input_ids"] = [input_ids[: tokenizer.model_max_length] for input_ids in tokenized["input_ids"]]
+ tokenized["attention_mask"] = [
+ input_ids[: tokenizer.model_max_length] for input_ids in tokenized["attention_mask"]
+ ]
+ return tokenized
+
+
+def get_wiki_small(num_samples: int = 100) -> list[str]:
+ # This way of loading the dataset avoid having to download whole shards
+ ds = load_dataset("HuggingFaceFW/finewiki", split="train", streaming=True)
+ dataset_head = ds.take(num_samples)
+ rows = [row["text"] for row in dataset_head]
+ return rows
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/default_training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/default_training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..a10fa4960130c88046425a267faa89fa0d2569cc
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/default_training_params.json
@@ -0,0 +1,28 @@
+{
+ "model_id": "meta-llama/Llama-3.2-3B",
+ "dtype": "bfloat16",
+ "max_seq_length": 768,
+ "batch_size": 4,
+ "batch_size_eval": 50,
+ "max_steps": 5000,
+ "eval_steps": 250,
+ "compile": false,
+ "use_gc": false,
+ "seed": 0,
+ "grad_norm_clip": 1.0,
+ "optimizer_type": "AdamW",
+ "optimizer_kwargs": {
+ "lr": 1e-4,
+ "weight_decay": 0.1
+ },
+ "lr_scheduler": "cosine",
+ "use_amp": false,
+ "autocast_adapter_dtype": true,
+ "attn_implementation": null,
+ "generation_kwargs": {
+ "max_length": 800,
+ "max_new_tokens": 300
+ },
+ "query_template": "Question: {query} Think step by step.\nAnswer:",
+ "init_kv_cache_prefix": null
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adalora/llama-3.2-3B-rank32/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adalora/llama-3.2-3B-rank32/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..d20357b52d92ad65b3af6e932c9dd8d16b47bcb4
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adalora/llama-3.2-3B-rank32/adapter_config.json
@@ -0,0 +1,39 @@
+{
+ "alpha_pattern": {},
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "beta1": 0.85,
+ "beta2": 0.85,
+ "bias": "none",
+ "corda_config": null,
+ "deltaT": 1,
+ "eva_config": null,
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "inference_mode": false,
+ "init_lora_weights": true,
+ "init_r": 64,
+ "layer_replication": null,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "loftq_config": {},
+ "lora_alpha": 8,
+ "lora_bias": false,
+ "lora_dropout": 0.0,
+ "megatron_config": null,
+ "megatron_core": "megatron.core",
+ "modules_to_save": null,
+ "orth_reg_weight": 0.5,
+ "peft_type": "ADALORA",
+ "r": 8,
+ "rank_pattern": null,
+ "revision": null,
+ "target_modules": null,
+ "target_r": 32,
+ "task_type": null,
+ "tfinal": 500,
+ "tinit": 200,
+ "total_step": 5000,
+ "use_dora": false,
+ "use_rslora": false
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adamss/llama-3.2-3B-rank32/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adamss/llama-3.2-3B-rank32/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..ddcbc406bad53c41b5569e83afdddf0951000746
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adamss/llama-3.2-3B-rank32/adapter_config.json
@@ -0,0 +1,10 @@
+{
+ "peft_type": "ADAMSS",
+ "r": 100,
+ "num_subspaces": 32,
+ "subspace_rank": 1,
+ "target_modules": null,
+ "init_weights": "orthogonal",
+ "use_asa": false,
+ "task_type": "CAUSAL_LM"
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adamss/llama-3.2-3B-rank32/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adamss/llama-3.2-3B-rank32/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..e258e1c4c884324db0443380331332bfbf88741b
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adamss/llama-3.2-3B-rank32/training_params.json
@@ -0,0 +1,10 @@
+{
+ "model_id": "meta-llama/Llama-3.2-3B",
+ "max_steps": 5000,
+ "batch_size": 4,
+ "eval_steps": 250,
+ "optimizer_kwargs": {
+ "lr": 1e-4,
+ "weight_decay": 0.1
+ }
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_0.0005/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_0.0005/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..367bea4cf187d10c96a4d8b53f355bfd269a1e6a
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_0.0005/adapter_config.json
@@ -0,0 +1,11 @@
+{
+ "adapter_layers": 28,
+ "adapter_len": 100,
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "inference_mode": false,
+ "peft_type": "ADAPTION_PROMPT",
+ "revision": null,
+ "target_modules": null,
+ "task_type": "CAUSAL_LM"
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_0.0005/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_0.0005/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..e8106a88d0de4099e2cbd2648abbe43bdebe6091
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_0.0005/training_params.json
@@ -0,0 +1,6 @@
+{
+ "optimizer_kwargs": {
+ "lr": 5e-4
+ }
+}
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_5e-3/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_5e-3/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..3ac75661c29b6799a839eac31a48daa445f2e2f2
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_5e-3/adapter_config.json
@@ -0,0 +1,12 @@
+{
+ "adapter_layers": 28,
+ "adapter_len": 100,
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "inference_mode": false,
+ "peft_type": "ADAPTION_PROMPT",
+ "peft_version": "0.19.2.dev0@UNKNOWN",
+ "revision": null,
+ "target_modules": null,
+ "task_type": null
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_5e-3/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_5e-3/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..6ed46ad46b21b89f529d8d6a1fa025dfa76ae8ce
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_5e-3/training_params.json
@@ -0,0 +1,23 @@
+{
+ "model_id": "meta-llama/Llama-3.2-3B",
+ "dtype": "bfloat16",
+ "max_seq_length": 512,
+ "batch_size": 4,
+ "batch_size_eval": 64,
+ "max_steps": 3000,
+ "eval_steps": 500,
+ "compile": false,
+ "use_gc": true,
+ "use_amp": false,
+ "grad_norm_clip": 1.0,
+ "optimizer_type": "AdamW",
+ "optimizer_kwargs": {
+ "lr": 0.005,
+ "weight_decay": 0.1
+ },
+ "lr_scheduler": "cosine",
+ "generation_kwargs": {
+ "max_new_tokens": 256
+ },
+ "query_template": "Question: {query} Think step by step.\nAnswer:"
+ }
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/beft/llama-3.2-3B-target-v_proj/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/beft/llama-3.2-3B-target-v_proj/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..658ca6c79777167b53a20daa881f54285dd85cd9
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/beft/llama-3.2-3B-target-v_proj/adapter_config.json
@@ -0,0 +1,14 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "inference_mode": false,
+ "init_weights": true,
+ "modules_to_save": null,
+ "peft_type": "BEFT",
+ "peft_version": "0.19.2.dev0@UNKNOWN",
+ "revision": null,
+ "target_modules": [
+ "v_proj"
+ ],
+ "task_type": null
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/boft/llama-3.2-3B-default/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/boft/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..44d50893ff7f19c1851a2150e879c444ec134fe1
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/boft/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,20 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "boft_block_num": 0,
+ "boft_block_size": 4,
+ "boft_dropout": 0.0,
+ "boft_n_butterfly_factor": 1,
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "inference_mode": false,
+ "init_weights": true,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "modules_to_save": null,
+ "peft_type": "BOFT",
+ "revision": null,
+ "target_modules": null,
+ "task_type": null
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/c3a/llama-3.2-3B-default/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/c3a/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..170c4bb33e558339b07da8044fb3cb2093d2e4eb
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/c3a/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,21 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "inference_mode": false,
+ "init_weights": false,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "modules_to_save": null,
+ "block_size": 64,
+ "block_size_pattern": {},
+ "peft_type": "C3A",
+ "revision": null,
+ "target_modules": [
+ "v_proj",
+ "q_proj"
+ ],
+ "task_type": null
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/c3a/llama-3.2-3B-default/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/c3a/llama-3.2-3B-default/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..a39b9dc8a825e9b79ace91032d0755835548eb44
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/c3a/llama-3.2-3B-default/training_params.json
@@ -0,0 +1,6 @@
+{
+ "optimizer_kwargs": {
+ "lr": 3e-1,
+ "weight_decay": 1e-5
+ }
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/delora/llama-3.2-3B-rank32/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/delora/llama-3.2-3B-rank32/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..6217e8f494197a000bf5274f888b8218c46b87fc
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/delora/llama-3.2-3B-rank32/adapter_config.json
@@ -0,0 +1,20 @@
+{
+ "lambda_pattern": {},
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "exclude_modules": null,
+ "inference_mode": false,
+ "init_weights": true,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "delora_lambda": 15,
+ "module_dropout": 0.0,
+ "modules_to_save": null,
+ "peft_type": "DELORA",
+ "r": 32,
+ "rank_pattern": {},
+ "revision": null,
+ "target_modules": null,
+ "task_type": "CAUSAL_LM"
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/delora/llama-3.2-3B-rank32/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/delora/llama-3.2-3B-rank32/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..8a120ad9a80c36dc3666f4da481a5292a7dc8072
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/delora/llama-3.2-3B-rank32/training_params.json
@@ -0,0 +1,6 @@
+{
+ "optimizer_kwargs": {
+ "lr": 1e-3
+ }
+}
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/fourierft/llama-3.2-3B-default/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/fourierft/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..a2a379f07427f4c68eeaf06756004ddaa377f96b
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/fourierft/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,23 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "inference_mode": false,
+ "init_weights": false,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "modules_to_save": null,
+ "n_frequency": 1000,
+ "n_frequency_pattern": {},
+ "peft_type": "FOURIERFT",
+ "random_loc_seed": 777,
+ "revision": null,
+ "scaling": 300,
+ "target_modules": [
+ "v_proj",
+ "q_proj"
+ ],
+ "task_type": null
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/fourierft/llama-3.2-3B-n_frequency-5000/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/fourierft/llama-3.2-3B-n_frequency-5000/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..40d40246c48487419ea0d21eb369bea60c729496
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/fourierft/llama-3.2-3B-n_frequency-5000/adapter_config.json
@@ -0,0 +1,23 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "inference_mode": false,
+ "init_weights": false,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "modules_to_save": null,
+ "n_frequency": 5000,
+ "n_frequency_pattern": {},
+ "peft_type": "FOURIERFT",
+ "random_loc_seed": 777,
+ "revision": null,
+ "scaling": 300,
+ "target_modules": [
+ "v_proj",
+ "q_proj"
+ ],
+ "task_type": null
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-default/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..4246f6522c3ccc3d32f725d6513c7a2b543a3d0e
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,21 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "fan_in_fan_out": false,
+ "frod_dropout": 0.0,
+ "inference_mode": false,
+ "init_weights": true,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "modules_to_save": null,
+ "peft_type": "FROD",
+ "projection_prng_key": 0,
+ "regularization_alpha": 0.001,
+ "revision": null,
+ "runtime_offload_base_weight": true,
+ "save_projection": true,
+ "sparse_rate": 0.01,
+ "target_modules": null,
+ "task_type": "CAUSAL_LM"
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-sparse0.02-lr_0.001/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-sparse0.02-lr_0.001/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..6c136c6a4547c27f94c285daf24dbfcc9138c49b
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-sparse0.02-lr_0.001/adapter_config.json
@@ -0,0 +1,21 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "fan_in_fan_out": false,
+ "frod_dropout": 0.0,
+ "inference_mode": false,
+ "init_weights": true,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "modules_to_save": null,
+ "peft_type": "FROD",
+ "projection_prng_key": 0,
+ "regularization_alpha": 0.001,
+ "revision": null,
+ "runtime_offload_base_weight": true,
+ "save_projection": true,
+ "sparse_rate": 0.02,
+ "target_modules": null,
+ "task_type": "CAUSAL_LM"
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-sparse0.02-lr_0.001/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-sparse0.02-lr_0.001/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..52d87e3ef6d143c29d2ba640028909a31befffa6
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-sparse0.02-lr_0.001/training_params.json
@@ -0,0 +1,5 @@
+{
+ "optimizer_kwargs": {
+ "lr": 1e-3
+ }
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/full-finetuning/llama-3.2-3B-lr_0.00001/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/full-finetuning/llama-3.2-3B-lr_0.00001/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..6d6c3b0f9114a63d0739eef0c996f4c1c0c0e36c
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/full-finetuning/llama-3.2-3B-lr_0.00001/training_params.json
@@ -0,0 +1,6 @@
+{
+ "optimizer_kwargs": {
+ "lr": 1e-5
+ }
+}
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/gralora/llama-3.2-3B-rank32/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/gralora/llama-3.2-3B-rank32/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..edeb382457a06ef03924f5941a29b1556be6c46d
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/gralora/llama-3.2-3B-rank32/adapter_config.json
@@ -0,0 +1,21 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "fan_in_fan_out": false,
+ "alpha": 64,
+ "gralora_dropout": 0.0,
+ "gralora_k": 2,
+ "hybrid_r": 0,
+ "inference_mode": false,
+ "init_weights": true,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "modules_to_save": null,
+ "peft_type": "GRALORA",
+ "peft_version": "0.17.2.dev0@UNKNOWN",
+ "r": 32,
+ "revision": null,
+ "target_modules": null,
+ "task_type": null
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/gralora/llama-3.2-3B-rank32/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/gralora/llama-3.2-3B-rank32/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..94cd6b2f1684684500badd8b05b9bc080eba16fb
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/gralora/llama-3.2-3B-rank32/training_params.json
@@ -0,0 +1,5 @@
+{
+ "optimizer_kwargs": {
+ "lr": 2e-4
+ }
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/hira/llama-3.2-3B-rank32-lr4.5e-3/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/hira/llama-3.2-3B-rank32-lr4.5e-3/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..f992b6523e690eceb8f4e9e7135d380bccd5662e
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/hira/llama-3.2-3B-rank32-lr4.5e-3/adapter_config.json
@@ -0,0 +1,20 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "hira_dropout": 0.0,
+ "inference_mode": false,
+ "init_weights": true,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "modules_to_save": null,
+ "peft_type": "HIRA",
+ "r": 32,
+ "rank_pattern": {},
+ "target_modules": [
+ "q_proj",
+ "v_proj"
+ ],
+ "task_type": "CAUSAL_LM"
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/hira/llama-3.2-3B-rank32-lr4.5e-3/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/hira/llama-3.2-3B-rank32-lr4.5e-3/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..951b2a48c59e5e161660f432e4f7fbf64dcf9ae6
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/hira/llama-3.2-3B-rank32-lr4.5e-3/training_params.json
@@ -0,0 +1,6 @@
+{
+ "optimizer_kwargs": {
+ "lr": 4.5e-3,
+ "weight_decay": 0.0
+ }
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-all-attn-5k-lr0.005/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-all-attn-5k-lr0.005/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..dbd23f732f33cb6e1fa56edcdac21ceb8048c7ee
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-all-attn-5k-lr0.005/adapter_config.json
@@ -0,0 +1,14 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "feedforward_modules": ["down_proj", "gate_proj", "up_proj"],
+ "inference_mode": false,
+ "init_ia3_weights": true,
+ "modules_to_save": null,
+ "peft_type": "IA3",
+ "revision": null,
+ "target_modules": ["q_proj", "k_proj", "v_proj", "o_proj", "down_proj", "gate_proj", "up_proj"],
+ "task_type": null
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-all-attn-5k-lr0.005/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-all-attn-5k-lr0.005/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..57801b471e04a89022415023cc3558913a816bef
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-all-attn-5k-lr0.005/training_params.json
@@ -0,0 +1,6 @@
+{
+ "optimizer_kwargs": {
+ "lr": 5e-3,
+ "weight_decay": 0.0
+ }
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-default/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..0c8e514faa808ac0874e71f21bad7a576d15349d
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,14 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "feedforward_modules": null,
+ "inference_mode": false,
+ "init_ia3_weights": true,
+ "modules_to_save": null,
+ "peft_type": "IA3",
+ "revision": null,
+ "target_modules": null,
+ "task_type": null
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-lr_0.001/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-lr_0.001/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..0c8e514faa808ac0874e71f21bad7a576d15349d
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-lr_0.001/adapter_config.json
@@ -0,0 +1,14 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "feedforward_modules": null,
+ "inference_mode": false,
+ "init_ia3_weights": true,
+ "modules_to_save": null,
+ "peft_type": "IA3",
+ "revision": null,
+ "target_modules": null,
+ "task_type": null
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-lr_0.001/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-lr_0.001/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..8a120ad9a80c36dc3666f4da481a5292a7dc8072
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-lr_0.001/training_params.json
@@ -0,0 +1,6 @@
+{
+ "optimizer_kwargs": {
+ "lr": 1e-3
+ }
+}
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lily/llama-3.2-3B-rank140-mlp-a2-b2-s8.0/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lily/llama-3.2-3B-rank140-mlp-a2-b2-s8.0/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..7544d9f7a0819048282fc0dbb2003d2c25ba7e56
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lily/llama-3.2-3B-rank140-mlp-a2-b2-s8.0/adapter_config.json
@@ -0,0 +1,19 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "exclude_modules": null,
+ "inference_mode": false,
+ "init_weights": true,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "modules_to_save": null,
+ "num_B": 2,
+ "peft_type": "LILY",
+ "peft_version": "0.18.2.dev0@UNKNOWN",
+ "r": 140,
+ "revision": null,
+ "scaling": 8.0,
+ "stride_A": 14,
+ "target_modules": ["gate_proj", "up_proj", "down_proj"],
+ "task_type": null
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lily/llama-3.2-3B-rank896-a2-b2-s2.0/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lily/llama-3.2-3B-rank896-a2-b2-s2.0/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..d4ab980c7943e6a4abee37bfbfb10601e8b3a877
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lily/llama-3.2-3B-rank896-a2-b2-s2.0/adapter_config.json
@@ -0,0 +1,22 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "exclude_modules": null,
+ "inference_mode": false,
+ "init_weights": true,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "modules_to_save": null,
+ "num_B": 2,
+ "peft_type": "LILY",
+ "peft_version": "0.18.2.dev0@UNKNOWN",
+ "r": 896,
+ "revision": null,
+ "scaling": 2.0,
+ "stride_A": 14,
+ "target_modules": [
+ "q_proj",
+ "v_proj"
+ ],
+ "task_type": null
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ln_tuning/llama-3.2-3B-default/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ln_tuning/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..70b7363d3ac83e8ff2ee85634baafbee1f42b56a
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/ln_tuning/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,11 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "exclude_modules": null,
+ "inference_mode": false,
+ "modules_to_save": null,
+ "peft_type": "LN_TUNING",
+ "revision": null,
+ "target_modules": null,
+ "task_type": null
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/loha/llama-3.2-3B-rank32/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/loha/llama-3.2-3B-rank32/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..1137259fa26b3abeac269c7bdda56dbeb29e34f7
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/loha/llama-3.2-3B-rank32/adapter_config.json
@@ -0,0 +1,24 @@
+{
+ "alpha": 64,
+ "alpha_pattern": {},
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "exclude_modules": null,
+ "inference_mode": false,
+ "init_weights": true,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "module_dropout": 0.0,
+ "modules_to_save": null,
+ "peft_type": "LOHA",
+ "r": 32,
+ "rank_dropout": 0.0,
+ "rank_pattern": {},
+ "revision": null,
+ "target_modules": [
+ "q_proj",
+ "v_proj"
+ ],
+ "task_type": null,
+ "use_effective_conv2d": false
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lokr/llama-3.2-3B-rank32/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lokr/llama-3.2-3B-rank32/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..7d30dd77a4c5f185fde99a5d60f381961ac7c522
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lokr/llama-3.2-3B-rank32/adapter_config.json
@@ -0,0 +1,27 @@
+{
+ "alpha": 64,
+ "alpha_pattern": {},
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "decompose_both": false,
+ "decompose_factor": -1,
+ "exclude_modules": null,
+ "inference_mode": false,
+ "init_weights": true,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "module_dropout": 0.0,
+ "modules_to_save": null,
+ "peft_type": "LOKR",
+ "r": 32,
+ "rank_dropout": 0.0,
+ "rank_dropout_scale": false,
+ "rank_pattern": {},
+ "revision": null,
+ "target_modules": [
+ "q_proj",
+ "v_proj"
+ ],
+ "task_type": null,
+ "use_effective_conv2d": false
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank10-target-mlp/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank10-target-mlp/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..2c04c5c94b610e7d46d75f2facc1f08ad7eb16ad
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank10-target-mlp/adapter_config.json
@@ -0,0 +1,30 @@
+{
+ "alpha_pattern": {},
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "corda_config": null,
+ "eva_config": null,
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "inference_mode": false,
+ "init_lora_weights": true,
+ "layer_replication": null,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "loftq_config": {},
+ "lora_alpha": 20,
+ "lora_bias": false,
+ "lora_dropout": 0.0,
+ "megatron_config": null,
+ "megatron_core": "megatron.core",
+ "modules_to_save": null,
+ "peft_type": "LORA",
+ "r": 10,
+ "rank_pattern": {},
+ "revision": null,
+ "target_modules": ["gate_proj", "up_proj", "down_proj"],
+ "task_type": "CAUSAL_LM",
+ "use_dora": false,
+ "use_rslora": false
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank14-target-mlp-bdlora/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank14-target-mlp-bdlora/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..cbd929e22f3ca8732b790b462349844e33bb4005
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank14-target-mlp-bdlora/adapter_config.json
@@ -0,0 +1,48 @@
+{
+ "alpha_pattern": {},
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "corda_config": null,
+ "eva_config": null,
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "inference_mode": false,
+ "init_lora_weights": true,
+ "layer_replication": null,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "loftq_config": {},
+ "lora_alpha": 28,
+ "lora_bias": false,
+ "lora_dropout": 0.0,
+ "megatron_config": null,
+ "megatron_core": "megatron.core",
+ "modules_to_save": null,
+ "peft_type": "LORA",
+ "r": 14,
+ "rank_pattern": {},
+ "revision": null,
+ "target_modules": [
+ "gate_proj",
+ "up_proj",
+ "down_proj"
+ ],
+ "task_type": "CAUSAL_LM",
+ "use_dora": false,
+ "use_rslora": false,
+ "use_bdlora": {
+ "target_modules_bd_a": [
+ "o_proj",
+ "down_proj"
+ ],
+ "target_modules_bd_b": [
+ "q_proj",
+ "v_proj",
+ "k_proj",
+ "up_proj",
+ "gate_proj"
+ ],
+ "nblocks": 2
+ }
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-dora/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-dora/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..255d09d2508a603fd8eea98152025c6cd8f0a789
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-dora/adapter_config.json
@@ -0,0 +1,30 @@
+{
+ "alpha_pattern": {},
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "corda_config": null,
+ "eva_config": null,
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "inference_mode": false,
+ "init_lora_weights": true,
+ "layer_replication": null,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "loftq_config": {},
+ "lora_alpha": 64,
+ "lora_bias": false,
+ "lora_dropout": 0.0,
+ "megatron_config": null,
+ "megatron_core": "megatron.core",
+ "modules_to_save": null,
+ "peft_type": "LORA",
+ "r": 32,
+ "rank_pattern": {},
+ "revision": null,
+ "target_modules": null,
+ "task_type": "CAUSAL_LM",
+ "use_dora": true,
+ "use_rslora": false
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-lorafa/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-lorafa/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..8832c108fac1825c52774517fd3e5bf0fc7d8d64
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-lorafa/adapter_config.json
@@ -0,0 +1,30 @@
+{
+ "alpha_pattern": {},
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "corda_config": null,
+ "eva_config": null,
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "inference_mode": false,
+ "init_lora_weights": true,
+ "layer_replication": null,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "loftq_config": {},
+ "lora_alpha": 64,
+ "lora_bias": false,
+ "lora_dropout": 0.0,
+ "megatron_config": null,
+ "megatron_core": "megatron.core",
+ "modules_to_save": null,
+ "peft_type": "LORA",
+ "r": 32,
+ "rank_pattern": {},
+ "revision": null,
+ "target_modules": null,
+ "task_type": "CAUSAL_LM",
+ "use_dora": false,
+ "use_rslora": false
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-lorafa/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-lorafa/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..985db872405905c31c93a10aa9cd3f77ed223437
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-lorafa/training_params.json
@@ -0,0 +1,9 @@
+{
+ "optimizer_type": "lora-fa",
+ "optimizer_kwargs": {
+ "r": 32,
+ "lora_alpha": 64,
+ "lr": 1e-4,
+ "weight_decay": 0.1
+ }
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-mica/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-mica/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..e62097f635f12c6d3b336df7354796f6eadff69b
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-mica/adapter_config.json
@@ -0,0 +1,30 @@
+{
+ "alpha_pattern": {},
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "corda_config": null,
+ "eva_config": null,
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "inference_mode": false,
+ "init_lora_weights": "mica",
+ "layer_replication": null,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "loftq_config": {},
+ "lora_alpha": 64,
+ "lora_bias": false,
+ "lora_dropout": 0.0,
+ "megatron_config": null,
+ "megatron_core": "megatron.core",
+ "modules_to_save": null,
+ "peft_type": "LORA",
+ "r": 32,
+ "rank_pattern": {},
+ "revision": null,
+ "target_modules": null,
+ "task_type": "CAUSAL_LM",
+ "use_dora": false,
+ "use_rslora": false
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..8832c108fac1825c52774517fd3e5bf0fc7d8d64
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32/adapter_config.json
@@ -0,0 +1,30 @@
+{
+ "alpha_pattern": {},
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "corda_config": null,
+ "eva_config": null,
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "inference_mode": false,
+ "init_lora_weights": true,
+ "layer_replication": null,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "loftq_config": {},
+ "lora_alpha": 64,
+ "lora_bias": false,
+ "lora_dropout": 0.0,
+ "megatron_config": null,
+ "megatron_core": "megatron.core",
+ "modules_to_save": null,
+ "peft_type": "LORA",
+ "r": 32,
+ "rank_pattern": {},
+ "revision": null,
+ "target_modules": null,
+ "task_type": "CAUSAL_LM",
+ "use_dora": false,
+ "use_rslora": false
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank64-rslora/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank64-rslora/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..dc1f8039ab02888675a12a1a1a017ebdd196b9d4
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank64-rslora/adapter_config.json
@@ -0,0 +1,30 @@
+{
+ "alpha_pattern": {},
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "corda_config": null,
+ "eva_config": null,
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "inference_mode": false,
+ "init_lora_weights": true,
+ "layer_replication": null,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "loftq_config": {},
+ "lora_alpha": 64,
+ "lora_bias": false,
+ "lora_dropout": 0.0,
+ "megatron_config": null,
+ "megatron_core": "megatron.core",
+ "modules_to_save": null,
+ "peft_type": "LORA",
+ "r": 64,
+ "rank_pattern": {},
+ "revision": null,
+ "target_modules": null,
+ "task_type": "CAUSAL_LM",
+ "use_dora": false,
+ "use_rslora": true
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank64/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank64/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..75890c9dce9fef14eee47ce19f3baa86d4d4168a
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank64/adapter_config.json
@@ -0,0 +1,30 @@
+{
+ "alpha_pattern": {},
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "corda_config": null,
+ "eva_config": null,
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "inference_mode": false,
+ "init_lora_weights": true,
+ "layer_replication": null,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "loftq_config": {},
+ "lora_alpha": 128,
+ "lora_bias": false,
+ "lora_dropout": 0.0,
+ "megatron_config": null,
+ "megatron_core": "megatron.core",
+ "modules_to_save": null,
+ "peft_type": "LORA",
+ "r": 64,
+ "rank_pattern": {},
+ "revision": null,
+ "target_modules": null,
+ "task_type": "CAUSAL_LM",
+ "use_dora": false,
+ "use_rslora": false
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-bat/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-bat/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..a3267da039aad22dcc2d70006dccc34c8759d359
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-bat/adapter_config.json
@@ -0,0 +1,18 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "exclude_modules": null,
+ "inference_mode": false,
+ "init_weights": "bat",
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "mini_r": 1,
+ "miss_dropout": 0.0,
+ "modules_to_save": null,
+ "peft_type": "MISS",
+ "r": 64,
+ "revision": null,
+ "target_modules": null,
+ "task_type": null
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-default/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..02ee9f74396d7372104f2adf9f462e1ac4653d93
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,18 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "exclude_modules": null,
+ "inference_mode": false,
+ "init_weights": true,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "mini_r": 1,
+ "miss_dropout": 0.0,
+ "modules_to_save": null,
+ "peft_type": "MISS",
+ "r": 64,
+ "revision": null,
+ "target_modules": null,
+ "task_type": null
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-mini/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-mini/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..d732e181b21e0961029723bc640c25d5917d217e
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-mini/adapter_config.json
@@ -0,0 +1,18 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "exclude_modules": null,
+ "inference_mode": false,
+ "init_weights": "mini",
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "mini_r": 64,
+ "miss_dropout": 0.0,
+ "modules_to_save": null,
+ "peft_type": "MISS",
+ "r": 64,
+ "revision": null,
+ "target_modules": null,
+ "task_type": null
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/oft/llama-3.2-3B-rank32/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/oft/llama-3.2-3B-rank32/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..e8cdb86ecd110a0176dd42b34e25b3c133cbab4a
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/oft/llama-3.2-3B-rank32/adapter_config.json
@@ -0,0 +1,27 @@
+{
+ "alpha_pattern": {},
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "bias": "none",
+ "block_share": false,
+ "coft": false,
+ "eps": 6e-05,
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "inference_mode": false,
+ "init_weights": true,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "module_dropout": 0.0,
+ "modules_to_save": null,
+ "oft_block_size": 0,
+ "peft_type": "OFT",
+ "r": 32,
+ "rank_pattern": {},
+ "revision": null,
+ "target_modules": [
+ "q_proj",
+ "v_proj"
+ ],
+ "task_type": null
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/osf/llama-3.2-3B-rank128/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/osf/llama-3.2-3B-rank128/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..34d7bf1858cf07e62aa0e31d85d3ad96f083ad63
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/osf/llama-3.2-3B-rank128/adapter_config.json
@@ -0,0 +1,28 @@
+{
+ "task_type": null,
+ "peft_type": "OSF",
+ "auto_mapping": null,
+ "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+ "revision": null,
+ "inference_mode": false,
+ "effective_rank": null,
+ "target_modules": [
+ "q_proj",
+ "k_proj",
+ "v_proj",
+ "o_proj",
+ "gate_proj",
+ "down_proj",
+ "up_proj"
+ ],
+ "rank_pattern": {
+ "q_proj": 2944,
+ "o_proj": 2944,
+ "k_proj": 896,
+ "v_proj": 896,
+ "gate_proj": 2944,
+ "down_proj": 2944,
+ "up_proj": 2944
+ }
+}
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/osf/llama-3.2-3B-rank128/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/osf/llama-3.2-3B-rank128/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..51f64313245dcc58f7e87b6e548e9abfda811ed5
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/osf/llama-3.2-3B-rank128/training_params.json
@@ -0,0 +1,7 @@
+{
+ "autocast_adapter_dtype": false,
+ "optimizer_kwargs": {
+ "lr": 5e-5
+ }
+}
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/peanut/llama-3.2-3B-rank1-relu-depth0-s32.0/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/peanut/llama-3.2-3B-rank1-relu-depth0-s32.0/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..a4007c1c87f03183c8e474605ae7c856c4f4fe4f
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/peanut/llama-3.2-3B-rank1-relu-depth0-s32.0/adapter_config.json
@@ -0,0 +1,22 @@
+{
+ "act_fn": "relu",
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "depth": 0,
+ "exclude_modules": null,
+ "inference_mode": false,
+ "init_weights": true,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "modules_to_save": null,
+ "peft_type": "PEANUT",
+ "peft_version": "0.18.2.dev0@UNKNOWN",
+ "r": 1,
+ "revision": null,
+ "scaling": 32.0,
+ "target_modules": [
+ "q_proj",
+ "v_proj"
+ ],
+ "task_type": null
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/peanut/llama-3.2-3B-rank32-relu-depth0-s2.0/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/peanut/llama-3.2-3B-rank32-relu-depth0-s2.0/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..ddb11ba8b123c7b22d9d2e8c637c95b2e6c111c6
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/peanut/llama-3.2-3B-rank32-relu-depth0-s2.0/adapter_config.json
@@ -0,0 +1,22 @@
+{
+ "act_fn": "relu",
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "depth": 0,
+ "exclude_modules": null,
+ "inference_mode": false,
+ "init_weights": true,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "modules_to_save": null,
+ "peft_type": "PEANUT",
+ "peft_version": "0.18.2.dev0@UNKNOWN",
+ "r": 32,
+ "revision": null,
+ "scaling": 2.0,
+ "target_modules": [
+ "q_proj",
+ "v_proj"
+ ],
+ "task_type": null
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.001/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.001/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..77bff7fd16cd3f675655221218e69a55eaead91f
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.001/adapter_config.json
@@ -0,0 +1,15 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "encoder_hidden_size": 3072,
+ "inference_mode": false,
+ "num_attention_heads": 24,
+ "num_layers": 28,
+ "num_transformer_submodules": 1,
+ "num_virtual_tokens": 200,
+ "peft_type": "PREFIX_TUNING",
+ "prefix_projection": false,
+ "revision": null,
+ "task_type": "CAUSAL_LM",
+ "token_dim": 3072
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.001/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.001/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..8a120ad9a80c36dc3666f4da481a5292a7dc8072
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.001/training_params.json
@@ -0,0 +1,6 @@
+{
+ "optimizer_kwargs": {
+ "lr": 1e-3
+ }
+}
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.005_zero_init/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.005_zero_init/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..29cbe8611585d2e4bf7f6d306bc2208696710957
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.005_zero_init/adapter_config.json
@@ -0,0 +1,16 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "encoder_hidden_size": 3072,
+ "inference_mode": false,
+ "num_attention_heads": 24,
+ "num_layers": 28,
+ "num_transformer_submodules": 1,
+ "num_virtual_tokens": 200,
+ "init_weights": "zero",
+ "peft_type": "PREFIX_TUNING",
+ "prefix_projection": false,
+ "revision": null,
+ "task_type": "CAUSAL_LM",
+ "token_dim": 3072
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.005_zero_init/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.005_zero_init/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..3c6ed9dedab8566fd7f2a300240d216c909dc523
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.005_zero_init/training_params.json
@@ -0,0 +1,5 @@
+{
+ "optimizer_kwargs": {
+ "lr": 0.005
+ }
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-tokens50-init_prefix-lr_0.005/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-tokens50-init_prefix-lr_0.005/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..382c384dfef49086b5ff3b2ad218471f08fb1a9b
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-tokens50-init_prefix-lr_0.005/adapter_config.json
@@ -0,0 +1,16 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "encoder_hidden_size": 3072,
+ "inference_mode": false,
+ "num_attention_heads": 24,
+ "num_layers": 28,
+ "num_transformer_submodules": 1,
+ "num_virtual_tokens": 50,
+ "init_weights": "zero",
+ "peft_type": "PREFIX_TUNING",
+ "prefix_projection": false,
+ "revision": null,
+ "task_type": "CAUSAL_LM",
+ "token_dim": 3072
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-tokens50-init_prefix-lr_0.005/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-tokens50-init_prefix-lr_0.005/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..54b489141cb8c75cd628dfc44265f116b532dad1
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-tokens50-init_prefix-lr_0.005/training_params.json
@@ -0,0 +1,6 @@
+{
+ "init_kv_cache_prefix": "You are a helpful math assistant. Solve mathematical problems by thinking step by step. First, identify what the problem is asking. Then, break down the solution into clear logical steps. Show all your work and calculations. Finally, verify that your answer makes sense.",
+ "optimizer_kwargs": {
+ "lr": 0.005
+ }
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-default/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..efa055b03d6f3a6c6d0f7df76f11550891919b0a
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,17 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "inference_mode": false,
+ "num_attention_heads": 24,
+ "num_layers": 28,
+ "num_transformer_submodules": 1,
+ "num_virtual_tokens": 200,
+ "peft_type": "PROMPT_TUNING",
+ "prompt_tuning_init": "RANDOM",
+ "prompt_tuning_init_text": null,
+ "revision": null,
+ "task_type": "CAUSAL_LM",
+ "token_dim": 3072,
+ "tokenizer_kwargs": null,
+ "tokenizer_name_or_path": null
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-lr_0.001/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-lr_0.001/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..efa055b03d6f3a6c6d0f7df76f11550891919b0a
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-lr_0.001/adapter_config.json
@@ -0,0 +1,17 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "inference_mode": false,
+ "num_attention_heads": 24,
+ "num_layers": 28,
+ "num_transformer_submodules": 1,
+ "num_virtual_tokens": 200,
+ "peft_type": "PROMPT_TUNING",
+ "prompt_tuning_init": "RANDOM",
+ "prompt_tuning_init_text": null,
+ "revision": null,
+ "task_type": "CAUSAL_LM",
+ "token_dim": 3072,
+ "tokenizer_kwargs": null,
+ "tokenizer_name_or_path": null
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-lr_0.001/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-lr_0.001/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..8a120ad9a80c36dc3666f4da481a5292a7dc8072
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-lr_0.001/training_params.json
@@ -0,0 +1,6 @@
+{
+ "optimizer_kwargs": {
+ "lr": 1e-3
+ }
+}
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-sample_vocab-lr_0.001/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-sample_vocab-lr_0.001/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..8b9f14279798195477b8a188feb12dfcd9605e00
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-sample_vocab-lr_0.001/adapter_config.json
@@ -0,0 +1,17 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "inference_mode": false,
+ "num_attention_heads": 24,
+ "num_layers": 28,
+ "num_transformer_submodules": 1,
+ "num_virtual_tokens": 200,
+ "peft_type": "PROMPT_TUNING",
+ "prompt_tuning_init": "SAMPLE_VOCAB",
+ "prompt_tuning_init_text": null,
+ "revision": null,
+ "task_type": "CAUSAL_LM",
+ "token_dim": 3072,
+ "tokenizer_kwargs": null,
+ "tokenizer_name_or_path": null
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-sample_vocab-lr_0.001/training_params.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-sample_vocab-lr_0.001/training_params.json
new file mode 100644
index 0000000000000000000000000000000000000000..8a120ad9a80c36dc3666f4da481a5292a7dc8072
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-sample_vocab-lr_0.001/training_params.json
@@ -0,0 +1,6 @@
+{
+ "optimizer_kwargs": {
+ "lr": 1e-3
+ }
+}
+
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/psoft/llama-3.2-3B-default/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/psoft/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..fb70b83d7f8a2a2de113fc6a77bb50e36919a4eb
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/psoft/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,26 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "r": 256,
+ "psoft_alpha": 256,
+ "psoft_dropout": 0.0,
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "ab_svd_init": "psoft_init",
+ "psoft_svd": "full",
+ "psoft_svd_lowrank_niter": 10,
+ "psoft_orth": true,
+ "psoft_mag_a": true,
+ "psoft_mag_b": true,
+ "use_cayley_neumann": false,
+ "num_cayley_neumann_terms": 5,
+ "cayley_neumann_eps": null,
+ "init_weights": true,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "modules_to_save": null,
+ "peft_type": "PSOFT",
+ "revision": null,
+ "target_modules": null,
+ "task_type": null
+}
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/psoft/llama-3.2-3B-fast/adapter_config.json b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/psoft/llama-3.2-3B-fast/adapter_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..290234d40949b5c10ccff4926aa808b5972ac0de
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/method_comparison/MetaMathQA/experiments/psoft/llama-3.2-3B-fast/adapter_config.json
@@ -0,0 +1,26 @@
+{
+ "auto_mapping": null,
+ "base_model_name_or_path": null,
+ "r": 256,
+ "psoft_alpha": 256,
+ "psoft_dropout": 0.0,
+ "exclude_modules": null,
+ "fan_in_fan_out": false,
+ "ab_svd_init": "psoft_init",
+ "psoft_svd": "lowrank",
+ "psoft_svd_lowrank_niter": 10,
+ "psoft_orth": true,
+ "psoft_mag_a": true,
+ "psoft_mag_b": true,
+ "use_cayley_neumann": true,
+ "num_cayley_neumann_terms": 5,
+ "cayley_neumann_eps": null,
+ "init_weights": true,
+ "layers_pattern": null,
+ "layers_to_transform": null,
+ "modules_to_save": null,
+ "peft_type": "PSOFT",
+ "revision": null,
+ "target_modules": null,
+ "task_type": null
+}
]({{ wandb_url }}){% endif %}
+{% if trackio_url %}[
]({{ trackio_url }}){% endif %}
+{% if comet_url %}[
]({{ comet_url }}){% endif %}
+
+This model was trained with {{ trainer_name }}{% if paper_id %}, a method introduced in [{{ paper_title }}](https://huggingface.co/papers/{{ paper_id }}){% endif %}.
+
+### Framework versions
+
+- TRL: {{ trl_version }}
+- Transformers: {{ transformers_version }}
+- Pytorch: {{ pytorch_version }}
+- Datasets: {{ datasets_version }}
+- Tokenizers: {{ tokenizers_version }}
+
+## Citations
+
+{% if trainer_citation %}Cite {{ trainer_name }} as:
+
+```bibtex
+{{ trainer_citation }}
+```{% endif %}
+
+Cite TRL as:
+
+```bibtex
+{% raw %}@software{vonwerra2020trl,
+ title = {{TRL: Transformers Reinforcement Learning}},
+ author = {von Werra, Leandro and Belkada, Younes and Tunstall, Lewis and Beeching, Edward and Thrush, Tristan and Lambert, Nathan and Huang, Shengyi and Rasul, Kashif and Gallouédec, Quentin},
+ license = {Apache-2.0},
+ url = {https://github.com/huggingface/trl},
+ year = {2020}
+}{% endraw %}
+```
diff --git a/tasks/tasksmith-03a6a091b12f/tests/source/trl/templates/rm_model_card.md b/tasks/tasksmith-03a6a091b12f/tests/source/trl/templates/rm_model_card.md
new file mode 100644
index 0000000000000000000000000000000000000000..0e47e9724a6c38f262b63782507d5871bb4272c2
--- /dev/null
+++ b/tasks/tasksmith-03a6a091b12f/tests/source/trl/templates/rm_model_card.md
@@ -0,0 +1,55 @@
+---
+{{ card_data }}
+---
+
+# Model Card for {{ model_name }}
+
+This model is a fine-tuned version of [{{ base_model }}](https://huggingface.co/{{ base_model }}){% if dataset_name %} on the [{{ dataset_name }}](https://huggingface.co/datasets/{{ dataset_name }}) dataset{% endif %}.
+It has been trained using [TRL](https://github.com/huggingface/trl).
+
+## Quick start
+
+```python
+from transformers import pipeline
+
+text = "The capital of France is Paris."
+rewarder = pipeline(model="{{ hub_model_id }}", device="cuda")
+output = rewarder(text)[0]
+print(output["score"])
+```
+
+## Training procedure
+
+{% if wandb_url %}[
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
![](\"bdlora-sharding.png\")
\n",
+ "![](\"bdlora-performance.png\")
\n",
+ "
+
+Optimization in Unsloth to speed up QLoRA finetuning while reducing GPU memory usage
+
+## Multi-GPU SFT with QLoRA
+To speed up QLoRA finetuning when you have access to multiple GPUs, look at the launch command at [run_peft_multigpu.sh](https://github.com/huggingface/peft/blob/main/examples/sft/run_peft_multigpu.sh). This example to performs DDP on 8 GPUs.
+
+Note:
+1. At present, `use_reentrant` needs to be `False` when using gradient checkpointing with Multi-GPU QLoRA else it will lead to errors. However, this leads to huge GPU memory consumption.
+
+## Multi-GPU SFT with LoRA and DeepSpeed
+When you have access to multiple GPUs, it would be better to use normal LoRA with DeepSpeed/FSDP. To use LoRA with DeepSpeed, refer to the docs at [PEFT with DeepSpeed](https://huggingface.co/docs/peft/accelerate/deepspeed).
+
+
+## Multi-GPU SFT with LoRA and FSDP
+When you have access to multiple GPUs, it would be better to use normal LoRA with DeepSpeed/FSDP. To use LoRA with FSDP, refer to the docs at [PEFT with FSDP](https://huggingface.co/docs/peft/accelerate/fsdp).
+
+Note: FSDP is currently not compatible with 8bit bitsandbytes quantization.
+
+
+## Multi-GPU SFT with LoRA and FSDP for GPT-QModel:
+As in [Multi-GPU SFT with LoRA and FSDP](https://github.com/huggingface/peft/blob/main/examples/sft/README.md#multi-gpu-sft-with-lora-and-fsdp), we also support other quantization methods like GPT-QModel. You may need to install [GPT-QModel](https://github.com/ModelCloud/GPTQModel) >= v7.0.0 or from source. Here is the launch command for reference: [run_peft_fsdp_gptq.sh]. For the `--model_name_or_path` argument, it is important to pass a model that is already quantized with GPT-QModel, like `"hugging-quants/Meta-Llama-3.1-8B-Instruct-GPTQ-INT4"`.
+
+Note: there is a bug in transformers v4.53.0 for this case, please skip this transformers version.
+
+## Tip
+
+Generally try to upgrade to the latest package versions for best results, especially when it comes to `bitsandbytes`, `accelerate`, `transformers`, `trl`, and `peft`.
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/deepspeed_config.yaml b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/deepspeed_config.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..56eef6e48b75727ede1d522b595b5ecde3a205a1
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/deepspeed_config.yaml
@@ -0,0 +1,23 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+deepspeed_config:
+ deepspeed_multinode_launcher: standard
+ gradient_accumulation_steps: 4
+ offload_optimizer_device: none
+ offload_param_device: none
+ zero3_init_flag: true
+ zero3_save_16bit_model: true
+ zero_stage: 3
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 8
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/deepspeed_config_z3_qlora.yaml b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/deepspeed_config_z3_qlora.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..07dddcef7853b963ea64d20d39078893c4e21c33
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/deepspeed_config_z3_qlora.yaml
@@ -0,0 +1,22 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+deepspeed_config:
+ deepspeed_multinode_launcher: standard
+ offload_optimizer_device: none
+ offload_param_device: none
+ zero3_init_flag: true
+ zero3_save_16bit_model: true
+ zero_stage: 3
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 2
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/fsdp_config.yaml b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/fsdp_config.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..7cccb74ca0dfa1a916b5057ceee561271c301ec5
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/fsdp_config.yaml
@@ -0,0 +1,25 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: FSDP
+downcast_bf16: 'no'
+fsdp_config:
+ fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
+ fsdp_backward_prefetch: BACKWARD_PRE
+ fsdp_cpu_ram_efficient_loading: true
+ fsdp_forward_prefetch: false
+ fsdp_offload_params: false
+ fsdp_sharding_strategy: FULL_SHARD
+ fsdp_state_dict_type: SHARDED_STATE_DICT
+ fsdp_sync_module_states: true
+ fsdp_use_orig_params: false
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 8
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/fsdp_config_qlora.yaml b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/fsdp_config_qlora.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..f28a0f1046a735579045655dcdb9d3bf7c6ffdcc
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/configs/fsdp_config_qlora.yaml
@@ -0,0 +1,25 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: FSDP
+downcast_bf16: 'no'
+fsdp_config:
+ fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
+ fsdp_backward_prefetch: BACKWARD_PRE
+ fsdp_cpu_ram_efficient_loading: true
+ fsdp_forward_prefetch: false
+ fsdp_offload_params: true
+ fsdp_sharding_strategy: FULL_SHARD
+ fsdp_state_dict_type: SHARDED_STATE_DICT
+ fsdp_sync_module_states: true
+ fsdp_use_orig_params: false
+machine_rank: 0
+main_training_function: main
+mixed_precision: 'no'
+num_machines: 1
+num_processes: 2
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements.txt b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..752b6976e62f4acff6193804c5422807bc5e8806
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements.txt
@@ -0,0 +1,25 @@
+git+https://github.com/huggingface/transformers
+git+https://github.com/huggingface/accelerate
+git+https://github.com/huggingface/peft
+git+https://github.com/huggingface/trl
+git+https://github.com/huggingface/datatrove.git
+unsloth[conda]@git+https://github.com/unslothai/unsloth.git
+deepspeed
+PyGithub
+flash-attn
+huggingface-hub
+evaluate
+datasets
+bitsandbytes
+einops
+wandb
+tensorboard
+tiktoken
+pandas
+numpy
+scipy
+matplotlib
+sentencepiece
+nltk
+xformers
+hf_transfer
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements_colab.txt b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements_colab.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b8c375dc44bf85305fa53964537f4877210b10bd
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements_colab.txt
@@ -0,0 +1,25 @@
+git+https://github.com/huggingface/transformers
+git+https://github.com/huggingface/accelerate
+git+https://github.com/huggingface/peft
+git+https://github.com/huggingface/trl
+unsloth[colab_ampere] @ git+https://github.com/unslothai/unsloth.git
+datasets
+deepspeed
+PyGithub
+flash-attn
+huggingface-hub
+evaluate
+bitsandbytes
+einops
+wandb
+tensorboard
+tiktoken
+pandas
+numpy
+scipy
+matplotlib
+sentencepiece
+nltk
+xformers
+git+https://github.com/huggingface/datatrove.git
+hf_transfer
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements_xpu.txt b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements_xpu.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9e5918b95180acbdc5789115ba0af71c8adf3aa5
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/requirements_xpu.txt
@@ -0,0 +1,22 @@
+git+https://github.com/huggingface/transformers
+git+https://github.com/huggingface/accelerate
+git+https://github.com/huggingface/peft
+git+https://github.com/huggingface/trl
+git+https://github.com/huggingface/datatrove.git
+deepspeed
+PyGithub
+huggingface-hub
+evaluate
+datasets
+bitsandbytes
+einops
+wandb
+tensorboard
+tiktoken
+pandas
+numpy
+scipy
+matplotlib
+sentencepiece
+nltk
+hf_transfer
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft.sh b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft.sh
new file mode 100644
index 0000000000000000000000000000000000000000..daa29f14f3cddcc829a68248c8055035f9206a5c
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft.sh
@@ -0,0 +1,41 @@
+python train.py \
+--seed 100 \
+--model_name_or_path "mistralai/Mistral-7B-v0.1" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "mistral-sft-lora" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 8 \
+--gradient_checkpointing True \
+--use_reentrant True \
+--dataset_text_field "content" \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--use_flash_attn True
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_deepspeed.sh b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_deepspeed.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8c2bcb13553c0c85c270494377cbcc7d72df9d00
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_deepspeed.sh
@@ -0,0 +1,39 @@
+accelerate launch --config_file "configs/deepspeed_config.yaml" train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "mistral-sft-lora-deepspeed" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 4 \
+--gradient_checkpointing True \
+--use_reentrant False \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization False
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_fsdp.sh b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_fsdp.sh
new file mode 100644
index 0000000000000000000000000000000000000000..82c595d2d6b99a48ad916015f090bcf908e954d5
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_fsdp.sh
@@ -0,0 +1,39 @@
+accelerate launch --config_file "configs/fsdp_config.yaml" train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "mistral-sft-lora-fsdp" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 4 \
+--gradient_checkpointing True \
+--use_reentrant False \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization False
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_fsdp_gptq.sh b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_fsdp_gptq.sh
new file mode 100644
index 0000000000000000000000000000000000000000..9f0939e9c923785c4ad3cd23674c7877fc247488
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_fsdp_gptq.sh
@@ -0,0 +1,36 @@
+accelerate launch --config_file "configs/fsdp_config.yaml" train.py \
+--seed 100 \
+--model_name_or_path "hugging-quants/Meta-Llama-3.1-8B-Instruct-GPTQ-INT4" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "llama3-8B-gptq-sft-lora-fsdp" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 4 \
+--gradient_checkpointing True \
+--use_reentrant False \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "q_proj,k_proj,v_proj,o_proj,up_proj,gate_proj" \
+--use_4bit_quantization False
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_multigpu.sh b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_multigpu.sh
new file mode 100644
index 0000000000000000000000000000000000000000..797df71d6e19b3a6f2bc3a6a92afa2413cfba355
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_multigpu.sh
@@ -0,0 +1,41 @@
+torchrun --nproc_per_node 8 --nnodes 1 train.py \
+--seed 100 \
+--model_name_or_path "mistralai/Mistral-7B-v0.1" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "mistral-sft-lora-multigpu" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 8 \
+--gradient_checkpointing True \
+--use_reentrant False \
+--dataset_text_field "content" \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--use_flash_attn True
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_qlora_deepspeed_stage3.sh b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_qlora_deepspeed_stage3.sh
new file mode 100644
index 0000000000000000000000000000000000000000..9c0fa3a63784f8afb36f610651a00737ab912de1
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_qlora_deepspeed_stage3.sh
@@ -0,0 +1,42 @@
+accelerate launch --config_file "configs/deepspeed_config_z3_qlora.yaml" train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "llama-sft-qlora-dsz3" \
+--per_device_train_batch_size 2 \
+--per_device_eval_batch_size 2 \
+--gradient_accumulation_steps 2 \
+--gradient_checkpointing True \
+--use_reentrant True \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--bnb_4bit_quant_storage_dtype "bfloat16"
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_qlora_fsdp.sh b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_qlora_fsdp.sh
new file mode 100644
index 0000000000000000000000000000000000000000..ca448cf34bfc44fcdabd715078fabbbc48d67782
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_peft_qlora_fsdp.sh
@@ -0,0 +1,42 @@
+accelerate launch --config_file "configs/fsdp_config_qlora.yaml" train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "llama-sft-qlora-fsdp" \
+--per_device_train_batch_size 2 \
+--per_device_eval_batch_size 2 \
+--gradient_accumulation_steps 2 \
+--gradient_checkpointing True \
+--use_reentrant True \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--bnb_4bit_quant_storage_dtype "bfloat16"
\ No newline at end of file
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_unsloth_peft.sh b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_unsloth_peft.sh
new file mode 100644
index 0000000000000000000000000000000000000000..608a1d93940fd72583009e204a796f510b7fe12c
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/run_unsloth_peft.sh
@@ -0,0 +1,42 @@
+python train.py \
+--seed 100 \
+--model_name_or_path "mistralai/Mistral-7B-v0.1" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "mistral-sft-lora-unsloth" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 8 \
+--gradient_checkpointing True \
+--use_reentrant True \
+--dataset_text_field "content" \
+--use_peft_lora True \
+--use_unsloth True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "q_proj,k_proj,v_proj,o_proj,down_proj,up_proj,gate_proj" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--use_flash_attn True
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/train.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/train.py
new file mode 100644
index 0000000000000000000000000000000000000000..921ae9910488caf2ff0c51fdc709494b2a084ab9
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/train.py
@@ -0,0 +1,156 @@
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Optional
+
+from transformers import HfArgumentParser, set_seed
+from trl import SFTConfig, SFTTrainer
+from utils import create_and_prepare_model, create_datasets
+
+
+# Define and parse arguments.
+@dataclass
+class ModelArguments:
+ """
+ Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
+ """
+
+ model_name_or_path: str = field(
+ metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}
+ )
+ chat_template_format: Optional[str] = field(
+ default="none",
+ metadata={
+ "help": "chatml|zephyr|none. Pass `none` if the dataset is already formatted with the chat template."
+ },
+ )
+ lora_alpha: Optional[int] = field(default=16)
+ lora_dropout: Optional[float] = field(default=0.1)
+ lora_r: Optional[int] = field(default=64)
+ lora_target_modules: Optional[str] = field(
+ default="q_proj,k_proj,v_proj,o_proj,down_proj,up_proj,gate_proj",
+ metadata={"help": "comma separated list of target modules to apply LoRA layers to"},
+ )
+ use_nested_quant: Optional[bool] = field(
+ default=False,
+ metadata={"help": "Activate nested quantization for 4bit base models"},
+ )
+ bnb_4bit_compute_dtype: Optional[str] = field(
+ default="float16",
+ metadata={"help": "Compute dtype for 4bit base models"},
+ )
+ bnb_4bit_quant_storage_dtype: Optional[str] = field(
+ default="uint8",
+ metadata={"help": "Quantization storage dtype for 4bit base models"},
+ )
+ bnb_4bit_quant_type: Optional[str] = field(
+ default="nf4",
+ metadata={"help": "Quantization type fp4 or nf4"},
+ )
+ use_flash_attn: Optional[bool] = field(
+ default=False,
+ metadata={"help": "Enables Flash attention for training."},
+ )
+ use_peft_lora: Optional[bool] = field(
+ default=False,
+ metadata={"help": "Enables PEFT LoRA for training."},
+ )
+ use_8bit_quantization: Optional[bool] = field(
+ default=False,
+ metadata={"help": "Enables loading model in 8bit."},
+ )
+ use_4bit_quantization: Optional[bool] = field(
+ default=False,
+ metadata={"help": "Enables loading model in 4bit."},
+ )
+ use_reentrant: Optional[bool] = field(
+ default=False,
+ metadata={"help": "Gradient Checkpointing param. Refer the related docs"},
+ )
+ use_unsloth: Optional[bool] = field(
+ default=False,
+ metadata={"help": "Enables UnSloth for training."},
+ )
+
+
+@dataclass
+class DataTrainingArguments:
+ dataset_name: Optional[str] = field(
+ default="timdettmers/openassistant-guanaco",
+ metadata={"help": "The preference dataset to use."},
+ )
+ append_concat_token: Optional[bool] = field(
+ default=False,
+ metadata={"help": "If True, appends `eos_token_id` at the end of each sample being packed."},
+ )
+ add_special_tokens: Optional[bool] = field(
+ default=False,
+ metadata={"help": "If True, tokenizers adds special tokens to each sample being packed."},
+ )
+ splits: Optional[str] = field(
+ default="train,test",
+ metadata={"help": "Comma separate list of the splits to use from the dataset."},
+ )
+
+
+def main(model_args, data_args, training_args):
+ # Set seed for reproducibility
+ set_seed(training_args.seed)
+
+ # model
+ model, peft_config, tokenizer = create_and_prepare_model(model_args, data_args, training_args)
+
+ # gradient ckpt
+ model.config.use_cache = not training_args.gradient_checkpointing
+ training_args.gradient_checkpointing = training_args.gradient_checkpointing and not model_args.use_unsloth
+ if training_args.gradient_checkpointing:
+ training_args.gradient_checkpointing_kwargs = {"use_reentrant": model_args.use_reentrant}
+
+ training_args.dataset_kwargs = {
+ "append_concat_token": data_args.append_concat_token,
+ "add_special_tokens": data_args.add_special_tokens,
+ }
+
+ # datasets
+ train_dataset, eval_dataset = create_datasets(
+ tokenizer,
+ data_args,
+ training_args,
+ apply_chat_template=model_args.chat_template_format != "none",
+ )
+
+ # trainer
+ trainer = SFTTrainer(
+ model=model,
+ processing_class=tokenizer,
+ args=training_args,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ peft_config=peft_config,
+ )
+ trainer.accelerator.print(f"{trainer.model}")
+ if hasattr(trainer.model, "print_trainable_parameters"):
+ trainer.model.print_trainable_parameters()
+
+ # train
+ checkpoint = None
+ if training_args.resume_from_checkpoint is not None:
+ checkpoint = training_args.resume_from_checkpoint
+ trainer.train(resume_from_checkpoint=checkpoint)
+
+ # saving final model
+ if trainer.is_fsdp_enabled:
+ trainer.accelerator.state.fsdp_plugin.set_state_dict_type("FULL_STATE_DICT")
+ trainer.save_model()
+
+
+if __name__ == "__main__":
+ parser = HfArgumentParser((ModelArguments, DataTrainingArguments, SFTConfig))
+ if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
+ # If we pass only one argument to the script and it's the path to a json file,
+ # let's parse it to get our arguments.
+ model_args, data_args, training_args = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+ else:
+ model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+ model_args.max_length = training_args.max_length
+ main(model_args, data_args, training_args)
diff --git a/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/utils.py b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..2fcb8dabd4108fe8ccd2549ac90501d3ed914076
--- /dev/null
+++ b/tasks/tasksmith-0d2d1e298e86/environment/source/examples/sft/utils.py
@@ -0,0 +1,219 @@
+import os
+from enum import Enum
+
+import packaging.version
+import torch
+import transformers
+from datasets import DatasetDict, load_dataset, load_from_disk
+from datasets.builder import DatasetGenerationError
+from transformers import (
+ AutoModelForCausalLM,
+ AutoTokenizer,
+ BitsAndBytesConfig,
+)
+
+from peft import LoraConfig
+
+
+DEFAULT_CHATML_CHAT_TEMPLATE = "{% for message in messages %}\n{{'<|im_start|>' + message['role'] + '\n' + message['content'] + '<|im_end|>' + '\n'}}{% if loop.last and add_generation_prompt %}{{'<|im_start|>assistant\n' }}{% endif %}{% endfor %}"
+DEFAULT_ZEPHYR_CHAT_TEMPLATE = "{% for message in messages %}\n{% if message['role'] == 'user' %}\n{{ '<|user|>\n' + message['content'] + eos_token }}\n{% elif message['role'] == 'system' %}\n{{ '<|system|>\n' + message['content'] + eos_token }}\n{% elif message['role'] == 'assistant' %}\n{{ '<|assistant|>\n' + message['content'] + eos_token }}\n{% endif %}\n{% if loop.last and add_generation_prompt %}\n{{ '<|assistant|>' }}\n{% endif %}\n{% endfor %}"
+
+
+class ZephyrSpecialTokens(str, Enum):
+ user = "<|user|>"
+ assistant = "<|assistant|>"
+ system = "<|system|>"
+ eos_token = ""
+ bos_token = "![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ngqdEv0rP01q"
+ },
+ "source": [
+ "## Introduction\n",
+ "\n",
+ "In this notebook, we are going to fine-tune the LayoutLM model by Microsoft Research on the [FUNSD](https://guillaumejaume.github.io/FUNSD/) dataset, which is a collection of annotated form documents. The goal of our model is to learn the annotations of a number of labels (\"question\", \"answer\", \"header\" and \"other\") on those forms, such that it can be used to annotate unseen forms in the future.\n",
+ "\n",
+ "* Original LayoutLM paper: https://huggingface.co/papers/1912.13318\n",
+ "\n",
+ "* Original FUNSD paper: https://huggingface.co/papers/1905.13538\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "6K4S2s33ebY0"
+ },
+ "source": [
+ "## Install libraries\n",
+ "\n",
+ "Currently you have to first install the `unilm` package, and then the `transformers` package (which updates the outdated `transformers` package that is included in the `unilm` package). The reason we also install the `unilm` package is because we need its preprocessing files. I've forked it, and removed some statements which introduced some issues."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000
+ },
+ "id": "5cngOTr6SqEf",
+ "outputId": "6c7a2f76-682b-4f93-a3db-59ab010e5ffe"
+ },
+ "outputs": [],
+ "source": [
+ "! rm -r unilm\n",
+ "! git clone https://github.com/microsoft/unilm.git"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "RGMkEG5aRB0D"
+ },
+ "source": [
+ "## Getting the data\n",
+ "\n",
+ "Here we download the data of the [FUNSD dataset](https://guillaumejaume.github.io/FUNSD/) from the web. This results in a directory called \"data\" being created, which has 2 subdirectories, one for training and one for testing. Each of those has 2 subdirectories in turn, one containing the images as png files and one containing the annotations in json format."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "DTFnEZagQm4v",
+ "outputId": "97ce03ba-a6bb-4444-8eba-77eceece44e0"
+ },
+ "outputs": [],
+ "source": [
+ "! wget https://guillaumejaume.github.io/FUNSD/dataset.zip\n",
+ "! unzip dataset.zip && mv dataset data && rm -rf dataset.zip __MACOSX"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "UrNMR64LsJXm"
+ },
+ "source": [
+ "Let's take a look at a training example. For this, we are going to use PIL (Python Image Library)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000
+ },
+ "id": "eG-eGcj3sNPs",
+ "outputId": "69ead0ea-15d6-4d5e-af61-a99a7533d31b"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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",
+ "image/png": "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",
+ "text/plain": [
+ "