Stage Harbor release files 72001-72500

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_gspo_token_trainer.py

@@ -0,0 +1,60 @@
+# 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 torch
+from datasets import load_dataset
+from transformers.utils import is_peft_available
+
+from trl import GRPOConfig
+from trl.experimental.gspo_token import GRPOTrainer as GSPOTokenTrainer
+
+from ..testing_utils import TrlTestCase
+
+
+if is_peft_available():
+    pass
+
+
+class TestGSPOTokenTrainer(TrlTestCase):
+    def test_train(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = GRPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            num_iterations=2,  # the importance sampling weights won't be 0 in this case
+            importance_sampling_level="sequence_token",
+            report_to="none",
+        )
+        trainer = GSPOTokenTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_harbor.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.
+
+"""Tests for the Harbor x TRL integration that don't need a running Harbor sandbox.
+
+`harbor` is imported lazily (only when an env is *started*), so spec construction, agent resolution, dataset building,
+and the reward function are all testable without `harbor` / a sandbox backend.
+"""
+
+from pathlib import Path
+
+import pytest
+
+from trl.experimental.harbor import AGENTS, HarborBashEnv, HarborEnv, HarborSpec
+from trl.experimental.harbor._spec import _outcome_reward_func, _resolve_agent
+
+from ..testing_utils import TrlTestCase
+
+
+def _write_task(tasks_dir: Path, task_id: str, gold: str, difficulty: int) -> None:
+    d = tasks_dir / task_id
+    (d / "environment").mkdir(parents=True)
+    (d / "tests").mkdir()
+    (d / "instruction.md").write_text(f"Solve task {task_id}.")
+    # Built from a joined list (not a triple-quoted block) so doc-builder doesn't reflow the TOML.
+    lines = [
+        "[task]",
+        f'name = "{task_id}"',
+        "[metadata]",
+        f'gold_answer = "{gold}"',
+        'reward_mode_initial = "exact_short"',
+        f"difficulty_level = {difficulty}",
+        f'kaggle_dataset_name = "owner/{task_id}"',
+    ]
+    (d / "task.toml").write_text("\n".join(lines))
+
+
+class TestResolveAgent(TrlTestCase):
+    def test_builtin_name(self):
+        assert _resolve_agent("bash") is HarborBashEnv
+        assert AGENTS["bash"] is HarborBashEnv
+
+    def test_class_passthrough(self):
+        assert _resolve_agent(HarborBashEnv) is HarborBashEnv
+
+    def test_import_path(self):
+        assert _resolve_agent("trl.experimental.harbor:HarborBashEnv") is HarborBashEnv
+
+    def test_file_path(self):
+        path = Path(self.tmp_dir) / "my_harness.py"
+        path.write_text(
+            "from trl.experimental.harbor import HarborEnv\n"
+            "class MyEnv(HarborEnv):\n"
+            "    def run_cmd(self, command: str) -> str:\n"
+            "        'Run a command.\\n\\nArgs:\\n    command: cmd.'\n"
+            "        return self._exec(command)\n"
+        )
+        cls = _resolve_agent(f"{path}:MyEnv")
+        assert issubclass(cls, HarborEnv) and cls.__name__ == "MyEnv"
+
+    def test_unknown_name_raises(self):
+        with pytest.raises(ValueError):
+            _resolve_agent("not-a-harness")
+
+    def test_non_harborenv_raises(self):
+        with pytest.raises(TypeError):
+            _resolve_agent("trl.experimental.harbor:HarborSpec")  # not a HarborEnv subclass
+
+
+class TestHarborSpecDataset(TrlTestCase):
+    def _suite(self) -> str:
+        tasks = Path(self.tmp_dir) / "tasks"
+        tasks.mkdir()
+        _write_task(tasks, "0001_a", "alpha", 0)
+        _write_task(tasks, "0002_b", "beta", 3)
+        return str(self.tmp_dir)
+
+    def test_train_dataset_columns_and_metadata(self):
+        ds = HarborSpec(self._suite()).train_dataset
+        assert len(ds) == 2
+        assert ds[0]["prompt"] == [{"role": "user", "content": ""}]  # env appends instruction at reset
+        assert ds[0]["task_dir"].endswith("0001_a")
+        assert ds[0]["task_index"] == 0
+        assert ds[0]["gold_answer"] == "alpha"
+        assert ds[1]["difficulty_level"] == 3
+
+    def test_num_tasks_cap(self):
+        ds = HarborSpec(self._suite(), num_tasks=1).train_dataset
+        assert len(ds) == 1
+
+    def test_indices_selection(self):
+        ds = HarborSpec(self._suite(), indices=[1]).train_dataset
+        assert len(ds) == 1 and ds[0]["task_dir"].endswith("0002_b")
+
+    def test_num_tasks_and_indices_mutually_exclusive(self):
+        with pytest.raises(ValueError):
+            HarborSpec(self._suite(), num_tasks=1, indices=[0])
+
+    def test_environment_factory_returns_fresh_envs(self):
+        factory = HarborSpec(self._suite(), agent="bash").environment_factory
+        e1, e2 = factory(), factory()
+        assert isinstance(e1, HarborBashEnv) and e1 is not e2
+
+
+class TestRewardFunc(TrlTestCase):
+    def test_outcome_reward_reads_env_reward(self):
+        class _Env:
+            def __init__(self, r):
+                self.reward = r
+
+        assert _outcome_reward_func([_Env(1.0), _Env(0.0)]) == [1.0, 0.0]
+
+    def test_outcome_reward_uses_environment_reward_when_passed(self):
+        # AsyncGRPOTrainer captures rewards in its rollout worker and passes them as a list, with no
+        # live env instances. The reward func must use them directly.
+        assert _outcome_reward_func(environment_reward=[0.25, 0.75]) == [0.25, 0.75]
+
+    def test_fresh_env_reward_is_zero_without_backend(self):
+        # The trainer discovers tool methods via `inspect.getmembers`, which evaluates properties. A fresh
+        # env (never `reset`) must expose its tools and return 0.0 from `reward` WITHOUT starting the
+        # Harbor backend or importing `harbor` (not installed in the trainer env).
+        import inspect
+
+        env = HarborBashEnv()
+        names = {n for n, _ in inspect.getmembers(env, predicate=inspect.ismethod)}
+        assert {"bash", "reset"} <= names
+        assert env.reward == 0.0

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_kto_trainer.py

@@ -0,0 +1,774 @@
+# 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 multiprocess
+import pytest
+import torch
+import transformers
+from datasets import Dataset, load_dataset
+from packaging.version import Version
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from trl.experimental.kto import KTOConfig, KTOTrainer
+from trl.experimental.kto.kto_trainer import (
+    DataCollatorForUnpairedPreference,
+    DataCollatorForVisionUnpairedPreference,
+    _get_kl_completion_ids,
+)
+
+from ..testing_utils import TrlTestCase, require_liger_kernel, require_peft, require_vision
+
+
+@require_vision
+class TestDataCollatorForVisionUnpairedPreference(TrlTestCase):
+    @pytest.mark.skipif(
+        Version(transformers.__version__) < Version("5.3.0"),
+        reason="mm_token_type_ids are returned by default since transformers-5.3.0 (see transformers#43972)",
+    )
+    def test_mm_token_type_ids_shape(self):
+        # Regression guard: when the processor returns mm_token_type_ids (Qwen2.5-VL after transformers#43972),
+        # the collator must produce a KL_completion_token_type_ids whose width matches KL_completion_input_ids,
+        # not the main completion's width (the two differ whenever their text lengths differ).
+        from PIL import Image
+        from transformers import AutoProcessor
+
+        processor = AutoProcessor.from_pretrained("trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration")
+        collator = DataCollatorForVisionUnpairedPreference(processor, calculate_kl=True)
+        image = Image.new("RGB", (16, 16))
+        examples = [
+            {
+                "images": [image],
+                "prompt": [{"role": "user", "content": "What is this?"}],
+                "completion": [{"role": "assistant", "content": "A red square."}],
+                "label": True,
+            },
+            {
+                "images": [image],
+                "prompt": [{"role": "user", "content": "Describe it."}],
+                "completion": [{"role": "assistant", "content": "An image."}],
+                "label": False,
+            },
+        ]
+        output = collator(examples)
+
+        assert "mm_token_type_ids" in output
+        assert output["mm_token_type_ids"].shape == output["completion_input_ids"].shape, (
+            f"mm_token_type_ids shape {output['mm_token_type_ids'].shape} != "
+            f"completion_input_ids shape {output['completion_input_ids'].shape}"
+        )
+        assert "KL_completion_mm_token_type_ids" in output
+        assert output["KL_completion_mm_token_type_ids"].shape == output["KL_completion_input_ids"].shape, (
+            f"KL_completion_mm_token_type_ids shape {output['KL_completion_mm_token_type_ids'].shape} != "
+            f"KL_completion_input_ids shape {output['KL_completion_input_ids'].shape}"
+        )
+
+    def test_output_keys(self):
+        from PIL import Image
+        from transformers import AutoProcessor
+
+        processor = AutoProcessor.from_pretrained("trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration")
+        image = Image.new("RGB", (16, 16))
+
+        def make_examples():
+            return [
+                {
+                    "images": [image],
+                    "prompt": [{"role": "user", "content": "What is this?"}],
+                    "completion": [{"role": "assistant", "content": "A red square."}],
+                    "label": True,
+                },
+                {
+                    "images": [image],
+                    "prompt": [{"role": "user", "content": "Describe it."}],
+                    "completion": [{"role": "assistant", "content": "An image."}],
+                    "label": False,
+                },
+            ]
+
+        # With KL
+        collator = DataCollatorForVisionUnpairedPreference(processor, calculate_kl=True)
+        output = collator(make_examples())
+        for key in ["completion_input_ids", "completion_attention_mask", "completion_mask", "pixel_values", "label"]:
+            assert key in output, f"Missing key: {key}"
+        for key in ["KL_completion_input_ids", "KL_completion_attention_mask", "KL_completion_mask"]:
+            assert key in output, f"Missing KL key: {key}"
+
+        # Without KL
+        collator_no_kl = DataCollatorForVisionUnpairedPreference(processor, calculate_kl=False)
+        output_no_kl = collator_no_kl(make_examples())
+        assert "completion_input_ids" in output_no_kl
+        assert "KL_completion_input_ids" not in output_no_kl
+
+    def test_kl_cycling(self):
+        # The KL completion for example i must be the completion from example i-1 (cycled by +1).
+        from PIL import Image
+        from transformers import AutoProcessor
+
+        processor = AutoProcessor.from_pretrained("trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration")
+        collator = DataCollatorForVisionUnpairedPreference(processor, calculate_kl=True)
+        image = Image.new("RGB", (16, 16))
+        # Two distinct completions so that cycling is detectable
+        examples = [
+            {
+                "images": [image],
+                "prompt": [{"role": "user", "content": "Q1"}],
+                "completion": [{"role": "assistant", "content": "Answer one."}],
+                "label": True,
+            },
+            {
+                "images": [image],
+                "prompt": [{"role": "user", "content": "Q2"}],
+                "completion": [{"role": "assistant", "content": "Answer two."}],
+                "label": False,
+            },
+        ]
+        output = collator(examples)
+        # KL completions are cycled: KL[0] = completion[-1], KL[1] = completion[0]
+        # They must differ from the matching main completion (unless both are identical strings, which they aren't here)
+        assert not torch.equal(output["completion_input_ids"][0], output["KL_completion_input_ids"][0])
+        assert not torch.equal(output["completion_input_ids"][1], output["KL_completion_input_ids"][1])
+
+
+class TestDataCollatorForUnpairedPreference(TrlTestCase):
+    def test_padding_and_masks(self):
+        collator = DataCollatorForUnpairedPreference(pad_token_id=0)
+        examples = [
+            {"prompt_ids": [1, 2, 3], "completion_ids": [4, 5], "KL_completion_ids": [6], "label": True},
+            {"prompt_ids": [7, 8], "completion_ids": [9, 10], "KL_completion_ids": [11, 12, 13], "label": False},
+        ]
+        result = collator(examples)
+
+        expected_completion_input_ids = torch.tensor(
+            [
+                [1, 2, 3, 4, 5],  # prompt + completion (example 1)
+                [7, 8, 9, 10, 0],  # prompt + completion (example 2, padded)
+            ]
+        )
+        expected_completion_attention_mask = torch.tensor(
+            [
+                [1, 1, 1, 1, 1],
+                [1, 1, 1, 1, 0],
+            ]
+        )
+        expected_completion_mask = torch.tensor(
+            [
+                [0, 0, 0, 1, 1],  # completion (example 1)
+                [0, 0, 1, 1, 0],  # completion (example 2, padded)
+            ]
+        )
+        expected_kl_completion_input_ids = torch.tensor(
+            [
+                [1, 2, 3, 6, 0],  # prompt + KL completion (example 1, padded)
+                [7, 8, 11, 12, 13],  # prompt + KL completion (example 2)
+            ]
+        )
+        expected_kl_completion_attention_mask = torch.tensor(
+            [
+                [1, 1, 1, 1, 0],
+                [1, 1, 1, 1, 1],
+            ]
+        )
+        expected_kl_completion_mask = torch.tensor(
+            [
+                [0, 0, 0, 1, 0],  # KL completion (example 1, padded)
+                [0, 0, 1, 1, 1],  # KL completion (example 2)
+            ]
+        )
+
+        assert set(result.keys()) == {
+            "completion_input_ids",
+            "completion_attention_mask",
+            "completion_mask",
+            "KL_completion_input_ids",
+            "KL_completion_attention_mask",
+            "KL_completion_mask",
+            "label",
+        }
+        torch.testing.assert_close(result["completion_input_ids"], expected_completion_input_ids)
+        torch.testing.assert_close(result["completion_attention_mask"], expected_completion_attention_mask)
+        torch.testing.assert_close(result["completion_mask"], expected_completion_mask)
+        torch.testing.assert_close(result["KL_completion_input_ids"], expected_kl_completion_input_ids)
+        torch.testing.assert_close(result["KL_completion_attention_mask"], expected_kl_completion_attention_mask)
+        torch.testing.assert_close(result["KL_completion_mask"], expected_kl_completion_mask)
+        assert result["label"] == [True, False]
+
+    def test_optional_reference_logps(self):
+        collator = DataCollatorForUnpairedPreference(pad_token_id=0)
+        examples = [
+            {
+                "prompt_ids": [1, 2],
+                "completion_ids": [3],
+                "KL_completion_ids": [4],
+                "ref_logps": 0.1,
+                "ref_KL_logps": 0.2,
+                "label": True,
+            },
+            {
+                "prompt_ids": [5],
+                "completion_ids": [6, 7],
+                "KL_completion_ids": [8, 9],
+                "ref_logps": 0.3,
+                "ref_KL_logps": 0.4,
+                "label": False,
+            },
+        ]
+        result = collator(examples)
+
+        expected_ref_logps = torch.tensor([0.1, 0.3])
+        expected_ref_kl_logps = torch.tensor([0.2, 0.4])
+
+        assert set(result.keys()) == {
+            "completion_input_ids",
+            "completion_attention_mask",
+            "completion_mask",
+            "KL_completion_input_ids",
+            "KL_completion_attention_mask",
+            "KL_completion_mask",
+            "ref_logps",
+            "ref_KL_logps",
+            "label",
+        }
+        torch.testing.assert_close(result["ref_logps"], expected_ref_logps)
+        torch.testing.assert_close(result["ref_KL_logps"], expected_ref_kl_logps)
+
+    def test_with_pad_to_multiple_of(self):
+        collator = DataCollatorForUnpairedPreference(pad_token_id=0, pad_to_multiple_of=5)
+        examples = [
+            {"prompt_ids": [1], "completion_ids": [2], "KL_completion_ids": [3], "label": True},
+            {"prompt_ids": [4, 5], "completion_ids": [6, 7], "KL_completion_ids": [8, 9], "label": False},
+        ]
+        result = collator(examples)
+
+        expected_completion_input_ids = torch.tensor(
+            [
+                [1, 2, 0, 0, 0],  # prompt + completion (example 1, padded to multiple of 5)
+                [4, 5, 6, 7, 0],  # prompt + completion (example 2)
+            ]
+        )
+        expected_kl_completion_input_ids = torch.tensor(
+            [
+                [1, 3, 0, 0, 0],  # prompt + KL completion (example 1, padded to multiple of 5)
+                [4, 5, 8, 9, 0],  # prompt + KL completion (example 2)
+            ]
+        )
+
+        assert set(result.keys()) == {
+            "completion_input_ids",
+            "completion_attention_mask",
+            "completion_mask",
+            "KL_completion_input_ids",
+            "KL_completion_attention_mask",
+            "KL_completion_mask",
+            "label",
+        }
+        torch.testing.assert_close(result["completion_input_ids"], expected_completion_input_ids)
+        torch.testing.assert_close(result["KL_completion_input_ids"], expected_kl_completion_input_ids)
+
+
+class TestKTOTrainer(TrlTestCase):
+    def setup_method(self):
+        self.model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        self.model = AutoModelForCausalLM.from_pretrained(self.model_id, dtype="float32")
+        self.ref_model = AutoModelForCausalLM.from_pretrained(self.model_id)
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+        self.tokenizer.pad_token = self.tokenizer.eos_token
+
+    @pytest.mark.parametrize(
+        "config_name, loss_type, pre_compute, eval_dataset",
+        [
+            ("standard_preference", "kto", True, True),
+            ("standard_unpaired_preference", "kto", False, True),
+            ("conversational_implicit_prompt_preference", "apo_zero_unpaired", True, True),
+            ("standard_unpaired_preference", "apo_zero_unpaired", False, True),
+        ],
+    )
+    def test_kto_trainer(self, config_name, loss_type, pre_compute, eval_dataset):
+        training_args = KTOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            gradient_accumulation_steps=1,
+            learning_rate=9e-1,
+            eval_strategy="steps" if eval_dataset else "no",
+            beta=0.1,
+            precompute_ref_log_probs=pre_compute,
+            loss_type=loss_type,
+            report_to="none",
+        )
+
+        dataset = load_dataset("trl-internal-testing/zen", config_name)
+
+        trainer = KTOTrainer(
+            model=self.model,
+            ref_model=self.ref_model,
+            args=training_args,
+            processing_class=self.tokenizer,
+            train_dataset=dataset["train"],
+            eval_dataset=dataset["test"] if eval_dataset else None,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if param.sum() != 0:  # ignore 0 biases
+                assert not torch.equal(param, new_param)
+
+    def test_trust_remote_code(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference", split="train")
+        model_id = "trl-internal-testing/tiny-RemoteForCausalLM"
+
+        with pytest.raises(ValueError, match="custom code"):
+            KTOTrainer(
+                model=model_id,
+                args=KTOConfig(output_dir=self.tmp_dir, report_to="none"),
+                train_dataset=dataset,
+            )
+
+        trainer = KTOTrainer(
+            model=model_id,
+            args=KTOConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True),
+            train_dataset=dataset,
+        )
+        assert type(trainer.model).__name__ == "RemoteForCausalLM"
+
+    def test_kto_trainer_with_ref_model_is_model(self):
+        training_args = KTOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            report_to="none",
+        )
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference", split="train")
+
+        with pytest.raises(ValueError):
+            KTOTrainer(
+                model=self.model,
+                ref_model=self.model,  # ref_model can't be the same as model
+                args=training_args,
+                processing_class=self.tokenizer,
+                train_dataset=dataset,
+            )
+
+    def test_tokenize_and_process_tokens(self):
+        # Pytest/CI often starts background threads before tests run. Under Python 3.12+,
+        # using "fork" in a multi-threaded process emits a DeprecationWarning and may deadlock.
+        # Force "spawn" to keep this multiprocessing test safe while still exercising `num_proc=2`.
+        multiprocess.set_start_method("spawn", force=True)
+
+        training_args = KTOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            gradient_accumulation_steps=1,
+            learning_rate=9e-1,
+            eval_strategy="steps",
+            beta=0.1,
+            report_to="none",
+        )
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference")
+        train_dataset = dataset["train"]
+
+        trainer = KTOTrainer(
+            model=self.model,
+            ref_model=self.ref_model,
+            args=training_args,
+            processing_class=self.tokenizer,
+            train_dataset=train_dataset,
+            eval_dataset=dataset["test"],
+        )
+
+        # Verify the tokenization step: dataset stores raw token IDs (aligned with DPO style).
+        # prompt_ids must start with the tokenized prompt text.
+        prompt_ids = self.tokenizer(train_dataset["prompt"][0])["input_ids"]
+        assert trainer.train_dataset[0]["prompt_ids"][: len(prompt_ids)] == prompt_ids
+        # completion_ids are the raw answer tokens (no prompt prefix, no BOS/EOS added yet).
+        assert len(trainer.train_dataset[0]["completion_ids"]) > 0
+
+        # Verify the collator output (assembly, BOS/EOS insertion, labels).
+        example = trainer.train_dataset[0]
+        batch = trainer.data_collator([example])
+        # completion_input_ids ends with EOS
+        assert batch["completion_input_ids"][0, -1].item() == self.tokenizer.eos_token_id
+        # completion_mask: prompt tokens are 0, completion tokens are 1; at least the prompt is masked
+        assert "completion_mask" in batch
+        completion_mask = batch["completion_mask"][0].tolist()
+        assert 0 in completion_mask and 1 in completion_mask
+        first_completion = next(i for i, m in enumerate(completion_mask) if m == 1)
+        assert first_completion > 0  # at least the prompt is masked
+        assert all(m == 0 for m in completion_mask[:first_completion])
+
+        # Test corruption of (prompt, completion) pairs for KL dataset.
+        # _get_kl_completion_ids shifts completion_ids by one within each batch; prompt_ids are unchanged.
+        synthetic = Dataset.from_dict(
+            {
+                "prompt_ids": [[1, 2], [3, 4], [5, 6]],
+                "completion_ids": [[10, 11], [20, 21], [30, 31]],
+                "label": [True, False, True],
+            }
+        )
+        for batch_size in [2, 3]:
+            rotated = synthetic.map(_get_kl_completion_ids, batched=True, batch_size=batch_size)
+
+            # Verify that completion_ids have been rotated (differ from original). When the dataset length
+            # modulo batch_size equals 1, the last batch is unaltered: exclude it from the check.
+            for i in range(len(rotated) - 1):
+                assert synthetic["prompt_ids"][i] == rotated["prompt_ids"][i]
+                assert synthetic["completion_ids"][i] != rotated["completion_ids"][i]
+
+    def test_kto_trainer_without_providing_ref_model(self):
+        training_args = KTOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            gradient_accumulation_steps=4,
+            learning_rate=9e-1,
+            eval_strategy="steps",
+            beta=0.1,
+            report_to="none",
+        )
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference")
+
+        trainer = KTOTrainer(
+            model=self.model,
+            ref_model=None,
+            args=training_args,
+            processing_class=self.tokenizer,
+            train_dataset=dataset["train"],
+            eval_dataset=dataset["test"],
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if param.sum() != 0:  # ignore 0 biases
+                assert not torch.equal(param, new_param)
+
+    @require_peft
+    def test_kto_trainer_without_providing_ref_model_with_lora(self):
+        from peft import LoraConfig
+
+        lora_config = LoraConfig(
+            r=16,
+            lora_alpha=32,
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        training_args = KTOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            gradient_accumulation_steps=4,
+            learning_rate=9e-1,
+            eval_strategy="steps",
+            beta=0.1,
+            report_to="none",
+        )
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference")
+
+        trainer = KTOTrainer(
+            model=self.model,
+            ref_model=None,
+            args=training_args,
+            processing_class=self.tokenizer,
+            train_dataset=dataset["train"],
+            eval_dataset=dataset["test"],
+            peft_config=lora_config,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            if "lora" in n:
+                new_param = trainer.model.get_parameter(n)
+                if param.sum() != 0:  # ignore 0 biases
+                    assert not torch.equal(param, new_param)
+
+    @require_liger_kernel
+    def test_kto_trainer_with_liger(self):
+        """Test KTO trainer with Liger kernel enabled."""
+        training_args = KTOConfig(
+            output_dir=self.tmp_dir,
+            report_to="none",
+            use_liger_kernel=True,  # Enable Liger kernel
+        )
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference", split="train")
+
+        trainer = KTOTrainer(
+            model=self.model,
+            args=training_args,
+            processing_class=self.tokenizer,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # check the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            # check the params have changed - ignore 0 biases
+            if param.sum() != 0:
+                assert not torch.equal(param, new_param)
+
+    def test_compute_metrics(self):
+        model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32")
+        ref_model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5")
+        tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5")
+        tokenizer.pad_token = tokenizer.eos_token
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference")
+
+        def dummy_compute_metrics(*args, **kwargs):
+            return {"test": 0.0}
+
+        training_args = KTOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            do_eval=True,
+            eval_strategy="steps",
+            eval_steps=1,
+            per_device_eval_batch_size=2,
+            report_to="none",
+        )
+
+        trainer = KTOTrainer(
+            model=model,
+            ref_model=ref_model,
+            args=training_args,
+            processing_class=tokenizer,
+            train_dataset=dataset["train"],
+            eval_dataset=dataset["test"],
+            compute_metrics=dummy_compute_metrics,
+        )
+
+        trainer.train()
+
+        assert trainer.state.log_history[-2]["eval_test"] == 0.0
+
+
+@require_vision
+class TestKTOTrainerVLM(TrlTestCase):
+    @pytest.mark.parametrize(
+        "model_id",
+        [
+            "trl-internal-testing/tiny-Gemma3ForConditionalGeneration",
+            pytest.param(
+                "trl-internal-testing/tiny-Gemma4ForConditionalGeneration",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.5.0"),
+                    reason="Gemma4 models were introduced in transformers-5.5.0",
+                ),
+            ),
+            "trl-internal-testing/tiny-LlavaForConditionalGeneration",
+            "trl-internal-testing/tiny-LlavaNextForConditionalGeneration",
+            "trl-internal-testing/tiny-Qwen2VLForConditionalGeneration",
+            "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+            # "trl-internal-testing/tiny-SmolVLMForConditionalGeneration", seems not to support bf16 properly
+            pytest.param(
+                "trl-internal-testing/tiny-Qwen3VLForConditionalGeneration",
+                marks=[
+                    pytest.mark.skipif(
+                        Version(transformers.__version__) < Version("4.57.0"),
+                        reason="Qwen3-VL series were introduced in transformers-4.57.0",
+                    ),
+                ],
+            ),
+            pytest.param(
+                "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.2.0"),
+                    reason="Qwen3.5 models were introduced in transformers-5.2.0",
+                ),
+            ),
+            pytest.param(
+                "trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.2.0"),
+                    reason="Qwen3.5 models were introduced in transformers-5.2.0",
+                ),
+            ),
+        ],
+    )
+    def test_train_vlm(self, model_id):
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_unpaired_preference", split="train")
+        training_args = KTOConfig(
+            output_dir=self.tmp_dir,
+            max_length=None,  # for VLMs, truncating can remove image tokens, leading to errors
+            per_device_train_batch_size=2,  # VLM training is memory intensive, reduce batch size to avoid OOM
+            report_to="none",
+        )
+        trainer = KTOTrainer(model=model_id, args=training_args, train_dataset=dataset)
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            # LLaVA & LLaVA-Next: vision_feature_layer=-2 leaves the last encoder layer (layers.1) and
+            # post_layernorm (pooler-only path) without gradient by design. Assert they stay frozen — if they
+            # ever start training, the feature-selection plumbing has likely regressed.
+            if model_id in (
+                "trl-internal-testing/tiny-LlavaForConditionalGeneration",
+                "trl-internal-testing/tiny-LlavaNextForConditionalGeneration",
+            ) and ("encoder.layers.1" in n or "post_layernorm" in n):
+                assert torch.equal(param, new_param), f"Param {n} expected frozen by LLaVA design, but changed"
+            else:
+                assert not torch.equal(param, new_param), f"Param {n} is not updated"
+
+    def test_train_vlm_apo_zero_unpaired(self):
+        # apo_zero_unpaired does not need the KL term: verify that calculate_kl=False path works end-to-end.
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_unpaired_preference", split="train")
+        training_args = KTOConfig(
+            output_dir=self.tmp_dir,
+            max_length=None,  # for VLMs, truncating can remove image tokens, leading to errors
+            per_device_train_batch_size=2,  # VLM training is memory intensive, reduce batch size to avoid OOM
+            loss_type="apo_zero_unpaired",
+            report_to="none",
+        )
+        trainer = KTOTrainer(
+            model="trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+            args=training_args,
+            train_dataset=dataset,
+        )
+        trainer.train()
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.parametrize(
+        "model_id",
+        [
+            "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+        ],
+    )
+    @pytest.mark.parametrize(
+        "dataset_config",
+        ["conversational_unpaired_preference", "standard_unpaired_preference"],
+    )
+    def test_train_vlm_text_only_data(self, model_id, dataset_config):
+        dataset = load_dataset("trl-internal-testing/zen", dataset_config, split="train")
+        training_args = KTOConfig(output_dir=self.tmp_dir, report_to="none")
+        trainer = KTOTrainer(
+            model=model_id,
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n.startswith("model.visual"):
+                torch.testing.assert_close(param, new_param, rtol=1e-12, atol=1e-12, msg=f"Param {n} is updated")
+            else:
+                assert not torch.equal(param, new_param), f"Param {n} is not updated"
+
+    def test_train_vlm_with_max_length(self):
+        # Regression test: mm_token_type_ids (and KL_completion_mm_token_type_ids) must be truncated alongside
+        # input_ids when max_length is set, otherwise a shape mismatch crashes the model forward pass.
+        # max_length=37 truncates 1 completion token (total_len=38) while keeping all image tokens (prompt_len=34) safe.
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_unpaired_preference", split="train")
+        training_args = KTOConfig(
+            output_dir=self.tmp_dir,
+            max_length=37,  # total_len=38, prompt_len=34 — truncates completion, not image tokens
+            per_device_train_batch_size=2,
+            report_to="none",
+        )
+        trainer = KTOTrainer(
+            model="trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+            args=training_args,
+            train_dataset=dataset,
+        )
+        trainer.train()
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    def test_vision_dataset_with_text_model_raises(self):
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_unpaired_preference", split="train")
+        training_args = KTOConfig(output_dir=self.tmp_dir, report_to="none")
+        with pytest.raises(ValueError, match="vision-related.*vision-language model"):
+            KTOTrainer(
+                model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+                args=training_args,
+                train_dataset=dataset,
+            )
+
+    def test_precompute_ref_log_probs_raises_for_vision(self):
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_unpaired_preference", split="train")
+        training_args = KTOConfig(output_dir=self.tmp_dir, report_to="none", precompute_ref_log_probs=True)
+        with pytest.raises(ValueError, match="precompute_ref_log_probs.*not supported for vision datasets"):
+            KTOTrainer(
+                model="trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+                args=training_args,
+                train_dataset=dataset,
+            )
+
+    @require_liger_kernel
+    def test_train_vlm_liger(self):
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_unpaired_preference", split="train")
+        training_args = KTOConfig(
+            output_dir=self.tmp_dir,
+            max_length=None,  # for VLMs, truncating can remove image tokens, leading to errors
+            per_device_train_batch_size=2,  # VLM training is memory intensive, reduce batch size to avoid OOM
+            use_liger_kernel=True,
+            report_to="none",
+        )
+        trainer = KTOTrainer(
+            model="trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Param {n} is not updated"

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_merge_model_callback.py

@@ -0,0 +1,84 @@
+# 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
+
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers.trainer_utils import get_last_checkpoint
+
+from trl import DPOConfig, DPOTrainer
+from trl.experimental.merge_model_callback import MergeConfig, MergeModelCallback
+
+from ..testing_utils import TrlTestCase, require_mergekit
+
+
+@require_mergekit
+class TestMergeModelCallback(TrlTestCase):
+    def setup_method(self):
+        self.model = AutoModelForCausalLM.from_pretrained(
+            "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32"
+        )
+        self.tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5")
+        self.dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+    def test_callback(self):
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            num_train_epochs=1,
+            report_to="none",
+            save_strategy="steps",
+            save_steps=1,
+        )
+        config = MergeConfig()
+        merge_callback = MergeModelCallback(config)
+        trainer = DPOTrainer(
+            model=self.model,
+            args=training_args,
+            train_dataset=self.dataset,
+            processing_class=self.tokenizer,
+            callbacks=[merge_callback],
+        )
+        trainer.train()
+        last_checkpoint = get_last_checkpoint(self.tmp_dir)
+        merged_path = os.path.join(last_checkpoint, "merged")
+        assert os.path.isdir(merged_path), "Merged folder does not exist in the last checkpoint."
+
+    def test_every_checkpoint(self):
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            num_train_epochs=1,
+            report_to="none",
+            save_strategy="steps",
+            save_steps=1,
+        )
+        config = MergeConfig()
+        merge_callback = MergeModelCallback(config, merge_at_every_checkpoint=True)
+        trainer = DPOTrainer(
+            model=self.model,
+            args=training_args,
+            train_dataset=self.dataset,
+            processing_class=self.tokenizer,
+            callbacks=[merge_callback],
+        )
+        trainer.train()
+
+        checkpoints = sorted(
+            [os.path.join(self.tmp_dir, cp) for cp in os.listdir(self.tmp_dir) if cp.startswith("checkpoint-")]
+        )
+
+        for checkpoint in checkpoints:
+            merged_path = os.path.join(checkpoint, "merged")
+            assert os.path.isdir(merged_path), f"Merged folder does not exist in checkpoint {checkpoint}."

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_minillm_trainer.py

@@ -0,0 +1,52 @@
+# 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 pytest
+import torch
+from datasets import load_dataset
+
+from trl.experimental.minillm import MiniLLMConfig, MiniLLMTrainer
+
+from ..testing_utils import TrlTestCase
+
+
+@pytest.mark.low_priority
+class TestMiniLLMTrainer(TrlTestCase):
+    def test_train(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = MiniLLMConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=32,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = MiniLLMTrainer(
+            model="trl-internal-testing/small-Qwen3ForCausalLM",
+            teacher_model="trl-internal-testing/tiny-Qwen3ForCausalLM",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_modeling_value_head.py

@@ -0,0 +1,112 @@
+# 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 torch
+
+from trl.experimental.ppo import AutoModelForCausalLMWithValueHead
+from trl.experimental.utils import create_reference_model
+
+from ..testing_utils import TrlTestCase
+
+
+class TestReferenceModel(TrlTestCase):
+    def setup_method(self):
+        self.model = AutoModelForCausalLMWithValueHead.from_pretrained("trl-internal-testing/tiny-GPT2LMHeadModel")
+        self.test_input = torch.tensor([[0, 1, 2, 3]])
+        self.optimizer = torch.optim.AdamW(self.model.parameters(), lr=1)
+        self.layer_format = "pretrained_model.transformer.h.{layer}.attn.c_attn.weight"
+
+    def test_independent_reference(self):
+        layer_0 = self.layer_format.format(layer=0)
+        layer_1 = self.layer_format.format(layer=1)
+
+        ref_model = create_reference_model(self.model)
+
+        first_layer_before = self.model.get_parameter(layer_0).data.clone()
+        last_layer_before = self.model.get_parameter(layer_1).data.clone()  # the model only has 2 layers
+
+        first_ref_layer_before = ref_model.get_parameter(layer_0).data.clone()
+        last_ref_layer_before = ref_model.get_parameter(layer_1).data.clone()
+
+        output = self.model(input_ids=self.test_input, labels=self.test_input)
+        output[1].backward()
+        self.optimizer.step()
+
+        first_layer_after = self.model.get_parameter(layer_0).data.clone()
+        last_layer_after = self.model.get_parameter(layer_1).data.clone()
+
+        first_ref_layer_after = ref_model.get_parameter(layer_0).data.clone()
+        last_ref_layer_after = ref_model.get_parameter(layer_1).data.clone()
+
+        # before optimization ref and model are identical
+        assert (first_layer_before == first_ref_layer_before).all()
+        assert (last_layer_before == last_ref_layer_before).all()
+
+        # ref model stays identical after optimization
+        assert (first_ref_layer_before == first_ref_layer_after).all()
+        assert (last_ref_layer_before == last_ref_layer_after).all()
+
+        # optimized model changes
+        assert not (first_layer_before == first_layer_after).all()
+        assert not (last_layer_before == last_layer_after).all()
+
+    def test_shared_layers(self):
+        layer_0 = self.layer_format.format(layer=0)
+        layer_1 = self.layer_format.format(layer=1)
+
+        ref_model = create_reference_model(self.model, num_shared_layers=1)
+
+        first_layer_before = self.model.get_parameter(layer_0).data.clone()
+        second_layer_before = self.model.get_parameter(layer_1).data.clone()
+
+        first_ref_layer_before = ref_model.get_parameter(layer_0).data.clone()
+        second_ref_layer_before = ref_model.get_parameter(layer_1).data.clone()
+
+        output = self.model(input_ids=self.test_input, labels=self.test_input)
+        output[1].backward()
+        self.optimizer.step()
+
+        first_layer_after = self.model.get_parameter(layer_0).data.clone()
+        second_layer_after = self.model.get_parameter(layer_1).data.clone()
+
+        first_ref_layer_after = ref_model.get_parameter(layer_0).data.clone()
+        second_ref_layer_after = ref_model.get_parameter(layer_1).data.clone()
+
+        # before optimization ref and model are identical
+        assert (first_layer_before == first_ref_layer_before).all()
+        assert (second_layer_before == second_ref_layer_before).all()
+
+        # ref model stays identical after optimization
+        assert (first_ref_layer_before == first_ref_layer_after).all()
+        assert (second_ref_layer_before == second_ref_layer_after).all()
+
+        # first layer of optimized model stays the same
+        assert (first_layer_before == first_layer_after).all()
+
+        # other layers in optimized model change
+        assert not (second_layer_before == second_layer_after).all()
+
+    def test_shared_layers_share_memory(self):
+        # Shared layers must reference the same storage as the source model, not a `deepcopy` duplicate,
+        # so they are held in memory only once (see issue #2904).
+        layer_0 = self.layer_format.format(layer=0)
+        layer_1 = self.layer_format.format(layer=1)
+
+        ref_model = create_reference_model(self.model, num_shared_layers=1)
+
+        # the shared layer points at the same storage as the source model
+        assert ref_model.get_parameter(layer_0).data_ptr() == self.model.get_parameter(layer_0).data_ptr()
+        # an unshared layer is an independent copy
+        assert ref_model.get_parameter(layer_1).data_ptr() != self.model.get_parameter(layer_1).data_ptr()

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_nash_md_trainer.py

@@ -0,0 +1,195 @@
+# 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 pytest
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification, AutoTokenizer, GenerationConfig
+from transformers.utils import is_peft_available
+
+from trl.experimental.nash_md import NashMDConfig, NashMDTrainer
+from trl.experimental.nash_md.nash_md_trainer import GeometricMixtureWrapper
+from trl.experimental.utils import create_reference_model
+
+from ..testing_utils import TrlTestCase, require_peft
+
+
+if is_peft_available():
+    from peft import LoraConfig, get_peft_model
+
+
+class TestGeometricMixtureWrapper(TrlTestCase):
+    def setup_method(self):
+        model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32").to(self.device)
+        self.ref_model = create_reference_model(self.model).to(self.device)
+        self.generation_config = GenerationConfig.from_pretrained(model_id)
+        self.mixture_coef = 0.5
+        self.wrapper = GeometricMixtureWrapper(
+            self.model, self.ref_model, self.generation_config, mixture_coef=self.mixture_coef
+        )
+
+    def test_forward(self):
+        input_ids = torch.tensor([[1, 2, 3, 4, 5]], device=self.device)
+        attention_mask = torch.ones_like(input_ids)
+
+        output = self.wrapper(input_ids=input_ids, attention_mask=attention_mask)
+
+        assert output is not None
+        assert hasattr(output, "logits")
+        assert output.logits.shape == (1, 5, self.model.config.vocab_size)
+
+    def test_mixture_coefficient(self):
+        input_ids = torch.tensor([[1, 2, 3, 4, 5]], device=self.device)
+        attention_mask = torch.ones_like(input_ids)
+
+        with torch.no_grad():
+            model_output = self.model(input_ids=input_ids, attention_mask=attention_mask)
+            ref_model_output = self.ref_model(input_ids=input_ids, attention_mask=attention_mask)
+            wrapper_output = self.wrapper(input_ids=input_ids, attention_mask=attention_mask)
+
+        expected_logits = torch.nn.functional.log_softmax(
+            self.mixture_coef * ref_model_output.logits + (1 - self.mixture_coef) * model_output.logits, dim=-1
+        )
+
+        torch.testing.assert_close(wrapper_output.logits, expected_logits)
+
+    def test_prepare_inputs_for_generation(self):
+        input_ids = torch.tensor([[1, 2, 3, 4, 5]], device=self.device)
+        attention_mask = torch.ones_like(input_ids)
+
+        inputs = self.wrapper.prepare_inputs_for_generation(input_ids, attention_mask=attention_mask, use_cache=True)
+
+        assert "input_ids" in inputs
+        assert "attention_mask" in inputs
+        assert not inputs.get("use_cache", False)
+
+
+class TestNashMDTrainer(TrlTestCase):
+    def setup_method(self):
+        self.model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        self.model = AutoModelForCausalLM.from_pretrained(self.model_id, dtype="float32")
+        self.ref_model = AutoModelForCausalLM.from_pretrained(self.model_id)
+        self.reward_model = AutoModelForSequenceClassification.from_pretrained(self.model_id, num_labels=1)
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+        self.tokenizer.pad_token = self.tokenizer.eos_token
+
+    @pytest.mark.parametrize("config_name", ["standard_prompt_only", "conversational_prompt_only"])
+    def test_nash_md_trainer_training(self, config_name):
+        training_args = NashMDConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            remove_unused_columns=False,
+            gradient_accumulation_steps=1,
+            learning_rate=9e-1,
+            report_to="none",
+        )
+        dataset = load_dataset("trl-internal-testing/zen", config_name, split="train")
+
+        trainer = NashMDTrainer(
+            model=self.model,
+            ref_model=self.ref_model,
+            reward_funcs=self.reward_model,
+            args=training_args,
+            processing_class=self.tokenizer,
+            train_dataset=dataset,
+        )
+
+        trainer.train()
+
+        assert "train_loss" in trainer.state.log_history[-1]
+
+    @require_peft
+    def test_train_with_peft(self):
+        lora_config = LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM")
+        training_args = NashMDConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            learning_rate=5.0e-7,
+            report_to="none",
+        )
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        trainer = NashMDTrainer(
+            model=self.model,
+            reward_funcs=self.reward_model,
+            args=training_args,
+            processing_class=self.tokenizer,
+            train_dataset=dataset,
+            peft_config=lora_config,
+        )
+
+        trainer.train()
+
+        assert "train_loss" in trainer.state.log_history[-1]
+
+    @require_peft
+    def test_train_with_peft_and_ref_model(self):
+        lora_config = LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM")
+        training_args = NashMDConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            learning_rate=5.0e-7,
+            report_to="none",
+        )
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        trainer = NashMDTrainer(
+            model=self.model,
+            ref_model=self.ref_model,
+            reward_funcs=self.reward_model,
+            args=training_args,
+            processing_class=self.tokenizer,
+            train_dataset=dataset,
+            peft_config=lora_config,
+        )
+
+        trainer.train()
+
+        assert "train_loss" in trainer.state.log_history[-1]
+
+    @require_peft
+    def test_train_pre_pefted_model_implicit_ref_with_reward_model(self):
+        lora_config = LoraConfig(r=8, lora_alpha=16, lora_dropout=0.1, bias="none", task_type="CAUSAL_LM")
+        # self.model from setUp is a base AutoModelForCausalLM
+        peft_model_instance = get_peft_model(self.model, lora_config)
+
+        training_args = NashMDConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=1,  # Keep small for quick test
+            max_steps=2,  # Few steps
+            learning_rate=5.0e-7,
+            eval_strategy="no",
+            report_to="none",
+            remove_unused_columns=False,  # Important for the dummy dataset
+        )
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        trainer = NashMDTrainer(
+            model=peft_model_instance,  # Pass the already PEFT model
+            ref_model=None,  # Implicit reference from peft_model_instance's base
+            reward_funcs=self.reward_model,  # To trigger GeometricMixtureWrapper path
+            args=training_args,
+            processing_class=self.tokenizer,
+            train_dataset=dataset,
+            # peft_config is not passed, as model is already PEFT
+        )
+
+        trainer.train()
+
+        assert "train_loss" in trainer.state.log_history[-1]

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_online_dpo_trainer.py

@@ -0,0 +1,461 @@
+# 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 pytest
+from datasets import Dataset, features, load_dataset
+from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification, AutoTokenizer
+from transformers.utils import is_peft_available, is_vision_available
+
+from trl.experimental.online_dpo import OnlineDPOConfig, OnlineDPOTrainer
+
+from ..testing_utils import TrlTestCase, require_peft, require_torch_accelerator, require_vision, require_vllm
+
+
+if is_peft_available():
+    from peft import LoraConfig
+
+if is_vision_available():
+    import numpy as np
+    from PIL import Image
+    from transformers import AutoModelForImageTextToText, AutoProcessor
+
+
+class TestOnlineDPOTrainer(TrlTestCase):
+    def setup_method(self):
+        self.model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        self.model = AutoModelForCausalLM.from_pretrained(self.model_id, dtype="float32")
+        self.ref_model = AutoModelForCausalLM.from_pretrained(self.model_id)
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+        self.tokenizer.pad_token = self.tokenizer.eos_token
+
+        self.reward_model_id = "trl-internal-testing/tiny-LlamaForCausalLM-3.2"
+        self.reward_model = AutoModelForSequenceClassification.from_pretrained(self.reward_model_id, num_labels=1)
+        self.reward_tokenizer = AutoTokenizer.from_pretrained(self.reward_model_id)
+        self.reward_tokenizer.pad_token = self.reward_tokenizer.eos_token
+
+    def test_trust_remote_code(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+        model_id = "trl-internal-testing/tiny-RemoteForCausalLM"
+        tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
+
+        with pytest.raises(ValueError, match="custom code"):
+            OnlineDPOTrainer(
+                model=model_id,
+                reward_funcs=self.reward_model,
+                args=OnlineDPOConfig(output_dir=self.tmp_dir, report_to="none"),
+                train_dataset=dataset,
+                processing_class=tokenizer,
+                reward_processing_classes=self.reward_tokenizer,
+            )
+
+        trainer = OnlineDPOTrainer(
+            model=model_id,
+            reward_funcs=self.reward_model,
+            args=OnlineDPOConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True),
+            train_dataset=dataset,
+            processing_class=tokenizer,
+            reward_processing_classes=self.reward_tokenizer,
+        )
+        assert type(trainer.model).__name__ == "RemoteForCausalLM"
+
+    @pytest.mark.parametrize("config_name", ["standard_prompt_only", "conversational_prompt_only"])
+    def test_train(self, config_name):
+        training_args = OnlineDPOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            learning_rate=5.0e-7,
+            report_to="none",
+        )
+        dataset = load_dataset("trl-internal-testing/zen", config_name, split="train")
+
+        trainer = OnlineDPOTrainer(
+            model=self.model,
+            reward_funcs=self.reward_model,
+            args=training_args,
+            train_dataset=dataset,
+            processing_class=self.tokenizer,
+            reward_processing_classes=self.reward_tokenizer,
+        )
+        trainer.train()
+
+        assert "train_loss" in trainer.state.log_history[-1]
+
+    def test_train_model_str(self):
+        training_args = OnlineDPOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            learning_rate=5.0e-7,
+            report_to="none",
+        )
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        trainer = OnlineDPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=self.reward_model,
+            args=training_args,
+            train_dataset=dataset,
+            processing_class=self.tokenizer,
+            reward_processing_classes=self.reward_tokenizer,
+        )
+        trainer.train()
+
+        assert "train_loss" in trainer.state.log_history[-1]
+
+    def test_train_with_ref_model(self):
+        training_args = OnlineDPOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            learning_rate=5.0e-7,
+            report_to="none",
+        )
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        trainer = OnlineDPOTrainer(
+            model=self.model,
+            ref_model=self.ref_model,
+            reward_funcs=self.reward_model,
+            args=training_args,
+            train_dataset=dataset,
+            processing_class=self.tokenizer,
+            reward_processing_classes=self.reward_tokenizer,
+        )
+        trainer.train()
+
+        assert "train_loss" in trainer.state.log_history[-1]
+
+    def test_ref_model_is_model(self):
+        training_args = OnlineDPOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            report_to="none",
+        )
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        with pytest.raises(ValueError):
+            OnlineDPOTrainer(
+                model=self.model,
+                ref_model=self.model,  # ref_model can't be the same as model
+                reward_funcs=self.reward_model,
+                args=training_args,
+                train_dataset=dataset,
+                processing_class=self.tokenizer,
+                reward_processing_classes=self.reward_tokenizer,
+            )
+
+    @require_peft
+    def test_train_with_peft(self):
+        lora_config = LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM")
+        training_args = OnlineDPOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            learning_rate=5.0e-7,
+            report_to="none",
+        )
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        trainer = OnlineDPOTrainer(
+            model=self.model,
+            reward_funcs=self.reward_model,
+            args=training_args,
+            train_dataset=dataset,
+            processing_class=self.tokenizer,
+            reward_processing_classes=self.reward_tokenizer,
+            peft_config=lora_config,
+        )
+
+        trainer.train()
+
+        assert "train_loss" in trainer.state.log_history[-1]
+
+    @require_peft
+    def test_train_with_peft_and_ref_model(self):
+        lora_config = LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM")
+        training_args = OnlineDPOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            learning_rate=5.0e-7,
+            report_to="none",
+        )
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        trainer = OnlineDPOTrainer(
+            model=self.model,
+            ref_model=self.ref_model,
+            reward_funcs=self.reward_model,
+            args=training_args,
+            train_dataset=dataset,
+            processing_class=self.tokenizer,
+            reward_processing_classes=self.reward_tokenizer,
+            peft_config=lora_config,
+        )
+
+        trainer.train()
+
+        assert "train_loss" in trainer.state.log_history[-1]
+
+    @pytest.mark.parametrize("config_name", ["standard_prompt_only", "conversational_prompt_only"])
+    @require_torch_accelerator
+    @require_vllm
+    @pytest.mark.slow
+    def test_train_with_vllm_server(self, config_name):
+        def cleanup_vllm_communicator(trainer):
+            """Clean up vLLM communicator to avoid conflicts between test runs"""
+            try:
+                if hasattr(trainer, "vllm_client") and trainer.vllm_client is not None:
+                    trainer.vllm_client.close_communicator()
+            except Exception:
+                pass  # Continue if cleanup fails
+
+        model_id = "trl-internal-testing/small-Qwen2ForCausalLM-2.5"  # We need a bigger model
+        model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        tokenizer.pad_token = tokenizer.eos_token
+
+        training_args = OnlineDPOConfig(
+            output_dir=self.tmp_dir,
+            use_vllm=True,
+            vllm_mode="server",
+            vllm_gpu_memory_utilization=0.2,
+            report_to="none",
+        )
+        dataset = load_dataset("trl-internal-testing/zen", config_name, split="train")
+
+        trainer = OnlineDPOTrainer(
+            model=model,
+            reward_funcs=self.reward_model,
+            args=training_args,
+            train_dataset=dataset,
+            processing_class=tokenizer,
+            reward_processing_classes=self.reward_tokenizer,
+        )
+
+        # Ensure cleanup of vLLM communicator after the test
+        try:
+            trainer.train()
+            # Check if training loss is available
+            assert "train_loss" in trainer.state.log_history[-1]
+        finally:
+            cleanup_vllm_communicator(trainer)
+
+    @require_vllm
+    def test_train_with_vllm_colocate(self):
+        """Test vLLM colocate mode with our refactored implementation"""
+        model_id = "trl-internal-testing/small-Qwen2ForCausalLM-2.5"  # We need a bigger model
+        model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        tokenizer.pad_token = tokenizer.eos_token
+
+        training_args = OnlineDPOConfig(
+            output_dir=self.tmp_dir,
+            use_vllm=True,
+            vllm_mode="colocate",
+            vllm_gpu_memory_utilization=0.2,
+            per_device_train_batch_size=1,
+            max_steps=2,
+            report_to="none",
+            # Test generation parameters
+            temperature=0.9,
+            top_p=0.95,
+            top_k=50,
+            repetition_penalty=1.1,
+            max_new_tokens=32,
+        )
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        trainer = OnlineDPOTrainer(
+            model=model,
+            reward_funcs=self.reward_model,
+            args=training_args,
+            train_dataset=dataset,
+            processing_class=tokenizer,
+            reward_processing_classes=self.reward_tokenizer,
+        )
+
+        # Verify vLLM setup
+        assert trainer.use_vllm
+        assert trainer.vllm_mode == "colocate"
+        assert trainer.llm is not None
+        # self.assertIsNone(trainer.vllm_client)
+        # self.assertEqual(trainer.vllm_gpu_memory_utilization, 0.2)
+
+        # Verify generation parameters
+        assert trainer.temperature == 0.9
+        assert trainer.top_p == 0.95
+        assert trainer.top_k == 50
+        assert trainer.repetition_penalty == 1.1
+
+        # Verify generation config
+        assert trainer.generation_config is not None
+        assert trainer.generation_config.temperature == 0.9
+        assert trainer.generation_config.top_p == 0.95
+        assert trainer.generation_config.top_k == 50
+        assert trainer.generation_config.repetition_penalty == 1.1
+        assert trainer.generation_config.max_tokens == 32
+
+        trainer.train()
+
+        assert "train_loss" in trainer.state.log_history[-1]
+
+    def test_vllm_config_validation(self):
+        """Test vLLM configuration validation"""
+        # Test valid vllm_mode values
+        config = OnlineDPOConfig(use_vllm=True, vllm_mode="server")
+        assert config.vllm_mode == "server"
+
+        config = OnlineDPOConfig(use_vllm=True, vllm_mode="colocate")
+        assert config.vllm_mode == "colocate"
+
+        # Test default values
+        config = OnlineDPOConfig()
+        assert config.vllm_mode == "colocate"
+        assert config.vllm_server_base_url is None
+        assert config.vllm_server_host == "0.0.0.0"
+        assert config.vllm_server_port == 8000
+        assert config.vllm_server_timeout == 240.0
+        assert config.vllm_gpu_memory_utilization == 0.55
+
+        # Test generation parameters
+        assert config.top_p == 1.0
+        assert config.top_k == 0
+        assert config.min_p is None
+        assert config.repetition_penalty == 1.0
+        assert config.cache_implementation is None
+        assert config.generation_kwargs is None
+
+    def test_generation_config_setup(self):
+        """Test that generation configuration is properly set up for both vLLM and transformers"""
+        training_args = OnlineDPOConfig(
+            output_dir=self.tmp_dir,
+            use_vllm=False,
+            temperature=0.8,
+            top_p=0.9,
+            top_k=40,
+            repetition_penalty=1.2,
+            max_new_tokens=64,
+            generation_kwargs={"do_sample": False},
+            report_to="none",
+        )
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        trainer = OnlineDPOTrainer(
+            model=self.model,
+            reward_funcs=self.reward_model,
+            args=training_args,
+            train_dataset=dataset,
+            processing_class=self.tokenizer,
+            reward_processing_classes=self.reward_tokenizer,
+        )
+
+        # Verify transformers generation config
+        assert not trainer.use_vllm
+        # When not using vLLM, these attributes should not be set
+        assert not (hasattr(trainer, "llm") and trainer.llm is not None)
+        assert not (hasattr(trainer, "vllm_client") and trainer.vllm_client is not None)
+        assert trainer.generation_config is not None
+        assert trainer.generation_config.temperature == 0.8
+        assert trainer.generation_config.top_p == 0.9
+        assert trainer.generation_config.top_k == 40
+        assert trainer.generation_config.repetition_penalty == 1.2
+        assert trainer.generation_config.max_new_tokens == 64
+        assert not trainer.generation_config.do_sample  # From generation_kwargs
+
+    @pytest.mark.parametrize("config_name", ["standard_prompt_only", "conversational_prompt_only"])
+    def test_train_with_reward_funcs(self, config_name):
+        def simple_reward_func(prompts, completions, completion_ids, **kwargs):
+            return [0.5 for _ in prompts]
+
+        training_args = OnlineDPOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            learning_rate=5.0e-7,
+            reward_weights=[0.7, 0.3],
+            report_to="none",
+        )
+        dataset = load_dataset("trl-internal-testing/zen", config_name, split="train")
+
+        trainer = OnlineDPOTrainer(
+            model=self.model,
+            reward_funcs=[simple_reward_func, simple_reward_func],
+            args=training_args,
+            train_dataset=dataset,
+            processing_class=self.tokenizer,
+        )
+        trainer.train()
+
+        assert "train_loss" in trainer.state.log_history[-1]
+        assert len(trainer.reward_funcs) == 2
+        assert trainer.reward_weights is not None
+        assert round(abs(trainer.reward_weights[0].item() - 0.7), 5) == 0
+        assert round(abs(trainer.reward_weights[1].item() - 0.3), 5) == 0
+
+
+@require_vision
+class TestOnlineDPOVisionTrainer(TrlTestCase):
+    @pytest.mark.parametrize(
+        "model_id",
+        [
+            "trl-internal-testing/tiny-Idefics2ForConditionalGeneration",
+            "trl-internal-testing/tiny-LlavaForConditionalGeneration",
+        ],
+    )
+    def test_online_dpo_vlm_trainer(self, model_id):
+        dataset_dict = {
+            "prompt": [
+                [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "Describe the image."}]}],
+                [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What do you see?"}]}],
+            ],
+            "images": [
+                [Image.fromarray(np.random.randint(0, 255, (64, 64, 3), dtype=np.uint8))],
+                [Image.fromarray(np.random.randint(0, 255, (64, 64, 3), dtype=np.uint8))],
+            ],
+        }
+        dataset = Dataset.from_dict(dataset_dict)
+        dataset = dataset.cast_column("images", features.Sequence(features.Image()))
+
+        model = AutoModelForImageTextToText.from_pretrained(model_id, dtype="float32")
+        reward_model = AutoModelForSequenceClassification.from_pretrained(
+            "trl-internal-testing/tiny-LlamaForCausalLM-3.2", num_labels=1
+        )
+        processor = AutoProcessor.from_pretrained(model_id)
+        reward_tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-LlamaForCausalLM-3.2")
+        reward_tokenizer.pad_token = reward_tokenizer.eos_token
+
+        training_args = OnlineDPOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=1,
+            max_steps=2,
+            learning_rate=0.01,
+            report_to="none",
+        )
+        trainer = OnlineDPOTrainer(
+            model=model,
+            reward_funcs=reward_model,
+            args=training_args,
+            processing_class=processor,
+            train_dataset=dataset,
+            eval_dataset=dataset,
+            reward_processing_classes=reward_tokenizer,
+        )
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_openreward.py

@@ -0,0 +1,252 @@
+# 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.
+
+"""Tests for `trl.experimental.openreward`.
+
+A class-scoped fixture spawns ``_openreward_echo_env.py`` as a uvicorn subprocess on a free port and points the
+openreward SDK at it via the ``OPENREWARD_API_URL`` / ``OPENREWARD_SESSION_URL`` overrides. Tests then exercise the
+adapter end-to-end against real HTTP — no mocks, no network.
+
+The same env definition is published at ``trl-internal-testing/openreward-echo-env`` if you want to point at the hosted
+Space directly.
+"""
+
+import os
+import socket
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import pytest
+import requests
+
+from trl.experimental.openreward import OpenRewardSpec
+
+from ..testing_utils import TrlTestCase, require_openreward
+
+
+_HERE = Path(__file__).parent
+_ECHO_ENV_SCRIPT = _HERE / "_openreward_echo_env.py"
+
+
+def _free_port() -> int:
+    with socket.socket() as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+@pytest.fixture(scope="class")
+def echo_env_url():
+    """Spawn the echo env on a free port; tear down on teardown."""
+    port = _free_port()
+    proc = subprocess.Popen(
+        [sys.executable, str(_ECHO_ENV_SCRIPT)],
+        env={**os.environ, "PORT": str(port)},
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+    url = f"http://127.0.0.1:{port}"
+    deadline = time.time() + 30.0
+    while time.time() < deadline:
+        try:
+            r = requests.get(f"{url}/health", timeout=1.0)
+            if r.status_code == 200:
+                break
+        except requests.RequestException:
+            pass
+        time.sleep(0.2)
+    else:
+        proc.terminate()
+        raise RuntimeError(f"echo env did not become ready at {url}")
+
+    # The openreward SDK by default rewrites base_url into api.<host> /
+    # sessions.<host>; for a single-host self-hosted server these env vars
+    # bypass that two-subdomain layout.
+    saved = {k: os.environ.get(k) for k in ("OPENREWARD_API_URL", "OPENREWARD_SESSION_URL", "OPENREWARD_API_KEY")}
+    os.environ["OPENREWARD_API_URL"] = url
+    os.environ["OPENREWARD_SESSION_URL"] = url
+    os.environ.setdefault("OPENREWARD_API_KEY", "test")
+
+    yield url
+
+    for k, v in saved.items():
+        if v is None:
+            os.environ.pop(k, None)
+        else:
+            os.environ[k] = v
+    proc.terminate()
+    try:
+        proc.wait(timeout=5.0)
+    except subprocess.TimeoutExpired:
+        proc.kill()
+
+
+@require_openreward
+@pytest.mark.usefixtures("echo_env_url")
+class TestOpenRewardSpec(TrlTestCase):
+    """Exercises the public `OpenRewardSpec` surface against a real ORS server."""
+
+    def test_construction_is_lazy(self, echo_env_url):
+        # Construction must not perform any HTTP — `train_dataset` /
+        # `environment_factory` are `cached_property` and only fire on access.
+        spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=2)
+        # Touching only private attributes should not have hit the network.
+        assert spec._target == echo_env_url
+        assert spec._is_url is True
+        assert spec._num_tasks == 2
+
+    def test_train_dataset_derives_from_env(self, echo_env_url):
+        spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=2)
+        ds = spec.train_dataset
+        assert len(ds) == 2
+        assert "prompt" in ds.column_names
+        assert "task_index" in ds.column_names
+        # Per-task metadata folded in (id, target) when include_metadata=True.
+        assert "target" in ds.column_names
+        assert ds[0]["task_index"] == 0
+        assert ds[0]["target"] == "hello"
+        assert ds[1]["target"] == "world"
+
+    def test_train_dataset_with_indices(self, echo_env_url):
+        spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", indices=[0, 2])
+        ds = spec.train_dataset
+        assert [row["target"] for row in ds] == ["hello", "trl"]
+
+    def test_num_tasks_and_indices_are_mutually_exclusive(self, echo_env_url):
+        with pytest.raises(ValueError):
+            OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=2, indices=[0])
+
+    def test_environment_factory_returns_rollout_env_with_bound_tools(self, echo_env_url):
+        spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=2)
+        env = spec.environment_factory()
+        # Shared + task-scoped ORS tools (ORS /tools vs /task_tools) are both bound for GRPO.
+        assert callable(env.echo)
+        sig = env.echo.__annotations__
+        assert sig["text"] is str
+        assert sig["return"] is str
+        assert callable(env.hint)
+
+    def test_discover_task_tools_false_skips_task_scoped_binding(self, echo_env_url):
+        spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=1, discover_task_tools=False)
+        env = spec.environment_factory()
+        assert callable(env.echo)
+        assert not hasattr(env, "hint")
+
+    def test_reset_returns_prompt_and_opens_session(self, echo_env_url):
+        spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=1)
+        env = spec.environment_factory()
+        prompt = env.reset(**spec.train_dataset[0])
+        assert "echo" in prompt and "hello" in prompt
+        env._close()
+
+    def test_correct_echo_returns_match_with_reward_and_finished(self, echo_env_url):
+        spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=1)
+        env = spec.environment_factory()
+        env.reset(**spec.train_dataset[0])
+        out = env.echo(text="hello")
+        assert "match" in out
+        assert env.reward == 1.0
+        assert env.finished is True
+        env._close()
+
+    def test_wrong_echo_returns_no_match_with_zero_reward(self, echo_env_url):
+        spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=1)
+        env = spec.environment_factory()
+        env.reset(**spec.train_dataset[0])
+        out = env.echo(text="goodbye")
+        assert "no match" in out
+        assert env.reward == 0.0
+        assert env.finished is False
+        env._close()
+
+    def test_reward_func_reads_last_non_null_per_environment(self, echo_env_url):
+        spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=2)
+        env_a = spec.environment_factory()
+        env_b = spec.environment_factory()
+        env_a.reset(**spec.train_dataset[0])
+        env_b.reset(**spec.train_dataset[1])
+        env_a.echo(text="hello")  # match → reward=1.0
+        env_b.echo(text="oops")  # no match → reward=0.0
+        rewards = spec.reward_funcs(environments=[env_a, env_b])
+        assert rewards == [1.0, 0.0]
+        env_a._close()
+        env_b._close()
+
+    def test_factory_produces_isolated_sessions(self, echo_env_url):
+        # GRPO opens N concurrent envs; mutating one must not leak into another.
+        spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=2)
+        env_a = spec.environment_factory()
+        env_b = spec.environment_factory()
+        env_a.reset(**spec.train_dataset[0])
+        env_b.reset(**spec.train_dataset[1])
+        env_a.echo(text="hello")
+        assert env_a.reward == 1.0
+        assert env_b.reward == 0.0  # untouched
+        env_a._close()
+        env_b._close()
+
+    def test_metadata_does_not_overwrite_reserved_columns(self, echo_env_url):
+        # If a task spec ever shipped a `prompt` key, the metadata loop must
+        # not clobber our chat-format `prompt` column. Same for `task_index`.
+        # We assert the shape directly — the echo env's task spec doesn't
+        # currently have either, but the guard is what we're testing.
+        spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=1)
+        ds = spec.train_dataset
+        # `prompt` is a list-of-message-dicts, not a string from task spec.
+        assert isinstance(ds[0]["prompt"], list)
+        assert ds[0]["prompt"][0]["role"] == "user"
+        # `task_index` is the int we set, not anything from the spec.
+        assert isinstance(ds[0]["task_index"], int)
+
+    def test_task_tools_discovery_index_probes_single_task(self, echo_env_url):
+        # task_tools_discovery_index=0 tells the spec to probe only task 0 for
+        # tool discovery (ORS /task_tools), regardless of how many tasks are in
+        # the dataset. This is the Toolathlon pattern: all tasks expose the same
+        # meta-tools, so probing one is sufficient and avoids N sessions.
+        spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=4, task_tools_discovery_index=0)
+        env = spec.environment_factory()
+        # Shared tool (echo) and task-specific tool (hint) are both bound.
+        assert callable(env.echo)
+        assert callable(env.hint)
+        # Dataset still has 4 tasks even though discovery only probed index 0.
+        assert len(spec.train_dataset) == 4
+        env._close()
+
+    def test_task_tools_discovery_index_with_indices(self, echo_env_url):
+        # When indices= is set AND task_tools_discovery_index is set, discovery
+        # uses only the explicit discovery index (not all indices for probing).
+        spec = OpenRewardSpec(
+            echo_env_url, env_name="echoenvironment", indices=[0, 1, 2, 3], task_tools_discovery_index=2
+        )
+        env = spec.environment_factory()
+        # Task tools are still discovered (via index 2).
+        assert callable(env.hint)
+        assert len(spec.train_dataset) == 4
+        env._close()
+
+    def test_two_specs_get_isolated_rollout_subclasses(self, echo_env_url):
+        # Two specs (potentially against different envs with different tool
+        # sets) must each produce rollout instances with their own subclass,
+        # so neither side's bound tools clobber or shadow the other's.
+        spec_a = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=1)
+        spec_b = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=1)
+        env_a = spec_a.environment_factory()
+        env_b = spec_b.environment_factory()
+        # Each rollout is a distinct subclass of _RolloutEnvironment.
+        assert type(env_a) is not type(env_b)
+        # Both subclasses still get their own `echo` method.
+        assert callable(env_a.echo) and callable(env_b.echo)
+        env_a._close()
+        env_b._close()

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_orpo_trainer.py

@@ -0,0 +1,198 @@
+# 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 pytest
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoModelForSeq2SeqLM, AutoTokenizer
+
+from trl.experimental.orpo import ORPOConfig, ORPOTrainer
+
+from ..testing_utils import TrlTestCase, require_peft
+
+
+class TestORPOTrainer(TrlTestCase):
+    def setup_method(self):
+        self.model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        self.model = AutoModelForCausalLM.from_pretrained(self.model_id, dtype="float32")
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+        self.tokenizer.pad_token = self.tokenizer.eos_token
+
+        # get t5 as seq2seq example:
+        model_id = "trl-internal-testing/tiny-T5ForConditionalGeneration"
+        self.t5_model = AutoModelForSeq2SeqLM.from_pretrained(model_id, dtype="float32")
+        self.t5_tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+    def test_trust_remote_code(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+        model_id = "trl-internal-testing/tiny-RemoteForCausalLM"
+        tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
+
+        with pytest.raises(ValueError, match="custom code"):
+            ORPOTrainer(
+                model=model_id,
+                args=ORPOConfig(output_dir=self.tmp_dir, report_to="none"),
+                processing_class=tokenizer,
+                train_dataset=dataset,
+            )
+
+        trainer = ORPOTrainer(
+            model=model_id,
+            args=ORPOConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True),
+            processing_class=tokenizer,
+            train_dataset=dataset,
+        )
+        assert type(trainer.model).__name__ == "RemoteForCausalLM"
+
+    @pytest.mark.parametrize(
+        "name, config_name",
+        [
+            ("qwen", "standard_preference"),
+            ("t5", "standard_implicit_prompt_preference"),
+            ("qwen", "conversational_preference"),
+        ],
+    )
+    def test_orpo_trainer(self, name, config_name):
+        training_args = ORPOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            remove_unused_columns=False,
+            gradient_accumulation_steps=1,
+            learning_rate=9e-1,
+            eval_strategy="steps",
+            beta=0.1,
+            report_to="none",
+        )
+
+        dataset = load_dataset("trl-internal-testing/zen", config_name)
+
+        if name == "qwen":
+            model = self.model
+            tokenizer = self.tokenizer
+        elif name == "t5":
+            model = self.t5_model
+            tokenizer = self.t5_tokenizer
+            training_args.is_encoder_decoder = True
+
+        trainer = ORPOTrainer(
+            model=model,
+            args=training_args,
+            processing_class=tokenizer,
+            train_dataset=dataset["train"],
+            eval_dataset=dataset["test"],
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if param.sum() != 0:  # ignore 0 biases
+                assert not torch.equal(param, new_param)
+
+    @pytest.mark.parametrize(
+        "config_name",
+        [
+            "standard_preference",
+            "standard_implicit_prompt_preference",
+            "conversational_preference",
+            "conversational_implicit_prompt_preference",
+        ],
+    )
+    @require_peft
+    def test_orpo_trainer_with_lora(self, config_name):
+        from peft import LoraConfig
+
+        lora_config = LoraConfig(
+            r=16,
+            lora_alpha=32,
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        training_args = ORPOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            remove_unused_columns=False,
+            gradient_accumulation_steps=4,
+            learning_rate=9e-1,
+            eval_strategy="steps",
+            beta=0.1,
+            report_to="none",
+        )
+
+        dataset = load_dataset("trl-internal-testing/zen", config_name)
+
+        trainer = ORPOTrainer(
+            model=self.model,
+            args=training_args,
+            processing_class=self.tokenizer,
+            train_dataset=dataset["train"],
+            eval_dataset=dataset["test"],
+            peft_config=lora_config,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            if "lora" in n:
+                new_param = trainer.model.get_parameter(n)
+                if param.sum() != 0:  # ignore 0 biases
+                    assert not torch.equal(param, new_param)
+
+    def test_compute_metrics(self):
+        model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32")
+        tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5")
+        tokenizer.pad_token = tokenizer.eos_token
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference")
+
+        def dummy_compute_metrics(*args, **kwargs):
+            return {"test": 0.0}
+
+        training_args = ORPOConfig(
+            output_dir=self.tmp_dir,
+            remove_unused_columns=False,
+            per_device_train_batch_size=2,
+            do_eval=True,
+            eval_strategy="steps",
+            eval_steps=1,
+            per_device_eval_batch_size=2,
+            report_to="none",
+        )
+
+        trainer = ORPOTrainer(
+            model=model,
+            args=training_args,
+            processing_class=tokenizer,
+            train_dataset=dataset["train"],
+            eval_dataset=dataset["test"],
+            compute_metrics=dummy_compute_metrics,
+        )
+
+        trainer.train()
+
+        assert trainer.state.log_history[-2]["eval_test"] == 0.0

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_ppo_trainer.py

@@ -0,0 +1,829 @@
+# 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 os
+
+import pytest
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoModelForSeq2SeqLM,
+    AutoModelForSequenceClassification,
+    AutoTokenizer,
+    GenerationConfig,
+)
+from transformers.utils import is_peft_available
+
+from trl.experimental.ppo import (
+    AutoModelForCausalLMWithValueHead,
+    AutoModelForSeq2SeqLMWithValueHead,
+    PPOConfig,
+    PPOTrainer,
+)
+from trl.experimental.ppo.ppo_trainer import batch_generation, masked_mean, masked_var, masked_whiten
+
+from ..testing_utils import (
+    TrlTestCase,
+    require_bitsandbytes,
+    require_peft,
+    require_torch_gpu_if_bnb_not_multi_backend_enabled,
+)
+
+
+if is_peft_available():
+    from peft import LoraConfig, get_peft_model
+
+
+ALL_CAUSAL_LM_MODELS = [
+    "trl-internal-testing/tiny-BloomForCausalLM",
+    "trl-internal-testing/tiny-CohereForCausalLM",
+    # "trl-internal-testing/tiny-FalconMambaForCausalLM",  # FalconMambaForCausalLM modeling seems to be broken for now
+    "trl-internal-testing/tiny-Gemma2ForCausalLM",
+    "trl-internal-testing/tiny-GemmaForCausalLM",
+    "trl-internal-testing/tiny-GPT2LMHeadModel",
+    "trl-internal-testing/tiny-GPTNeoXForCausalLM",
+    "trl-internal-testing/tiny-LlamaForCausalLM-3.1",
+    "trl-internal-testing/tiny-LlamaForCausalLM-3.2",
+    "trl-internal-testing/tiny-LlamaForCausalLM-3",
+    "trl-internal-testing/tiny-MistralForCausalLM-0.1",
+    "trl-internal-testing/tiny-MistralForCausalLM-0.2",
+    "trl-internal-testing/tiny-OPTForCausalLM",
+    "trl-internal-testing/tiny-Phi3ForCausalLM-3",
+    "trl-internal-testing/tiny-Phi3ForCausalLM-3.5",
+    "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+]
+
+ALL_SEQ2SEQ_MODELS = [
+    "trl-internal-testing/tiny-T5ForConditionalGeneration",
+    "trl-internal-testing/tiny-BartModel",
+]
+
+
+class TestBatchGeneration(TrlTestCase):
+    def setup_method(self):
+        # Initialize the tokenizer
+        self.model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model = AutoModelForCausalLM.from_pretrained(self.model_id, dtype="float32").to(self.device)
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+
+        self.generation_config = GenerationConfig(
+            max_new_tokens=128,
+            temperature=0.5,
+            do_sample=True,
+            top_k=0,
+            pad_token_id=self.tokenizer.pad_token_id,
+        )
+
+        # Example input
+        dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling", split="train")
+        self.examples = dataset["messages"]
+        self.mini_batch_size = 3
+
+    def test_mini_batch_generation(self):
+        batch = [
+            self.tokenizer.apply_chat_template(example[:-1], add_generation_prompt=True, tokenize=False)
+            for example in self.examples
+        ]
+        queries = self.tokenizer(batch, padding=True, return_tensors="pt")["input_ids"].to(self.device)
+        bs, context_length = queries.shape
+
+        query_responses, logits = batch_generation(
+            self.model, queries, self.mini_batch_size, self.tokenizer.pad_token_id, self.generation_config
+        )
+
+        max_length_query = query_responses.shape[1]
+        max_length_logits = max_length_query - context_length
+
+        assert max_length_query > context_length
+        assert query_responses.shape == (bs, max_length_query)
+        assert logits.shape == (bs, max_length_logits, self.model.config.vocab_size)
+
+    def test_single_batch_generation(self):
+        batch = [
+            self.tokenizer.apply_chat_template(example[:-1], add_generation_prompt=True, tokenize=False)
+            for example in self.examples
+        ]
+        queries = self.tokenizer(batch, padding=True, return_tensors="pt")["input_ids"].to(self.device)
+        bs, context_length = queries.shape
+
+        query_responses, logits = batch_generation(
+            self.model, queries, bs, self.tokenizer.pad_token_id, self.generation_config
+        )
+
+        max_length_query = query_responses.shape[1]
+        max_length_logits = max_length_query - context_length
+
+        assert max_length_query > context_length
+        assert query_responses.shape == (bs, max_length_query)
+        assert logits.shape == (bs, max_length_logits, self.model.config.vocab_size)
+
+
+class BaseTester:
+    class VHeadModelTester(TrlTestCase):
+        all_model_names = None
+        trl_model_class = None
+        transformers_model_class = None
+
+        def setup_method(self):
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        def test_value_head(self):
+            r"""
+            Test if the v-head is added to the model successfully
+            """
+            for model_name in self.all_model_names:
+                model = self.trl_model_class.from_pretrained(model_name)
+                assert hasattr(model, "v_head")
+
+        def test_value_head_shape(self):
+            r"""
+            Test if the v-head has the correct shape
+            """
+            for model_name in self.all_model_names:
+                model = self.trl_model_class.from_pretrained(model_name)
+                assert model.v_head.summary.weight.shape[0] == 1
+
+        def test_value_head_init_random(self):
+            r"""
+            Test if the v-head has been randomly initialized. We can check that by making sure the bias is different
+            than zeros by default.
+            """
+            for model_name in self.all_model_names:
+                model = self.trl_model_class.from_pretrained(model_name)
+                assert not torch.allclose(model.v_head.summary.bias, torch.zeros_like(model.v_head.summary.bias))
+
+        def test_value_head_not_str(self):
+            r"""
+            Test if the v-head is added to the model successfully, by passing a non `PretrainedModel` as an argument to
+            `from_pretrained`.
+            """
+            for model_name in self.all_model_names:
+                pretrained_model = self.transformers_model_class.from_pretrained(model_name)
+                model = self.trl_model_class.from_pretrained(pretrained_model)
+                assert hasattr(model, "v_head")
+
+        def test_from_save_trl(self):
+            """
+            Test if the model can be saved and loaded from a directory and get the same weights, including the
+            additional modules (e.g. v_head)
+            """
+            for model_name in self.all_model_names:
+                model = self.trl_model_class.from_pretrained(model_name)
+
+                model.save_pretrained(self.tmp_dir)
+
+                model_from_save = self.trl_model_class.from_pretrained(self.tmp_dir)
+
+                # Check if the weights are the same
+                for key in model_from_save.state_dict():
+                    torch.testing.assert_close(model_from_save.state_dict()[key], model.state_dict()[key])
+
+        def test_from_save_trl_sharded(self):
+            """
+            Test if the model can be saved and loaded from a directory and get the same weights - sharded case
+            """
+            for model_name in self.all_model_names:
+                model = self.trl_model_class.from_pretrained(model_name)
+
+                model.save_pretrained(self.tmp_dir)
+
+                model_from_save = self.trl_model_class.from_pretrained(self.tmp_dir)
+
+                # Check if the weights are the same
+                for key in model_from_save.state_dict():
+                    torch.testing.assert_close(model_from_save.state_dict()[key], model.state_dict()[key])
+
+        def test_from_save_transformers_sharded(self):
+            """
+            Test if the model can be saved and loaded using transformers and get the same weights - sharded case
+            """
+            for model_name in self.all_model_names:
+                transformers_model = self.trl_model_class.transformers_parent_class.from_pretrained(model_name)
+
+                trl_model = self.trl_model_class.from_pretrained(model_name)
+
+                trl_model.save_pretrained(self.tmp_dir, max_shard_size="1MB")
+                transformers_model_from_save = self.trl_model_class.transformers_parent_class.from_pretrained(
+                    self.tmp_dir
+                )
+
+                # Check if the weights are the same
+                for key in transformers_model.state_dict():
+                    torch.testing.assert_close(
+                        transformers_model_from_save.state_dict()[key], transformers_model.state_dict()[key]
+                    )
+
+        def test_from_save_transformers(self):
+            """
+            Test if the model can be saved and loaded using transformers and get the same weights. We override the test
+            of the super class to check if the weights are the same.
+            """
+            for model_name in self.all_model_names:
+                transformers_model = self.trl_model_class.transformers_parent_class.from_pretrained(model_name)
+
+                trl_model = self.trl_model_class.from_pretrained(model_name)
+
+                trl_model.save_pretrained(self.tmp_dir)
+                transformers_model_from_save = self.trl_model_class.transformers_parent_class.from_pretrained(
+                    self.tmp_dir
+                )
+
+                # Check if the weights are the same
+                for key in transformers_model.state_dict():
+                    torch.testing.assert_close(
+                        transformers_model_from_save.state_dict()[key], transformers_model.state_dict()[key]
+                    )
+
+                # Check if the trl model has the same keys as the transformers model
+                # except the v_head
+                for key in trl_model.state_dict():
+                    if "v_head" not in key:
+                        assert key in transformers_model.state_dict()
+                        # check if the weights are the same
+                        torch.testing.assert_close(trl_model.state_dict()[key], transformers_model.state_dict()[key])
+
+                # check if they have the same modules
+                assert set(transformers_model_from_save.state_dict().keys()) == set(
+                    transformers_model.state_dict().keys()
+                )
+
+
+class TestCausalLMValueHeadModel(BaseTester.VHeadModelTester, TrlTestCase):
+    """
+    Testing suite for v-head models.
+    """
+
+    all_model_names = ALL_CAUSAL_LM_MODELS
+    trl_model_class = AutoModelForCausalLMWithValueHead
+    transformers_model_class = AutoModelForCausalLM
+
+    def teardown_method(self):
+        # free memory
+        gc.collect()
+
+    def test_inference(self):
+        r"""
+        Test if the model can be used for inference and outputs 3 values
+        - logits, loss, and value states
+        """
+        EXPECTED_OUTPUT_SIZE = 3
+
+        for model_name in self.all_model_names:
+            model = self.trl_model_class.from_pretrained(model_name).to(self.device)
+            input_ids = torch.tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], device=self.device)
+            outputs = model(input_ids)
+
+            # Check if the outputs are of the right size - here
+            # we always output 3 values - logits, loss, and value states
+            assert len(outputs) == EXPECTED_OUTPUT_SIZE
+
+    def test_dropout_config(self):
+        r"""
+        Test if we instantiate a model by adding `summary_drop_prob` to the config it will be added to the v_head
+        """
+        for model_name in self.all_model_names:
+            pretrained_model = self.transformers_model_class.from_pretrained(model_name)
+            pretrained_model.config.summary_dropout_prob = 0.5
+            model = self.trl_model_class.from_pretrained(pretrained_model)
+
+            # Check if v head of the model has the same dropout as the config
+            assert model.v_head.dropout.p == pretrained_model.config.summary_dropout_prob
+
+    def test_dropout_kwargs(self):
+        r"""
+        Test if we instantiate a model by adding `summary_drop_prob` to the config it will be added to the v_head
+        """
+        for model_name in self.all_model_names:
+            v_head_kwargs = {"summary_dropout_prob": 0.5}
+
+            model = self.trl_model_class.from_pretrained(model_name, **v_head_kwargs)
+
+            # Check if v head of the model has the same dropout as the config
+            assert model.v_head.dropout.p == 0.5
+
+            model = self.trl_model_class.from_pretrained(model_name, summary_dropout_prob=0.5)
+
+            # Check if v head of the model has the same dropout as the config
+            assert model.v_head.dropout.p == 0.5
+
+    @pytest.mark.parametrize("model_name", ALL_CAUSAL_LM_MODELS)
+    def test_generate(self, model_name):
+        r"""
+        Test if `generate` works for every model
+        """
+        generation_config = GenerationConfig(max_new_tokens=9)
+        model = self.trl_model_class.from_pretrained(model_name).to(self.device)
+        input_ids = torch.tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], device=self.device)
+
+        # Just check if the generation works
+        _ = model.generate(input_ids, generation_config=generation_config)
+
+    def test_transformers_bf16_kwargs(self):
+        r"""
+        Test if the transformers kwargs are correctly passed. Here we check that loading a model in half precision
+        works as expected, i.e. the weights of the `pretrained_model` attribute is loaded in half precision and you can
+        run a dummy forward pass without any issue.
+        """
+        for model_name in self.all_model_names:
+            trl_model = self.trl_model_class.from_pretrained(model_name, dtype=torch.bfloat16).to(self.device)
+
+            lm_head_namings = ["lm_head", "embed_out", "output_layer"]
+
+            assert any(hasattr(trl_model.pretrained_model, lm_head_naming) for lm_head_naming in lm_head_namings), (
+                "Can't test the model because it doesn't have any of the expected lm_head namings"
+            )
+
+            for lm_head_naming in lm_head_namings:
+                if hasattr(trl_model.pretrained_model, lm_head_naming):
+                    assert getattr(trl_model.pretrained_model, lm_head_naming).weight.dtype == torch.bfloat16
+
+            dummy_input = torch.LongTensor([[0, 1, 0, 1]]).to(self.device)
+
+            # check dummy forward pass works in half precision
+            _ = trl_model(dummy_input)
+
+    @pytest.mark.skip(reason="This test needs to be run manually due to HF token issue.")
+    def test_push_to_hub(self):
+        for model_name in self.all_model_names:
+            model = AutoModelForCausalLMWithValueHead.from_pretrained(model_name)
+            if "sharded" in model_name:
+                model.push_to_hub(model_name + "-ppo", use_auth_token=True, max_shard_size="1MB")
+            else:
+                model.push_to_hub(model_name + "-ppo", use_auth_token=True)
+
+            model_from_pretrained = AutoModelForCausalLMWithValueHead.from_pretrained(model_name + "-ppo")
+            # check all keys
+            assert model.state_dict().keys() == model_from_pretrained.state_dict().keys()
+
+            for name, param in model.state_dict().items():
+                (
+                    torch.testing.assert_close(param, model_from_pretrained.state_dict()[name]),
+                    (f"Parameter {name} is not the same after push_to_hub and from_pretrained"),
+                )
+
+
+class TestSeq2SeqValueHeadModel(BaseTester.VHeadModelTester, TrlTestCase):
+    """
+    Testing suite for v-head models.
+    """
+
+    all_model_names = ALL_SEQ2SEQ_MODELS
+    trl_model_class = AutoModelForSeq2SeqLMWithValueHead
+    transformers_model_class = AutoModelForSeq2SeqLM
+
+    def teardown_method(self):
+        # free memory
+        gc.collect()
+
+    def test_inference(self):
+        r"""
+        Test if the model can be used for inference and outputs 3 values
+        - logits, loss, and value states
+        """
+        EXPECTED_OUTPUT_SIZE = 3
+
+        for model_name in self.all_model_names:
+            model = self.trl_model_class.from_pretrained(model_name).to(self.device)
+            input_ids = torch.tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], device=self.device)
+            decoder_input_ids = torch.tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], device=self.device)
+            outputs = model(input_ids, decoder_input_ids=decoder_input_ids)
+
+            # Check if the outputs are of the right size - here
+            # we always output 3 values - logits, loss, and value states
+            assert len(outputs) == EXPECTED_OUTPUT_SIZE
+
+    def test_dropout_config(self):
+        r"""
+        Test if we instantiate a model by adding `summary_drop_prob` to the config it will be added to the v_head
+        """
+        for model_name in self.all_model_names:
+            pretrained_model = self.transformers_model_class.from_pretrained(model_name)
+            pretrained_model.config.summary_dropout_prob = 0.5
+            model = self.trl_model_class.from_pretrained(pretrained_model)
+
+            # Check if v head of the model has the same dropout as the config
+            assert model.v_head.dropout.p == pretrained_model.config.summary_dropout_prob
+
+    def test_dropout_kwargs(self):
+        r"""
+        Test if we instantiate a model by adding `summary_drop_prob` to the config it will be added to the v_head
+        """
+        for model_name in self.all_model_names:
+            v_head_kwargs = {"summary_dropout_prob": 0.5}
+
+            model = self.trl_model_class.from_pretrained(model_name, **v_head_kwargs)
+
+            # Check if v head of the model has the same dropout as the config
+            assert model.v_head.dropout.p == 0.5
+
+            model = self.trl_model_class.from_pretrained(model_name, summary_dropout_prob=0.5)
+
+            # Check if v head of the model has the same dropout as the config
+            assert model.v_head.dropout.p == 0.5
+
+    @pytest.mark.parametrize("model_name", ALL_SEQ2SEQ_MODELS)
+    def test_generate(self, model_name):
+        r"""
+        Test if `generate` works for every model
+        """
+        generation_config = GenerationConfig(max_new_tokens=9)
+        model = self.trl_model_class.from_pretrained(model_name).to(self.device)
+        input_ids = torch.tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], device=self.device)
+        decoder_input_ids = torch.tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], device=self.device)
+
+        # Just check if the generation works
+        _ = model.generate(input_ids, decoder_input_ids=decoder_input_ids, generation_config=generation_config)
+
+    @pytest.mark.skip(reason="This test needs to be run manually due to HF token issue.")
+    def test_push_to_hub(self):
+        for model_name in self.all_model_names:
+            model = self.trl_model_class.from_pretrained(model_name)
+            if "sharded" in model_name:
+                model.push_to_hub(model_name + "-ppo", use_auth_token=True, max_shard_size="1MB")
+            else:
+                model.push_to_hub(model_name + "-ppo", use_auth_token=True)
+
+            model_from_pretrained = self.trl_model_class.from_pretrained(model_name + "-ppo")
+            # check all keys
+            assert model.state_dict().keys() == model_from_pretrained.state_dict().keys()
+
+            for name, param in model.state_dict().items():
+                (
+                    torch.testing.assert_close(param, model_from_pretrained.state_dict()[name]),
+                    (f"Parameter {name} is not the same after push_to_hub and from_pretrained"),
+                )
+
+    def test_transformers_bf16_kwargs(self):
+        r"""
+        Test if the transformers kwargs are correctly passed. Here we check that loading a model in half precision
+        works as expected, i.e. the weights of the `pretrained_model` attribute is loaded in half precision and you can
+        run a dummy forward pass without any issue.
+        """
+        for model_name in self.all_model_names:
+            trl_model = self.trl_model_class.from_pretrained(model_name, dtype=torch.bfloat16).to(self.device)
+
+            lm_head_namings = self.trl_model_class.lm_head_namings
+
+            assert any(hasattr(trl_model.pretrained_model, lm_head_naming) for lm_head_naming in lm_head_namings)
+
+            for lm_head_naming in lm_head_namings:
+                if hasattr(trl_model.pretrained_model, lm_head_naming):
+                    assert getattr(trl_model.pretrained_model, lm_head_naming).weight.dtype == torch.bfloat16
+
+            dummy_input = torch.LongTensor([[0, 1, 0, 1]]).to(self.device)
+
+            # check dummy forward pass works in half precision
+            _ = trl_model(input_ids=dummy_input, decoder_input_ids=dummy_input)
+
+
+@require_peft
+class TestPeftModel(TrlTestCase):
+    def setup_method(self):
+        self.causal_lm_model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        self.lora_config = LoraConfig(
+            r=16,
+            lora_alpha=32,
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+    def test_create_peft_model(self):
+        r"""
+        Simply creates a peft model and checks that it can be loaded.
+        """
+        causal_lm_model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id)
+        pretrained_model = get_peft_model(causal_lm_model, self.lora_config)
+
+        _ = AutoModelForCausalLMWithValueHead.from_pretrained(pretrained_model)
+
+    def test_peft_requires_grad(self):
+        r"""
+        Check that the value head of the returned model has requires_grad=True.
+        """
+        causal_lm_model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id)
+        pretrained_model = get_peft_model(causal_lm_model, self.lora_config)
+
+        model = AutoModelForCausalLMWithValueHead.from_pretrained(pretrained_model)
+
+        # Check that the value head has requires_grad=True
+        assert model.v_head.summary.weight.requires_grad
+
+    def test_check_peft_model_nb_trainable_params(self):
+        r"""
+        Check that the number of trainable parameters is correct.
+        """
+        causal_lm_model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id)
+        pretrained_model = get_peft_model(causal_lm_model, self.lora_config)
+
+        model = AutoModelForCausalLMWithValueHead.from_pretrained(pretrained_model)
+
+        # Check that the number of trainable parameters is correct
+        nb_trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+        assert nb_trainable_params == 905
+
+        # Check that the number of trainable param for the non-peft model is correct
+        non_peft_model = AutoModelForCausalLMWithValueHead.from_pretrained(self.causal_lm_model_id)
+        nb_trainable_params = sum(p.numel() for p in non_peft_model.parameters() if p.requires_grad)
+        assert nb_trainable_params == 2428641
+
+    def test_create_peft_model_from_config(self):
+        r"""
+        Simply creates a peft model and checks that it can be loaded.
+        """
+        trl_model = AutoModelForCausalLMWithValueHead.from_pretrained(
+            self.causal_lm_model_id, peft_config=self.lora_config
+        )
+        # Check that the number of trainable parameters is correct
+        nb_trainable_params = sum(p.numel() for p in trl_model.parameters() if p.requires_grad)
+        assert nb_trainable_params == 905
+
+        causal_lm_model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id)
+        trl_model = AutoModelForCausalLMWithValueHead.from_pretrained(causal_lm_model, peft_config=self.lora_config)
+        # Check that the number of trainable parameters is correct
+        nb_trainable_params = sum(p.numel() for p in trl_model.parameters() if p.requires_grad)
+        assert nb_trainable_params == 905
+
+    @require_bitsandbytes
+    @require_torch_gpu_if_bnb_not_multi_backend_enabled
+    def test_create_bnb_peft_model_from_config(self):
+        r"""
+        Simply creates a peft model and checks that it can be loaded.
+        """
+        from bitsandbytes.nn import Linear8bitLt
+        from transformers import BitsAndBytesConfig
+
+        trl_model = AutoModelForCausalLMWithValueHead.from_pretrained(
+            self.causal_lm_model_id,
+            peft_config=self.lora_config,
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+        # Check that the number of trainable parameters is correct
+        nb_trainable_params = sum(p.numel() for p in trl_model.parameters() if p.requires_grad)
+        assert nb_trainable_params == 905
+        assert isinstance(trl_model.pretrained_model.model.model.layers[0].mlp.gate_proj, Linear8bitLt)
+
+        causal_lm_model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id, quantization_config=BitsAndBytesConfig(load_in_8bit=True), device_map="auto"
+        )
+        trl_model = AutoModelForCausalLMWithValueHead.from_pretrained(causal_lm_model, peft_config=self.lora_config)
+        # Check that the number of trainable parameters is correct
+        nb_trainable_params = sum(p.numel() for p in trl_model.parameters() if p.requires_grad)
+        assert nb_trainable_params == 905
+        assert isinstance(trl_model.pretrained_model.model.model.layers[0].mlp.gate_proj, Linear8bitLt)
+
+    def test_save_pretrained_peft(self):
+        r"""
+        Check that the model can be saved and loaded properly.
+        """
+        causal_lm_model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id)
+        pretrained_model = get_peft_model(causal_lm_model, self.lora_config)
+
+        model = AutoModelForCausalLMWithValueHead.from_pretrained(pretrained_model)
+
+        model.save_pretrained(self.tmp_dir)
+
+        # check that the files `adapter_model.safetensors` and `adapter_config.json` are in the directory
+        assert os.path.isfile(f"{self.tmp_dir}/adapter_model.safetensors"), (
+            f"{self.tmp_dir}/adapter_model.safetensors does not exist"
+        )
+        assert os.path.exists(f"{self.tmp_dir}/adapter_config.json"), (
+            f"{self.tmp_dir}/adapter_config.json does not exist"
+        )
+
+        # check also for `pytorch_model.bin` and make sure it only contains `v_head` weights
+        assert os.path.exists(f"{self.tmp_dir}/pytorch_model.bin"), f"{self.tmp_dir}/pytorch_model.bin does not exist"
+
+        # check that only keys that starts with `v_head` are in the dict
+        maybe_v_head = torch.load(f"{self.tmp_dir}/pytorch_model.bin", weights_only=True)
+        assert all(k.startswith("v_head") for k in maybe_v_head.keys()), (
+            f"keys in {self.tmp_dir}/pytorch_model.bin do not start with `v_head`"
+        )
+
+        model_from_pretrained = AutoModelForCausalLMWithValueHead.from_pretrained(self.tmp_dir)
+
+        # check all the weights are the same
+        for p1, p2 in zip(model.named_parameters(), model_from_pretrained.named_parameters(), strict=True):
+            torch.testing.assert_close(p1[1], p2[1], msg=f"{p1[0]} != {p2[0]}")
+
+    def test_load_pretrained_peft(self):
+        r"""
+        Check that the model saved with peft class interface can be loaded properly.
+        """
+        causal_lm_model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id)
+        pretrained_model = get_peft_model(causal_lm_model, self.lora_config)
+
+        model = AutoModelForCausalLMWithValueHead.from_pretrained(pretrained_model)
+
+        pretrained_model.save_pretrained(self.tmp_dir)
+        model_from_pretrained = AutoModelForCausalLMWithValueHead.from_pretrained(self.tmp_dir)
+
+        # check that the files `adapter_model.safetensors` and `adapter_config.json` are in the directory
+        assert os.path.isfile(f"{self.tmp_dir}/adapter_model.safetensors"), (
+            f"{self.tmp_dir}/adapter_model.safetensors does not exist"
+        )
+        assert os.path.exists(f"{self.tmp_dir}/adapter_config.json"), (
+            f"{self.tmp_dir}/adapter_config.json does not exist"
+        )
+
+        # check all the weights are the same
+        for p1, p2 in zip(model.named_parameters(), model_from_pretrained.named_parameters(), strict=True):
+            if p1[0] not in ["v_head.summary.weight", "v_head.summary.bias"]:
+                torch.testing.assert_close(p1[1], p2[1], msg=f"{p1[0]} != {p2[0]}")
+
+    def test_continue_training_peft_model(self):
+        r"""
+        Load peft and checks that it can continue training.
+        """
+        causal_lm_model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id)
+        pretrained_model = get_peft_model(causal_lm_model, self.lora_config)
+
+        pretrained_model.save_pretrained(self.tmp_dir)
+        # set is_trainable to True
+        model = AutoModelForCausalLMWithValueHead.from_pretrained(self.tmp_dir, is_trainable=True)
+        # Check that the number of trainable parameters is correct
+        nb_trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+        assert nb_trainable_params == 905
+
+
+class TestCore(TrlTestCase):
+    """
+    A wrapper class for testing core utils functions
+    """
+
+    def setup_method(self):
+        self.test_input = torch.Tensor([1, 2, 3, 4])
+        self.test_mask = torch.Tensor([0, 1, 1, 0])
+        self.test_input_unmasked = self.test_input[1:3]
+
+    def test_masked_mean(self):
+        assert torch.mean(self.test_input_unmasked) == masked_mean(self.test_input, self.test_mask)
+
+    def test_masked_var(self):
+        assert torch.var(self.test_input_unmasked) == masked_var(self.test_input, self.test_mask)
+
+    def test_masked_whiten(self):
+        def whiten(values: torch.Tensor) -> torch.Tensor:
+            mean, var = torch.mean(values), torch.var(values)
+            return (values - mean) * torch.rsqrt(var + 1e-8)
+
+        whiten_unmasked = whiten(self.test_input_unmasked)
+        whiten_masked = masked_whiten(self.test_input, self.test_mask)[1:3]
+        diffs = (whiten_unmasked - whiten_masked).sum()
+        assert abs(diffs.item()) < 0.00001
+
+
+class TestPPOTrainer(TrlTestCase):
+    def setup_method(self):
+        # Set up the models and tokenizer using the test model
+        self.model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        self.model = AutoModelForCausalLM.from_pretrained(self.model_id, dtype="float32")
+        self.ref_model = AutoModelForCausalLM.from_pretrained(self.model_id)
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_id, padding_side="left")
+        self.tokenizer.add_special_tokens({"pad_token": "[PAD]"})
+
+        # Add reward and value models as in ppo.py
+        reward_model_id = "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5"
+        self.value_model = AutoModelForSequenceClassification.from_pretrained(reward_model_id, num_labels=1)
+        self.reward_model = AutoModelForSequenceClassification.from_pretrained(reward_model_id, num_labels=1)
+
+        # Load dataset
+        raw_dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only")
+
+        def tokenize(example, tokenizer):
+            tokenized = tokenizer(text=example["prompt"])
+            if tokenizer.eos_token_id is not None and tokenized["input_ids"][-1] != tokenizer.eos_token_id:
+                tokenized["input_ids"] = tokenized["input_ids"] + [tokenizer.eos_token_id]
+                tokenized["attention_mask"] = tokenized["attention_mask"] + [1]
+            return tokenized
+
+        self.raw_dataset = raw_dataset.map(tokenize, fn_kwargs={"tokenizer": self.tokenizer}, remove_columns="prompt")
+
+    def test_basic_training(self):
+        """Test basic PPO training configuration and verify model updates."""
+        # Capture initial weights
+        initial_critic_weights = {}
+        initial_policy_weights = {}
+        for name, param in self.value_model.named_parameters():
+            initial_critic_weights[name] = param.clone().detach()
+        for name, param in self.model.named_parameters():
+            initial_policy_weights[name] = param.clone().detach()
+
+        # Configure training args similar to example script
+        training_args = PPOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=4,
+            per_device_eval_batch_size=2,
+            num_ppo_epochs=2,  # Decrease number of PPO epochs to speed up test
+            report_to="none",
+        )
+
+        # Create trainer
+        trainer = PPOTrainer(
+            args=training_args,
+            processing_class=self.tokenizer,
+            model=self.model,
+            ref_model=self.ref_model,
+            reward_model=self.reward_model,
+            value_model=self.value_model,
+            train_dataset=self.raw_dataset["train"],
+            eval_dataset=self.raw_dataset["test"],
+        )
+
+        # Train
+        trainer.train()
+
+        # Check if critic weights have been updated
+        critic_weights_updated = False
+        for name, param in trainer.model.value_model.named_parameters():
+            if not torch.equal(initial_critic_weights[name], param.to("cpu")):
+                critic_weights_updated = True
+                break
+
+        # Check if policy weights have been updated
+        policy_weights_updated = False
+        for name, param in trainer.model.policy.named_parameters():
+            if not torch.equal(initial_policy_weights[name], param.to("cpu")):
+                policy_weights_updated = True
+                break
+
+        assert critic_weights_updated, "Critic weights were not updated during training"
+        assert policy_weights_updated, "Policy weights were not updated during training"
+
+    @require_peft
+    def test_peft_training(self):
+        """Test PPO training with PEFT configuration and verify model updates."""
+        # Capture initial weights
+        initial_critic_weights = {}
+        initial_policy_weights = {}
+        for name, param in self.value_model.named_parameters():
+            initial_critic_weights[name] = param.clone().detach()
+        for name, param in self.model.named_parameters():
+            initial_policy_weights[name] = param.clone().detach()
+
+        # Configure training args
+        training_args = PPOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=4,
+            per_device_eval_batch_size=2,
+            num_ppo_epochs=2,  # Decrease number of PPO epochs to speed up test
+            report_to="none",
+        )
+
+        # Configure PEFT
+        peft_config = LoraConfig(
+            r=32,
+            lora_alpha=16,
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        # Create trainer with PEFT
+        trainer = PPOTrainer(
+            args=training_args,
+            processing_class=self.tokenizer,
+            model=self.model,
+            ref_model=None,
+            reward_model=self.reward_model,
+            value_model=self.value_model,
+            train_dataset=self.raw_dataset["train"],
+            eval_dataset=self.raw_dataset["test"],
+            peft_config=peft_config,
+        )
+
+        # Train
+        trainer.train()
+
+        # Check if critic weights have been updated
+        critic_weights_updated = False
+        for name, param in trainer.model.value_model.named_parameters():
+            if name in initial_critic_weights and not torch.equal(initial_critic_weights[name], param.to("cpu")):
+                critic_weights_updated = True
+                break
+
+        # Check if policy weights have been updated - for PEFT we check the LoRA weights
+        policy_weights_updated = False
+        for name, param in trainer.model.policy.named_parameters():
+            if "lora" in name.lower() and param.requires_grad:  # Only check LoRA weights
+                # New weights should be non-zero if they've been updated
+                if not torch.allclose(param, torch.zeros_like(param)):
+                    policy_weights_updated = True
+                    break
+
+        assert critic_weights_updated, "Critic weights were not updated during training"
+        assert policy_weights_updated, "Policy LoRA weights were not updated during training"

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_prm_trainer.py

@@ -0,0 +1,376 @@
+# 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 unittest.mock import MagicMock
+
+import numpy as np
+import pytest
+import torch
+from datasets import Dataset, load_dataset
+from transformers import AutoModelForTokenClassification, AutoTokenizer, PreTrainedTokenizerBase
+from transformers.utils import is_peft_available
+
+from trl.experimental.prm import PRMConfig, PRMTrainer
+from trl.experimental.prm.prm_trainer import compute_accuracy
+
+from ..testing_utils import TrlTestCase, require_peft
+
+
+if is_peft_available():
+    from peft import LoraConfig, TaskType
+
+
+class TestComputeAccuracy(TrlTestCase):
+    def test_token_classification_task(self):
+        eval_pred = (
+            np.array(
+                [
+                    [[0.1, 0.9], [0.8, 0.2]],  # Batch 1
+                    [[0.3, 0.7], [0.6, 0.4]],  # Batch 2
+                ]
+            ),
+            np.array([[0, 1], [1, 0]]),
+        )
+        expected_accuracy = 0.5  # 2 matches, 2 mismatches
+        result = compute_accuracy(eval_pred)
+        assert round(abs(result["accuracy"] - expected_accuracy), 7) == 0
+
+    def test_token_classification_task_with_ignored_tokens_0(self):
+        eval_pred = (
+            np.array(
+                [
+                    [[0.1, 0.9], [0.8, 0.2]],  # Batch 1
+                    [[0.3, 0.7], [0.6, 0.4]],  # Batch 2
+                ]
+            ),
+            np.array([[1, 0], [1, -100]]),
+        )
+        expected_accuracy = 1.0  # All non-ignored tokens match
+        result = compute_accuracy(eval_pred)
+        assert round(abs(result["accuracy"] - expected_accuracy), 7) == 0
+
+    def test_token_classification_task_with_ignored_tokens_1(self):
+        eval_pred = (
+            np.array(
+                [
+                    [[0.1, 0.9], [0.8, 0.2]],  # Batch 1
+                    [[0.3, 0.7], [0.6, 0.4]],  # Batch 2
+                ]
+            ),
+            np.array([[1, 1], [0, -100]]),
+        )
+        expected_accuracy = 1 / 3  # 1 match, 2 mismatch, 1 ignored
+        result = compute_accuracy(eval_pred)
+        assert round(abs(result["accuracy"] - expected_accuracy), 7) == 0
+
+    def test_rewards_comparison_task(self, caplog):
+        eval_pred = (
+            np.array(
+                [
+                    [0.9, 0.1],  # Batch 1
+                    [0.6, 0.4],  # Batch 2
+                    [0.5, 0.5],  # Batch 3 (equal)
+                ]
+            ),
+            np.array([0, 1, 1]),
+        )
+        expected_accuracy = 0.5  # 1 match, 1 mismatch, 1 equal (ignored)
+
+        with caplog.at_level("WARNING", logger="trl.trainer.utils"):
+            result = compute_accuracy(eval_pred)
+
+        assert round(abs(result["accuracy"] - expected_accuracy), 7) == 0
+        expected_warning = (
+            "There are 1 out of 3 instances where the predictions for both options are equal. "
+            "These instances are ignored in the accuracy computation."
+        )
+        assert expected_warning in caplog.text
+
+
+class TestTokenizeRow(TrlTestCase):
+    def setup_method(self):
+        # Set up the mock tokenizer with specific behaviors
+        self.tokenizer = MagicMock(spec=PreTrainedTokenizerBase)
+        self.tokenizer.bos_token_id = 0
+        self.tokenizer.eos_token_id = 2
+
+        def mock_encode(text, add_special_tokens):
+            token_map = {
+                "Which number is larger, 9.8 or 9.11?": [465, 6766, 318, 298],
+                "11 is greater than 8.": [4, 322, 12],
+                "Hence, 9.11 > 9.8.": [4995, 11, 22],
+                "\n": [1030],
+                "\n\n": [1030, 1030],
+            }
+
+            return token_map[text]
+
+        def mock_tokenizer_call(text, add_special_tokens):
+            return {"input_ids": mock_encode(text, add_special_tokens)}
+
+        self.tokenizer.encode.side_effect = mock_encode
+        self.tokenizer.side_effect = mock_tokenizer_call
+
+    def test_tokenize_row_no_truncation(self):
+        # Define the input features
+        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],
+        }
+
+        # Call the method with no truncation
+        result = PRMTrainer.tokenize_row(
+            features=features,
+            tokenizer=self.tokenizer,
+            step_separator="\n",
+            max_length=None,
+            max_completion_length=None,
+            train_on_last_step_only=False,
+            is_eval=False,
+        )
+
+        assert result == {
+            "input_ids": [0, 465, 6766, 318, 298, 4, 322, 12, 1030, 4995, 11, 22, 1030],
+            "labels": [-100, -100, -100, -100, -100, -100, -100, -100, 1, -100, -100, -100, 0],
+        }
+
+    def test_tokenize_row_train_on_last_step_only(self):
+        # Define the input features
+        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],
+        }
+
+        result = PRMTrainer.tokenize_row(
+            features=features,
+            tokenizer=self.tokenizer,
+            step_separator="\n",
+            max_length=None,
+            max_completion_length=None,
+            train_on_last_step_only=True,
+            is_eval=False,
+        )
+
+        assert result == {
+            "input_ids": [0, 465, 6766, 318, 298, 4, 322, 12, 1030, 4995, 11, 22, 1030],
+            "labels": [-100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, 0],
+        }
+
+    def test_tokenize_row_completion_truncation(self):
+        # Define the input features
+        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],
+        }
+
+        # Call the method with truncation on the completion
+        result = PRMTrainer.tokenize_row(
+            features=features,
+            tokenizer=self.tokenizer,
+            step_separator="\n",
+            max_length=None,
+            max_completion_length=6,
+            train_on_last_step_only=False,
+            is_eval=False,
+        )
+
+        assert result == {
+            "input_ids": [0, 465, 6766, 318, 298, 4, 322, 12, 1030, 4995, 11],
+            "labels": [-100, -100, -100, -100, -100, -100, -100, -100, 1, -100, -100],
+        }
+
+    def test_tokenize_row_prompt_completion_truncation(self):
+        # Define the input features
+        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],
+        }
+
+        # Call the method with truncation on the prompt and completion
+        result = PRMTrainer.tokenize_row(
+            features=features,
+            tokenizer=self.tokenizer,
+            step_separator="\n",
+            max_length=9,
+            max_completion_length=None,
+            train_on_last_step_only=False,
+            is_eval=False,
+        )
+
+        assert result == {
+            "input_ids": [0, 465, 6766, 318, 298, 4, 322, 12, 1030],
+            "labels": [-100, -100, -100, -100, -100, -100, -100, -100, 1],
+        }
+
+    def test_tokenize_row_multi_token_separator(self):
+        # Define the input features
+        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],
+        }
+
+        # Call the method using multiple tokens as step_separator
+        result = PRMTrainer.tokenize_row(
+            features=features,
+            tokenizer=self.tokenizer,
+            step_separator="\n\n",
+            max_length=None,
+            max_completion_length=None,
+            train_on_last_step_only=False,
+            is_eval=False,
+        )
+
+        assert result == {
+            "input_ids": [0, 465, 6766, 318, 298, 4, 322, 12, 1030, 1030, 4995, 11, 22, 1030, 1030],
+            "labels": [-100, -100, -100, -100, -100, -100, -100, -100, -100, 1, -100, -100, -100, -100, 0],
+        }
+
+
+class TestPRMTrainer(TrlTestCase):
+    def setup_method(self):
+        model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        self.model = AutoModelForTokenClassification.from_pretrained(model_id, dtype="float32")
+        self.tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+    @pytest.mark.parametrize("train_on_last_step_only", [True, False])
+    def test_train_full(self, train_on_last_step_only):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_stepwise_supervision", split="train")
+        training_args = PRMConfig(
+            output_dir=self.tmp_dir,
+            report_to="none",
+            train_on_last_step_only=train_on_last_step_only,
+        )
+        trainer = PRMTrainer(
+            model=self.model, args=training_args, processing_class=self.tokenizer, train_dataset=dataset
+        )
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if param.sum() != 0:  # ignore 0 biases
+                assert not torch.equal(param, new_param)
+
+    def test_train_full_pretokenized(self):
+        dataset = Dataset.from_dict(
+            {
+                "labels": [
+                    [-100, -100, -100, -100, -100, -100, -100, -100, -100, 0, -100, -100, 1],
+                    [-100, -100, -100, -100, -100, -100, -100, -100, 0, -100, -100, 1, -100, -100, -100, -100, 0],
+                    [-100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, 0, -100, -100, 1],
+                    [-100, -100, -100, -100, -100, -100, -100, 1, -100, -100, 1],
+                    [-100, -100, -100, -100, -100, -100, -100, -100, -100, 1, -100, -100, 0],
+                    [-100, -100, -100, -100, -100, -100, -100, -100, -100, 1],
+                    [-100, -100, -100, -100, -100, -100, -100, -100, -100, 0],
+                    [-100, -100, -100, -100, -100, -100, -100, -100, -100, 1, -100, -100, -100, -100, -100, 0],
+                    [-100, -100, -100, -100, -100, -100, -100, -100, 0, -100, -100, 0],
+                    [-100, -100, -100, -100, -100, -100, 0, -100, -100, -100, -100, 0],
+                    [-100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, 1],
+                    [-100, -100, -100, -100, -100, -100, 0],
+                    [-100, -100, -100, -100, -100, -100, -100, -100, 1],
+                    [-100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, 0],
+                ],
+                "input_ids": [
+                    [46518, 374, 2664, 1091, 11, 1077, 752, 1744, 1112, 198, 27261, 13, 198],
+                    [98923, 374, 2664, 1091, 11, 315, 3308, 11, 198, 17995, 13, 198, 1576, 31273, 12850, 13, 198],
+                    [16374, 374, 2664, 1091, 1112, 1077, 594, 2506, 432, 6770, 11, 198, 6351, 13, 198],
+                    [31137, 374, 2664, 1091, 979, 4362, 11, 198, 16965, 13, 198],
+                    [31019, 374, 2664, 1091, 304, 3793, 315, 5944, 11, 198, 24034, 13, 198],
+                    [98491, 374, 2664, 1091, 1112, 5310, 369, 91494, 13, 198],
+                    [4418, 2897, 14579, 5310, 979, 3800, 1349, 432, 13, 198],
+                    [20366, 5048, 7629, 944, 3281, 3322, 11, 7241, 1112, 198, 807, 1795, 279, 5601, 13, 198],
+                    [15802, 14976, 487, 33327, 1045, 31787, 63443, 11, 198, 52400, 13, 198],
+                    [13877, 1265, 2581, 1494, 49394, 11, 198, 7241, 20975, 91681, 13, 198],
+                    [641, 279, 3579, 315, 71768, 11, 25066, 279, 61361, 311, 7942, 13, 198],
+                    [7039, 374, 2664, 1091, 2937, 13, 198],
+                    [26155, 374, 3545, 2664, 1091, 34933, 26537, 13, 198],
+                    [2679, 279, 8129, 374, 4135, 311, 10339, 11, 432, 2578, 387, 264, 1661, 2884, 13, 198],
+                ],
+            }
+        )
+
+        training_args = PRMConfig(output_dir=self.tmp_dir, report_to="none")
+        trainer = PRMTrainer(
+            model=self.model, args=training_args, processing_class=self.tokenizer, train_dataset=dataset
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if param.sum() != 0:  # ignore 0 biases
+                assert not torch.equal(param, new_param)
+
+    @require_peft
+    def test_train_lora(self):
+        peft_config = LoraConfig(
+            task_type=TaskType.TOKEN_CLS,
+            inference_mode=False,
+            r=8,
+            lora_alpha=32,
+            lora_dropout=0.1,
+        )
+        dataset = load_dataset("trl-internal-testing/zen", "standard_stepwise_supervision", split="train")
+        training_args = PRMConfig(output_dir=self.tmp_dir, max_steps=3, report_to="none")
+        trainer = PRMTrainer(
+            model=self.model,
+            args=training_args,
+            processing_class=self.tokenizer,
+            train_dataset=dataset,
+            peft_config=peft_config,
+        )
+        previous_trainable_params = {}
+        previous_non_trainable_params = {}
+
+        # due to a change in the way the modules to save are dealt in PEFT.
+        trainable_params_name = ["lora", "modules_to_save"]
+
+        # check gradients are not None
+        for n, param in trainer.model.named_parameters():
+            if any(t in n for t in trainable_params_name):
+                previous_trainable_params[n] = param.clone()
+            else:
+                previous_non_trainable_params[n] = param.clone()
+
+        trainer.train()
+
+        assert trainer.state.log_history[(-1)]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param)
+
+        # Check that the non trainable parameters have not changed
+        for n, param in previous_non_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            torch.testing.assert_close(param, new_param, atol=1e-12, rtol=1e-12)
+
+    def test_tags(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_stepwise_supervision", split="train")
+        training_args = PRMConfig(output_dir=self.tmp_dir, report_to="none")
+        trainer = PRMTrainer(
+            model=self.model, args=training_args, processing_class=self.tokenizer, train_dataset=dataset
+        )
+        assert trainer.model.model_tags == trainer._tag_names

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_sdft_trainer.py

@@ -0,0 +1,524 @@
+# 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 pytest
+import torch
+from datasets import Dataset
+from transformers import TrainerCallback
+from transformers.utils import is_peft_available
+
+from trl.experimental.sdft import SDFTConfig, SDFTTrainer
+
+from ..testing_utils import TrlTestCase, require_liger_kernel, require_peft, require_torch_accelerator
+
+
+if is_peft_available():
+    from peft import LoraConfig
+
+
+class SelfDistillationCaptureCallback(TrainerCallback):
+    def __init__(self):
+        self.captured_generation_prompts = None
+        self.captured_old_per_token_logps = None
+        self.captured_prompt_ids = None
+        self.generation_batch_build_count = 0
+
+    def on_generation_prompts_selected(self, generation_prompts=None, **kwargs):
+        if self.captured_generation_prompts is None and generation_prompts is not None:
+            self.captured_generation_prompts = generation_prompts
+
+    def on_self_distillation_batch_prepared(self, old_per_token_logps=None, prompt_ids=None, **kwargs):
+        if self.captured_old_per_token_logps is None and old_per_token_logps is not None:
+            self.captured_old_per_token_logps = old_per_token_logps.detach().cpu()
+        if self.captured_prompt_ids is None and prompt_ids is not None:
+            self.captured_prompt_ids = prompt_ids.detach().cpu()
+
+    def on_generation_batch_built(self, **kwargs):
+        self.generation_batch_build_count += 1
+
+
+class RecordingTeacherClient:
+    """Stands in for the vLLM server client and records scoring requests."""
+
+    def __init__(self, response):
+        self.response = response
+        self.calls = []
+
+    def get_sequence_logprobs(self, **kwargs):
+        self.calls.append(kwargs)
+        return self.response
+
+
+class TestSDFTTrainer(TrlTestCase):
+    @staticmethod
+    def _trainable_param_snapshot(model):
+        return {name: param.detach().clone() for name, param in model.named_parameters() if param.requires_grad}
+
+    @staticmethod
+    def _assert_any_trainable_param_changed(model, previous_trainable_params):
+        assert any(
+            not torch.allclose(previous_param, model.get_parameter(name), rtol=1e-12, atol=1e-12)
+            for name, previous_param in previous_trainable_params.items()
+        )
+
+    def test_trust_remote_code(self):
+        dataset = Dataset.from_dict(
+            {
+                "prompt": ["Solve 2+2.", "Name the capital of France."],
+                "privileged_context": ["Example answer: 4.", "Example answer: Paris."],
+            }
+        )
+        model_id = "trl-internal-testing/tiny-RemoteForCausalLM"
+
+        with pytest.raises(ValueError, match="custom code"):
+            SDFTTrainer(
+                model=model_id,
+                args=SDFTConfig(output_dir=self.tmp_dir, report_to="none"),
+                train_dataset=dataset,
+            )
+
+        trainer = SDFTTrainer(
+            model=model_id,
+            args=SDFTConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True),
+            train_dataset=dataset,
+        )
+        assert type(trainer.model).__name__ == "RemoteForCausalLM"
+
+    def test_train(self):
+        dataset = Dataset.from_dict(
+            {
+                "prompt": ["Solve 2+2.", "Name the capital of France."],
+                "privileged_context": [
+                    "Example answer: 4.",
+                    "Example answer: Paris.",
+                ],
+            }
+        )
+
+        training_args = SDFTConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            max_completion_length=8,
+            max_steps=1,
+            num_generations=1,
+            report_to="none",
+        )
+
+        trainer = SDFTTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+        previous_trainable_params = self._trainable_param_snapshot(trainer.model)
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+        self._assert_any_trainable_param_changed(trainer.model, previous_trainable_params)
+
+    @require_liger_kernel
+    @require_torch_accelerator
+    def test_liger_loss_matches_non_liger_loss(self):
+        dataset = Dataset.from_dict({"prompt": ["Solve 2+2."], "privileged_context": ["Example answer: 4."]})
+        common = dict(
+            output_dir=self.tmp_dir,
+            report_to="none",
+            per_device_train_batch_size=1,
+            max_completion_length=3,
+            num_generations=1,
+            distillation_mode="full_logits",
+            distillation_is_clip=None,
+            num_loss_tokens_to_skip=1,
+        )
+
+        ref_trainer = SDFTTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=SDFTConfig(use_liger_kernel=False, **common),
+            train_dataset=dataset,
+        )
+        liger_trainer = SDFTTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=SDFTConfig(use_liger_kernel=True, **common),
+            train_dataset=dataset,
+        )
+
+        liger_trainer.model.load_state_dict(ref_trainer.model.state_dict())
+        torch.manual_seed(0)
+        with torch.no_grad():
+            for param in ref_trainer.teacher_model.parameters():
+                param.add_(0.5 * torch.randn_like(param))
+        liger_trainer.teacher_model.load_state_dict(ref_trainer.teacher_model.state_dict())
+
+        device = next(ref_trainer.model.parameters()).device
+        batch = {
+            "prompt_ids": torch.tensor([[10, 11], [12, 13]], device=device),
+            "prompt_mask": torch.tensor([[1, 1], [1, 1]], device=device),
+            "completion_ids": torch.tensor([[14, 15, 16], [17, 18, 19]], device=device),
+            "completion_mask": torch.tensor([[1, 1, 0], [1, 1, 1]], device=device),
+            "teacher_input_ids": torch.tensor([[20, 21, 22, 14, 15, 16], [23, 24, 25, 17, 18, 19]], device=device),
+            "teacher_attention_mask": torch.tensor([[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1]], device=device),
+        }
+
+        ref_trainer.model.eval()
+        liger_trainer.model.eval()
+        with torch.no_grad():
+            ref_loss = ref_trainer.compute_loss(ref_trainer.model, batch).item()
+            liger_loss = liger_trainer.compute_loss(liger_trainer.model, batch).item()
+
+        torch.testing.assert_close(
+            torch.tensor(liger_loss),
+            torch.tensor(ref_loss),
+            rtol=2e-2,
+            atol=1e-6,
+        )
+
+    def test_train_rejects_none_privileged_context(self):
+        dataset = Dataset.from_dict(
+            {
+                "prompt": ["Solve 2+2."],
+                "privileged_context": [None],
+            }
+        )
+
+        training_args = SDFTConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=1,
+            max_completion_length=8,
+            max_steps=1,
+            num_generations=1,
+            report_to="none",
+        )
+
+        trainer = SDFTTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        with pytest.raises(ValueError, match="`privileged_context` must not be None"):
+            trainer.train()
+
+    def test_train_with_generate_from_teacher(self):
+        dataset = Dataset.from_dict(
+            {
+                "prompt": ["Solve 2+2.", "Solve 3+3."],
+                "privileged_context": [
+                    "Teacher hint: answer with 4 and explain briefly.",
+                    "Teacher hint: answer with 6 and explain briefly.",
+                ],
+            }
+        )
+
+        training_args = SDFTConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            max_completion_length=8,
+            max_steps=1,
+            num_generations=1,
+            generate_from_teacher=True,
+            report_to="none",
+        )
+
+        capture_callback = SelfDistillationCaptureCallback()
+        trainer = SDFTTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+            callbacks=[capture_callback],
+        )
+
+        trainer.train()
+
+        assert capture_callback.captured_generation_prompts == [
+            "Solve 2+2.\n\nTeacher hint: answer with 4 and explain briefly."
+        ]
+        student_prompt_text = trainer.processing_class.decode(
+            capture_callback.captured_prompt_ids[0],
+            skip_special_tokens=True,
+        )
+        assert "Teacher hint" not in student_prompt_text
+        assert "Solve 2+2." in student_prompt_text
+
+    def test_train_with_chat_template_kwargs(self):
+        dataset = Dataset.from_dict(
+            {
+                "prompt": [
+                    [{"role": "user", "content": "Solve 2+2."}],
+                    [{"role": "user", "content": "Solve 3+3."}],
+                ],
+                "privileged_context": [
+                    "Teacher hint: answer with 4.",
+                    "Teacher hint: answer with 6.",
+                ],
+            }
+        )
+
+        training_args = SDFTConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            max_completion_length=8,
+            max_steps=1,
+            num_generations=1,
+            chat_template_kwargs={"enable_thinking": False},
+            report_to="none",
+        )
+
+        trainer = SDFTTrainer(
+            model="trl-internal-testing/tiny-Qwen3ForCausalLM",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = self._trainable_param_snapshot(trainer.model)
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+        self._assert_any_trainable_param_changed(trainer.model, previous_trainable_params)
+
+    @require_peft
+    def test_train_with_peft_model(self):
+        dataset = Dataset.from_dict(
+            {
+                "prompt": ["Solve 2+2.", "Name the capital of France."],
+                "privileged_context": [
+                    "Example answer: 4.",
+                    "Example answer: Paris.",
+                ],
+            }
+        )
+
+        training_args = SDFTConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            max_completion_length=8,
+            max_steps=1,
+            num_generations=1,
+            report_to="none",
+        )
+
+        trainer = SDFTTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+            peft_config=LoraConfig(
+                task_type="CAUSAL_LM",
+                target_modules=["q_proj", "v_proj"],
+            ),
+        )
+
+        previous_trainable_params = self._trainable_param_snapshot(trainer.model)
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+        self._assert_any_trainable_param_changed(trainer.model, previous_trainable_params)
+
+    @require_peft
+    def test_train_with_peft_model_and_ema_teacher_sync(self):
+        dataset = Dataset.from_dict(
+            {
+                "prompt": ["Solve 2+2.", "Name the capital of France."],
+                "privileged_context": [
+                    "Example answer: 4.",
+                    "Example answer: Paris.",
+                ],
+            }
+        )
+
+        training_args = SDFTConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            max_completion_length=8,
+            max_steps=2,
+            num_generations=1,
+            teacher_model_kind="ema",
+            teacher_update_rate=0.05,
+            teacher_sync_steps=1,
+            report_to="none",
+        )
+
+        trainer = SDFTTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+            peft_config=LoraConfig(
+                task_type="CAUSAL_LM",
+                target_modules=["q_proj", "v_proj"],
+            ),
+        )
+        previous_trainable_params = self._trainable_param_snapshot(trainer.model)
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+        self._assert_any_trainable_param_changed(trainer.model, previous_trainable_params)
+
+    def test_train_populates_old_log_probs_for_distillation_clipping_when_misaligned(self):
+        dataset = Dataset.from_dict(
+            {
+                "prompt": ["Solve 2+2.", "Solve 3+3."],
+                "privileged_context": [
+                    "Example answer: 4.",
+                    "Example answer: 6.",
+                ],
+            }
+        )
+
+        training_args = SDFTConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            gradient_accumulation_steps=3,
+            steps_per_generation=2,
+            max_completion_length=8,
+            max_steps=1,
+            num_generations=1,
+            report_to="none",
+        )
+
+        capture_callback = SelfDistillationCaptureCallback()
+        trainer = SDFTTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+            callbacks=[capture_callback],
+        )
+
+        trainer.train()
+
+        assert capture_callback.captured_old_per_token_logps is not None
+
+    def test_train_with_generate_from_teacher_skips_old_log_probs_for_distillation_clipping(self):
+        dataset = Dataset.from_dict(
+            {
+                "prompt": ["Solve 2+2.", "Solve 3+3."],
+                "privileged_context": [
+                    "Teacher hint: answer with 4.",
+                    "Teacher hint: answer with 6.",
+                ],
+            }
+        )
+
+        training_args = SDFTConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            gradient_accumulation_steps=3,
+            steps_per_generation=2,
+            max_completion_length=8,
+            max_steps=1,
+            num_generations=1,
+            generate_from_teacher=True,
+            report_to="none",
+        )
+
+        capture_callback = SelfDistillationCaptureCallback()
+        trainer = SDFTTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+            callbacks=[capture_callback],
+        )
+
+        trainer.train()
+
+        assert capture_callback.captured_old_per_token_logps is None
+
+    def test_train_reuses_buffered_generation_batches(self):
+        dataset = Dataset.from_dict(
+            {
+                "prompt": ["Solve 2+2.", "Solve 3+3."],
+                "privileged_context": [
+                    "Example answer: 4.",
+                    "Example answer: 6.",
+                ],
+            }
+        )
+
+        training_args = SDFTConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            steps_per_generation=2,
+            max_completion_length=8,
+            max_steps=2,
+            num_generations=1,
+            report_to="none",
+        )
+
+        capture_callback = SelfDistillationCaptureCallback()
+        trainer = SDFTTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+            callbacks=[capture_callback],
+        )
+
+        trainer.train()
+
+        assert capture_callback.generation_batch_build_count == 1
+
+    def test_server_loss_finite_with_masked_and_padded_rows(self):
+        # Drives the teacher-server path through `compute_loss` with a fake server client: row 0 is fully masked
+        # (zero-length scored completion) and row 1 has a shorter completion than the padded batch, so the client
+        # response is ragged and the padded tail comes back as -inf. Neither may leak NaN or inf.
+        dataset = Dataset.from_dict({"prompt": ["Solve 2+2."], "privileged_context": ["Example answer: 4."]})
+        training_args = SDFTConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=1,
+            max_completion_length=3,
+            num_generations=1,
+            distillation_mode="topk_logits",
+            distillation_topk=2,
+            distillation_alpha=0.5,
+            distillation_add_tail=True,
+            distillation_is_clip=None,
+            report_to="none",
+        )
+        trainer = SDFTTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+        trainer.use_teacher_server = True
+        trainer.teacher_client = RecordingTeacherClient(
+            {
+                "actual_logprobs": [[], [[-1.1], [-0.4]]],
+                "logprobs": [[], [[-1.1, -1.5], [-0.4, -0.9]]],
+                "logprob_token_ids": [[], [[14, 15], [16, 17]]],
+            }
+        )
+
+        device = next(trainer.model.parameters()).device
+        batch = {
+            "prompt_ids": torch.tensor([[10, 11], [12, 13]], device=device),
+            "prompt_mask": torch.tensor([[1, 1], [1, 1]], device=device),
+            "completion_ids": torch.tensor([[14, 15, 16], [17, 18, 19]], device=device),
+            "completion_mask": torch.tensor([[0, 0, 0], [1, 1, 0]], device=device),
+            "teacher_input_ids": torch.tensor([[20, 21, 22, 14, 15, 16], [23, 24, 25, 17, 18, 19]], device=device),
+            "teacher_attention_mask": torch.tensor([[1, 1, 1, 0, 0, 0], [1, 1, 1, 1, 1, 0]], device=device),
+        }
+
+        loss = trainer.compute_loss(trainer.model, batch)
+
+        assert torch.isfinite(loss)
+        loss.backward()
+        assert all(torch.isfinite(p.grad).all() for p in trainer.model.parameters() if p.grad is not None)
+        assert trainer.teacher_client.calls[0]["top_logprobs"] == 2

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_sdpo_trainer.py

@@ -0,0 +1,582 @@
+# 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 pytest
+import torch
+from datasets import Dataset, load_dataset
+from transformers import TrainerCallback
+
+from trl.experimental.sdpo import SDPOConfig, SDPOTrainer
+
+from ..testing_utils import TrlTestCase, require_liger_kernel, require_torch_accelerator
+
+
+class SelfDistillationCaptureCallback(TrainerCallback):
+    def __init__(self):
+        self.captured_teacher_input_text = None
+        self.captured_teacher_input_texts = []
+        self.captured_self_distillation_mask = None
+        self.captured_teacher_attention_mask = None
+        self.captured_completion_mask = None
+        self.captured_old_per_token_logps = None
+
+    def on_teacher_context_built(
+        self,
+        processing_class=None,
+        teacher_input_ids=None,
+        teacher_attention_mask=None,
+        completion_mask=None,
+        self_distillation_mask=None,
+        **kwargs,
+    ):
+        if self.captured_teacher_input_text is None and teacher_input_ids is not None:
+            self.captured_teacher_input_text = processing_class.decode(teacher_input_ids[0], skip_special_tokens=True)
+        if teacher_input_ids is not None:
+            self.captured_teacher_input_texts.extend(
+                processing_class.decode(ids, skip_special_tokens=True) for ids in teacher_input_ids
+            )
+        if self.captured_teacher_attention_mask is None and teacher_attention_mask is not None:
+            self.captured_teacher_attention_mask = teacher_attention_mask.detach().cpu()
+        if self.captured_completion_mask is None and completion_mask is not None:
+            self.captured_completion_mask = completion_mask.detach().cpu()
+        if self.captured_self_distillation_mask is None and self_distillation_mask is not None:
+            self.captured_self_distillation_mask = self_distillation_mask.detach().cpu()
+
+    def on_self_distillation_batch_prepared(self, old_per_token_logps=None, **kwargs):
+        if self.captured_old_per_token_logps is None and old_per_token_logps is not None:
+            self.captured_old_per_token_logps = old_per_token_logps.detach().cpu()
+
+
+class RecordingTeacherClient:
+    """Stands in for the vLLM server client and records scoring requests."""
+
+    def __init__(self, response):
+        self.response = response
+        self.calls = []
+
+    def get_sequence_logprobs(self, **kwargs):
+        self.calls.append(kwargs)
+        return self.response
+
+
+class TestSDPOTrainer(TrlTestCase):
+    def test_trust_remote_code(self):
+        dataset = Dataset.from_dict(
+            {
+                "prompt": ["Solve 2+2.", "Name the capital of France."],
+                "privileged_context": ["Example answer: 4.", "Example answer: Paris."],
+            }
+        )
+        model_id = "trl-internal-testing/tiny-RemoteForCausalLM"
+
+        with pytest.raises(ValueError, match="custom code"):
+            SDPOTrainer(
+                model=model_id,
+                reward_funcs=lambda **kwargs: [0.0] * len(kwargs["prompts"]),
+                args=SDPOConfig(output_dir=self.tmp_dir, report_to="none"),
+                train_dataset=dataset,
+            )
+
+        trainer = SDPOTrainer(
+            model=model_id,
+            reward_funcs=lambda **kwargs: [0.0] * len(kwargs["prompts"]),
+            args=SDPOConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True),
+            train_dataset=dataset,
+        )
+        assert type(trainer.model).__name__ == "RemoteForCausalLM"
+
+    def test_train_with_positional_config_argument(self):
+        dataset = Dataset.from_dict(
+            {
+                "prompt": ["Solve 2+2."],
+                "privileged_context": ["Your earlier answer used the wrong format."],
+            }
+        )
+
+        training_args = SDPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            generation_batch_size=2,
+            num_generations=2,
+            max_completion_length=8,
+            include_environment_feedback=True,
+            max_steps=1,
+            report_to="none",
+        )
+
+        trainer = SDPOTrainer(
+            "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            lambda **kwargs: [0.0] * len(kwargs["prompts"]),
+            training_args,
+            dataset,
+        )
+
+        trainer.train()
+
+        assert trainer.args.output_dir == self.tmp_dir
+        assert trainer.args.include_environment_feedback is True
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    def test_vllm_config_defaults_match_reference_trainers(self):
+        config = SDPOConfig(output_dir=self.tmp_dir)
+
+        assert config.vllm_mode == "colocate"
+        assert config.vllm_model_impl == "vllm"
+
+    def test_train(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = SDPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            distillation_mode="topk_logits",
+            distillation_topk=5,
+            distillation_is_clip=None,
+            report_to="none",
+        )
+        trainer = SDPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if param.sum() != 0:
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @require_liger_kernel
+    @require_torch_accelerator
+    def test_liger_loss_matches_non_liger_loss(self):
+        dataset = Dataset.from_dict({"prompt": ["Solve 2+2."]})
+        common = dict(
+            output_dir=self.tmp_dir,
+            report_to="none",
+            per_device_train_batch_size=1,
+            generation_batch_size=2,
+            num_generations=2,
+            max_completion_length=3,
+            distillation_mode="full_logits",
+            distillation_is_clip=None,
+            distillation_weight=1.0,
+        )
+
+        ref_trainer = SDPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=lambda **kwargs: [0.0] * len(kwargs["prompts"]),
+            args=SDPOConfig(use_liger_kernel=False, **common),
+            train_dataset=dataset,
+        )
+        liger_trainer = SDPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=lambda **kwargs: [0.0] * len(kwargs["prompts"]),
+            args=SDPOConfig(use_liger_kernel=True, **common),
+            train_dataset=dataset,
+        )
+
+        liger_trainer.model.load_state_dict(ref_trainer.model.state_dict())
+        torch.manual_seed(0)
+        with torch.no_grad():
+            for param in ref_trainer.teacher_model.parameters():
+                param.add_(0.5 * torch.randn_like(param))
+        liger_trainer.teacher_model.load_state_dict(ref_trainer.teacher_model.state_dict())
+
+        device = next(ref_trainer.model.parameters()).device
+        batch = {
+            "prompt_ids": torch.tensor([[10, 11], [12, 13]], device=device),
+            "prompt_mask": torch.tensor([[1, 1], [1, 1]], device=device),
+            "completion_ids": torch.tensor([[14, 15, 16], [17, 18, 19]], device=device),
+            "completion_mask": torch.tensor([[1, 1, 0], [1, 1, 1]], device=device),
+            "teacher_input_ids": torch.tensor([[20, 21, 22, 14, 15, 16], [23, 24, 25, 17, 18, 19]], device=device),
+            "teacher_attention_mask": torch.tensor([[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1]], device=device),
+            "self_distillation_mask": torch.tensor([1.0, 0.0], device=device),
+        }
+
+        ref_trainer.model.eval()
+        liger_trainer.model.eval()
+        with torch.no_grad():
+            ref_loss = ref_trainer.compute_loss(ref_trainer.model, batch).item()
+            liger_loss = liger_trainer.compute_loss(liger_trainer.model, batch).item()
+
+        torch.testing.assert_close(
+            torch.tensor(liger_loss),
+            torch.tensor(ref_loss),
+            rtol=2e-2,
+            atol=1e-6,
+        )
+
+    def test_train_without_successful_rollouts(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = SDPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            distillation_is_clip=None,
+            report_to="none",
+        )
+
+        def zero_reward(**kwargs):
+            prompts = kwargs["prompts"]
+            return [0.0] * len(prompts)
+
+        trainer = SDPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=zero_reward,
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    def test_train_populates_old_log_probs_for_distillation_clipping_when_misaligned(self):
+        dataset = Dataset.from_dict({"prompt": ["Solve 2+2.", "Solve 3+3."]})
+
+        training_args = SDPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            gradient_accumulation_steps=3,
+            steps_per_generation=2,
+            num_generations=2,
+            max_completion_length=8,
+            max_steps=1,
+            report_to="none",
+        )
+
+        capture_callback = SelfDistillationCaptureCallback()
+        trainer = SDPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=lambda **kwargs: [0.0] * len(kwargs["prompts"]),
+            args=training_args,
+            train_dataset=dataset,
+            callbacks=[capture_callback],
+        )
+
+        trainer.train()
+
+        assert capture_callback.captured_old_per_token_logps is not None
+
+    def test_evaluation_uses_num_generations_eval_for_teacher_grouping(self):
+        eval_dataset = Dataset.from_dict({"prompt": ["Alpha prompt", "Beta prompt", "Gamma prompt", "Delta prompt"]})
+
+        training_args = SDPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            per_device_eval_batch_size=4,
+            generation_batch_size=3,
+            num_generations=3,
+            num_generations_eval=2,
+            max_completion_length=8,
+            success_reward_threshold=0.5,
+            dont_reprompt_on_self_success=False,
+            distillation_is_clip=None,
+            max_steps=1,
+            report_to="none",
+        )
+
+        def eval_rewards(**kwargs):
+            prompts = kwargs["prompts"]
+            if len(prompts) == 4 and prompts.count("Alpha prompt") == 2 and prompts.count("Beta prompt") == 2:
+                return [1.0, 0.0, 0.0, 0.0]
+            return [0.0] * len(prompts)
+
+        capture_callback = SelfDistillationCaptureCallback()
+        trainer = SDPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=eval_rewards,
+            args=training_args,
+            train_dataset=eval_dataset.select(range(1)),
+            eval_dataset=eval_dataset,
+            callbacks=[capture_callback],
+        )
+
+        trainer.evaluate()
+
+        assert capture_callback.captured_teacher_input_texts
+        alpha_teachers = [text for text in capture_callback.captured_teacher_input_texts if "Alpha prompt" in text]
+        beta_teachers = [text for text in capture_callback.captured_teacher_input_texts if "Beta prompt" in text]
+        assert alpha_teachers
+        assert beta_teachers
+        assert any("Correct solution:" in text for text in alpha_teachers)
+        assert all("Correct solution:" not in text for text in beta_teachers)
+
+    def test_teacher_reprompt_preserves_curly_braces_in_solution_and_feedback(self):
+        dataset = Dataset.from_dict(
+            {
+                "prompt": ["Solve f(x) = {x^2}."],
+                "privileged_context": ['Feedback: use {"x": 2} as a check.'],
+            }
+        )
+
+        training_args = SDPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            generation_batch_size=2,
+            num_generations=2,
+            max_completion_length=8,
+            include_environment_feedback=True,
+            success_reward_threshold=0.5,
+            dont_reprompt_on_self_success=False,
+            max_steps=1,
+            report_to="none",
+        )
+
+        def reward_with_one_success(**kwargs):
+            prompts = kwargs["prompts"]
+            return [1.0, 0.0][: len(prompts)]
+
+        capture_callback = SelfDistillationCaptureCallback()
+        trainer = SDPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=reward_with_one_success,
+            args=training_args,
+            train_dataset=dataset,
+            callbacks=[capture_callback],
+        )
+
+        trainer.train()
+
+        assert capture_callback.captured_teacher_input_text is not None
+        assert "Solve f(x) = {x^2}." in capture_callback.captured_teacher_input_text
+        assert 'Feedback: use {"x": 2} as a check.' in capture_callback.captured_teacher_input_text
+        assert "{{" not in capture_callback.captured_teacher_input_text
+        assert "}}" not in capture_callback.captured_teacher_input_text
+
+    def test_train_with_conversational_prompts_preserves_context(self):
+        dataset = Dataset.from_dict(
+            {
+                "prompt": [
+                    [
+                        {"role": "system", "content": "You are a careful assistant."},
+                        {"role": "user", "content": "Solve 2+2."},
+                    ]
+                ]
+            }
+        )
+
+        training_args = SDPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            generation_batch_size=2,
+            num_generations=2,
+            max_completion_length=8,
+            distillation_is_clip=None,
+            success_reward_threshold=0.5,
+            max_steps=1,
+            report_to="none",
+        )
+
+        def first_only_reward(**kwargs):
+            """Only the first sample in each group succeeds — exercises dont_reprompt_on_self_success default."""
+            return [1.0, 0.0][: len(kwargs["prompts"])]
+
+        capture_callback = SelfDistillationCaptureCallback()
+        trainer = SDPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=first_only_reward,
+            args=training_args,
+            train_dataset=dataset,
+            callbacks=[capture_callback],
+        )
+
+        trainer.train()
+
+        # With dont_reprompt_on_self_success=True (default), sample 0 skips itself,
+        # but sample 1 finds sample 0's success and gets a teacher reprompt.
+        assert capture_callback.captured_teacher_input_text is not None
+        assert "careful assistant" in capture_callback.captured_teacher_input_text
+        assert "Solve 2+2" in capture_callback.captured_teacher_input_text
+        assert capture_callback.captured_self_distillation_mask is not None
+
+    def test_train_with_feedback_only_reprompts_teacher(self):
+        dataset = Dataset.from_dict(
+            {
+                "prompt": [
+                    [
+                        {"role": "system", "content": "You are a careful assistant."},
+                        {"role": "user", "content": "Try the puzzle again."},
+                    ]
+                ],
+                "privileged_context": ["Your earlier answer violated the format requirements."],
+            }
+        )
+
+        training_args = SDPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            generation_batch_size=2,
+            num_generations=2,
+            max_completion_length=8,
+            distillation_is_clip=None,
+            include_environment_feedback=True,
+            max_steps=1,
+            report_to="none",
+        )
+
+        def zero_reward(**kwargs):
+            prompts = kwargs["prompts"]
+            return [0.0] * len(prompts)
+
+        capture_callback = SelfDistillationCaptureCallback()
+        trainer = SDPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=zero_reward,
+            args=training_args,
+            train_dataset=dataset,
+            callbacks=[capture_callback],
+        )
+
+        trainer.train()
+
+        assert capture_callback.captured_teacher_input_text is not None
+        assert "format requirements" in capture_callback.captured_teacher_input_text
+        assert capture_callback.captured_self_distillation_mask is not None
+        assert capture_callback.captured_self_distillation_mask[0].item() == 1.0
+
+    def test_train_warns_when_sdpo_rewards_are_flat(self, caplog):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = SDPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            diagnostics_warning_interval=2,
+            max_steps=2,
+            report_to="none",
+        )
+
+        def zero_reward(**kwargs):
+            return [0.0] * len(kwargs["prompts"])
+
+        trainer = SDPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=zero_reward,
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        with caplog.at_level(logging.WARNING):
+            trainer.train()
+
+        assert "Observed flat SDPO rewards across all sampled generations" in caplog.text
+        assert "SDPO self-distillation is inactive because no reprompted samples were constructed" in caplog.text
+
+    def test_train_preserves_teacher_completion_attention_mask(self):
+        dataset = Dataset.from_dict({"prompt": ["Solve 2+2."]})
+
+        training_args = SDPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            generation_batch_size=2,
+            num_generations=2,
+            max_completion_length=8,
+            success_reward_threshold=0.5,
+            max_steps=1,
+            report_to="none",
+        )
+
+        def first_only_reward(**kwargs):
+            return [1.0, 0.0][: len(kwargs["prompts"])]
+
+        capture_callback = SelfDistillationCaptureCallback()
+        trainer = SDPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=first_only_reward,
+            args=training_args,
+            train_dataset=dataset,
+            callbacks=[capture_callback],
+        )
+
+        trainer.train()
+
+        assert capture_callback.captured_teacher_attention_mask is not None
+        assert capture_callback.captured_completion_mask is not None
+
+        completion_length = capture_callback.captured_completion_mask.shape[1]
+        teacher_completion_attention = capture_callback.captured_teacher_attention_mask[0, -completion_length:]
+        assert torch.equal(teacher_completion_attention, capture_callback.captured_completion_mask[0])
+
+    def test_server_loss_finite_with_masked_and_padded_rows(self):
+        # Drives the teacher-server path through `compute_loss` with a fake server client: row 0 is fully masked
+        # (zero-length scored completion) and row 1 has a shorter completion than the padded batch, so the client
+        # response is ragged and the padded tail comes back as -inf. Neither may leak NaN or inf.
+        dataset = Dataset.from_dict({"prompt": ["Solve 2+2."], "privileged_context": ["Example answer: 4."]})
+        training_args = SDPOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=1,
+            max_completion_length=3,
+            num_generations=1,
+            distillation_mode="topk_logits",
+            distillation_topk=2,
+            distillation_alpha=0.5,
+            distillation_add_tail=True,
+            distillation_is_clip=None,
+            report_to="none",
+        )
+        trainer = SDPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=lambda **kwargs: [0.0] * len(kwargs["prompts"]),
+            args=training_args,
+            train_dataset=dataset,
+        )
+        trainer.use_teacher_server = True
+        trainer.teacher_client = RecordingTeacherClient(
+            {
+                "actual_logprobs": [[], [[-1.1], [-0.4]]],
+                "logprobs": [[], [[-1.1, -1.5], [-0.4, -0.9]]],
+                "logprob_token_ids": [[], [[14, 15], [16, 17]]],
+            }
+        )
+
+        device = next(trainer.model.parameters()).device
+        batch = {
+            "prompt_ids": torch.tensor([[10, 11], [12, 13]], device=device),
+            "prompt_mask": torch.tensor([[1, 1], [1, 1]], device=device),
+            "completion_ids": torch.tensor([[14, 15, 16], [17, 18, 19]], device=device),
+            "completion_mask": torch.tensor([[0, 0, 0], [1, 1, 0]], device=device),
+            "teacher_input_ids": torch.tensor([[20, 21, 22, 14, 15, 16], [23, 24, 25, 17, 18, 19]], device=device),
+            "teacher_attention_mask": torch.tensor([[1, 1, 1, 0, 0, 0], [1, 1, 1, 1, 1, 0]], device=device),
+        }
+
+        loss = trainer.compute_loss(trainer.model, batch)
+
+        assert torch.isfinite(loss)
+        loss.backward()
+        assert all(torch.isfinite(p.grad).all() for p in trainer.model.parameters() if p.grad is not None)
+        assert trainer.teacher_client.calls[0]["top_logprobs"] == 2

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_self_distillation_trainer_behavior.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 logging
+from collections import defaultdict
+from types import SimpleNamespace
+
+import pytest
+import torch
+from datasets import Dataset
+from transformers import AutoModelForCausalLM, TrainerControl, TrainerState, TrainingArguments
+from transformers.utils import is_peft_available
+
+from trl.experimental.sdft import SDFTConfig, SDFTTrainer
+from trl.experimental.sdft.loss_utils import (
+    apply_importance_sampling_clipping,
+    compute_full_logit_self_distillation_loss,
+    compute_sampled_token_self_distillation_loss,
+    compute_topk_self_distillation_loss,
+)
+
+from ..testing_utils import TrlTestCase
+
+
+if is_peft_available():
+    from peft import LoraConfig, get_peft_model, get_peft_model_state_dict
+
+    from trl.experimental.sdft.teacher_sync import PEFTAdapterEMACallback
+
+
+class TestSelfDistillationTrainerBehavior(TrlTestCase):
+    @staticmethod
+    def _make_loss_test_trainer(**args_overrides):
+        trainer = object.__new__(SDFTTrainer)
+        args = {
+            "distillation_mode": "sampled_token",
+            "distillation_topk": None,
+            "distillation_alpha": 1.0,
+            "distillation_add_tail": False,
+            "distillation_is_clip": None,
+        }
+        args.update(args_overrides)
+        trainer.args = SimpleNamespace(**args)
+        trainer.accelerator = SimpleNamespace(gather=lambda tensor: tensor)
+        trainer._metrics = {
+            "train": defaultdict(list),
+            "eval": defaultdict(list),
+        }
+        trainer._name = "SDFT"
+        return trainer
+
+    def test_full_logit_loss_matches_forward_kl(self):
+        student_probs = torch.tensor([[[0.8, 0.2]]], dtype=torch.float32)
+        teacher_probs = torch.tensor([[[0.5, 0.5]]], dtype=torch.float32)
+
+        loss = compute_full_logit_self_distillation_loss(
+            student_probs.log(),
+            teacher_probs.log(),
+            distillation_alpha=0.0,
+        )
+
+        expected_loss = teacher_probs[0, 0, 0] * (
+            teacher_probs[0, 0, 0].log() - student_probs[0, 0, 0].log()
+        ) + teacher_probs[0, 0, 1] * (teacher_probs[0, 0, 1].log() - student_probs[0, 0, 1].log())
+        torch.testing.assert_close(loss, expected_loss.reshape(1, 1))
+
+    def test_sampled_token_loss_uses_selected_completion_ids(self):
+        student_probs = torch.tensor([[[0.1, 0.9], [0.7, 0.3]]], dtype=torch.float32)
+        teacher_probs = torch.tensor([[[0.4, 0.6], [0.2, 0.8]]], dtype=torch.float32)
+        completion_ids = torch.tensor([[1, 0]])
+
+        loss = compute_sampled_token_self_distillation_loss(
+            student_probs.log(),
+            teacher_probs.log(),
+            completion_ids,
+            distillation_alpha=1.0,
+        )
+
+        expected_student_logps = torch.tensor([[0.9, 0.7]], dtype=torch.float32).log()
+        expected_teacher_logps = torch.tensor([[0.6, 0.2]], dtype=torch.float32).log()
+        expected_loss = (expected_student_logps - expected_teacher_logps) * expected_student_logps
+        torch.testing.assert_close(loss, expected_loss)
+
+    def test_topk_loss_renormalizes_selected_student_support(self):
+        student_probs = torch.tensor([[[0.5, 0.3, 0.2]]], dtype=torch.float32)
+        teacher_probs = torch.tensor([[[0.2, 0.6, 0.2]]], dtype=torch.float32)
+
+        loss = compute_topk_self_distillation_loss(
+            student_probs.log(),
+            teacher_probs.log(),
+            distillation_topk=2,
+            distillation_alpha=0.0,
+            distillation_add_tail=False,
+        )
+
+        student_topk = torch.tensor([0.5, 0.3], dtype=torch.float32)
+        student_topk = student_topk / student_topk.sum()
+        teacher_topk = torch.tensor([0.2, 0.6], dtype=torch.float32)
+        teacher_topk = teacher_topk / teacher_topk.sum()
+        expected_loss = (teacher_topk * (teacher_topk.log() - student_topk.log())).sum()
+        torch.testing.assert_close(loss, expected_loss.reshape(1, 1))
+
+    def test_topk_loss_can_include_tail_bucket(self):
+        student_probs = torch.tensor([[[0.5, 0.3, 0.2]]], dtype=torch.float32)
+        teacher_probs = torch.tensor([[[0.2, 0.6, 0.2]]], dtype=torch.float32)
+
+        loss = compute_topk_self_distillation_loss(
+            student_probs.log(),
+            teacher_probs.log(),
+            distillation_topk=2,
+            distillation_alpha=0.0,
+            distillation_add_tail=True,
+        )
+
+        student_with_tail = torch.tensor([0.5, 0.3, 0.2], dtype=torch.float32)
+        teacher_with_tail = torch.tensor([0.2, 0.6, 0.2], dtype=torch.float32)
+        expected_loss = (teacher_with_tail * (teacher_with_tail.log() - student_with_tail.log())).sum()
+        torch.testing.assert_close(loss, expected_loss.reshape(1, 1))
+
+    def test_importance_sampling_clipping_caps_token_ratio(self):
+        per_token_loss = torch.tensor([[1.0, 2.0]])
+        student_log_probs = torch.tensor([[0.4, 0.3]], dtype=torch.float32).log()
+        old_log_probs = torch.tensor([[0.1, 0.2]], dtype=torch.float32).log()
+
+        loss = apply_importance_sampling_clipping(
+            per_token_loss,
+            student_log_probs,
+            old_log_probs,
+            clip_coeff=2.0,
+        )
+
+        torch.testing.assert_close(loss, torch.tensor([[2.0, 3.0]]))
+
+    def test_teacher_model_kind_live_uses_student_model(self):
+        dataset = Dataset.from_dict({"prompt": ["Solve 2+2."]})
+        training_args = SDFTConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=1,
+            max_completion_length=8,
+            max_steps=1,
+            num_generations=1,
+            teacher_model_kind="live",
+            report_to="none",
+        )
+
+        trainer = SDFTTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        assert trainer.teacher_model is trainer.model
+
+    @pytest.mark.skipif(not is_peft_available(), reason="PEFT is required for this test")
+    def test_warns_when_initial_student_already_has_a_peft_adapter(self, caplog):
+        dataset = Dataset.from_dict({"prompt": ["Solve 2+2."]})
+        training_args = SDFTConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=1,
+            max_completion_length=8,
+            max_steps=1,
+            num_generations=1,
+            teacher_model_kind="base",
+            report_to="none",
+        )
+        model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5")
+        model = get_peft_model(
+            model,
+            LoraConfig(
+                r=4,
+                lora_alpha=8,
+                target_modules=["q_proj", "v_proj"],
+                bias="none",
+                task_type="CAUSAL_LM",
+            ),
+        )
+
+        with caplog.at_level(logging.WARNING, logger="trl.experimental.sdft.sdft_trainer"):
+            SDFTTrainer(
+                model=model,
+                args=training_args,
+                train_dataset=dataset,
+            )
+
+        assert "already contains a PEFT adapter" in caplog.text
+        assert "`teacher_model_kind='base'` may refer to the underlying base weights" in caplog.text
+
+    @pytest.mark.skipif(not is_peft_available(), reason="PEFT is required for this test")
+    def test_peft_adapter_ema_callback_updates_teacher_adapter(self):
+        model = AutoModelForCausalLM.from_pretrained(
+            "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            device_map="cpu",
+        )
+        model = get_peft_model(
+            model,
+            LoraConfig(
+                task_type="CAUSAL_LM",
+                target_modules=["q_proj", "v_proj"],
+                r=8,
+            ),
+            adapter_name="default",
+        )
+
+        update_rate = 0.5
+        callback = PEFTAdapterEMACallback(
+            model=model,
+            teacher_adapter_name="teacher",
+            update_rate=update_rate,
+            sync_steps=1,
+        )
+        args = TrainingArguments(output_dir=self.tmp_dir, report_to="none")
+        state = TrainerState(global_step=0)
+        control = TrainerControl()
+
+        callback.on_train_begin(args, state, control)
+
+        assert "teacher" in model.peft_config
+        assert callback.shadow_weights is not None
+        teacher_state = get_peft_model_state_dict(model, adapter_name="teacher")
+        for key, param in teacher_state.items():
+            assert torch.all(param == 0), f"Teacher param {key} should be zero-initialized"
+
+        student_state = {
+            key: value.clone() for key, value in get_peft_model_state_dict(model, adapter_name="default").items()
+        }
+        assert set(callback.shadow_weights.keys()) == set(student_state.keys())
+
+        state.global_step = 1
+        callback.on_step_end(args, state, control)
+
+        for key in callback.shadow_weights:
+            expected = update_rate * student_state[key]
+            torch.testing.assert_close(callback.shadow_weights[key], expected)
+
+        teacher_state = get_peft_model_state_dict(model, adapter_name="teacher")
+        for key in teacher_state:
+            torch.testing.assert_close(teacher_state[key].float(), callback.shadow_weights[key])
+
+    @pytest.mark.parametrize("teacher_model_kind", ["base", "ema"])
+    def test_teacher_model_kind_base_and_ema_use_frozen_teacher_copy(self, teacher_model_kind):
+        dataset = Dataset.from_dict({"prompt": ["Solve 2+2."]})
+        training_args = SDFTConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=1,
+            max_completion_length=8,
+            max_steps=1,
+            num_generations=1,
+            teacher_model_kind=teacher_model_kind,
+            report_to="none",
+        )
+
+        trainer = SDFTTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        assert trainer.teacher_model is not trainer.model
+        assert trainer.teacher_model.training is False
+
+        student_param = next(trainer.model.parameters())
+        teacher_param = next(trainer.teacher_model.parameters())
+        assert teacher_param.requires_grad is False
+        assert teacher_param.data_ptr() != student_param.data_ptr()
+
+    def test_compute_self_distillation_loss_ignores_masked_completion_tokens(self):
+        trainer = self._make_loss_test_trainer(
+            distillation_mode="full_logits",
+            distillation_alpha=0.0,
+        )
+        model = SimpleNamespace(training=True)
+
+        student_probs = torch.tensor([[[0.8, 0.2], [0.01, 0.99]]], dtype=torch.float32)
+        teacher_probs = torch.tensor([[[0.5, 0.5], [0.99, 0.01]]], dtype=torch.float32)
+        distillation_logits = SimpleNamespace(
+            completion_ids=torch.tensor([[0, 1]], dtype=torch.long),
+            loss_mask=torch.tensor([[1, 0]], dtype=torch.long),
+            student_logits=student_probs.log(),
+            teacher_logits=teacher_probs.log(),
+        )
+
+        loss = trainer._compute_self_distillation_loss(model, {}, distillation_logits)
+
+        expected_active_token_loss = teacher_probs[0, 0, 0] * (
+            teacher_probs[0, 0, 0].log() - student_probs[0, 0, 0].log()
+        ) + teacher_probs[0, 0, 1] * (teacher_probs[0, 0, 1].log() - student_probs[0, 0, 1].log())
+        torch.testing.assert_close(loss, expected_active_token_loss)
+        torch.testing.assert_close(
+            torch.tensor(trainer._metrics["train"]["self_distillation/distillation_loss"]),
+            expected_active_token_loss.unsqueeze(0),
+        )
+
+    def test_compute_self_distillation_loss_applies_importance_sampling_clip(self):
+        trainer = self._make_loss_test_trainer(distillation_is_clip=2.0)
+        model = SimpleNamespace(training=True)
+
+        student_token_probs = torch.tensor([[0.2, 0.4]], dtype=torch.float32)
+        teacher_token_probs = torch.tensor([[0.5, 0.5]], dtype=torch.float32)
+        old_token_probs = torch.tensor([[0.05, 0.4]], dtype=torch.float32)
+        clip_coeff = trainer.args.distillation_is_clip
+
+        distillation_logits = SimpleNamespace(
+            completion_ids=torch.tensor([[0, 1]], dtype=torch.long),
+            loss_mask=torch.tensor([[1, 1]], dtype=torch.long),
+            student_logits=torch.log(torch.tensor([[[0.2, 0.8], [0.6, 0.4]]], dtype=torch.float32)),
+            teacher_logits=torch.log(torch.tensor([[[0.5, 0.5], [0.5, 0.5]]], dtype=torch.float32)),
+        )
+
+        loss = trainer._compute_self_distillation_loss(
+            model,
+            {"old_per_token_logps": old_token_probs.log()},
+            distillation_logits,
+        )
+
+        raw_per_token_loss = (student_token_probs.log() - teacher_token_probs.log()) * student_token_probs.log()
+        clipped_ratio = torch.minimum(
+            student_token_probs / old_token_probs, torch.full_like(student_token_probs, clip_coeff)
+        )
+        expected_loss = (raw_per_token_loss * clipped_ratio).mean()
+
+        torch.testing.assert_close(loss, expected_loss)
+        torch.testing.assert_close(
+            torch.tensor(trainer._metrics["train"]["self_distillation/distillation_loss"]),
+            expected_loss.unsqueeze(0),
+        )

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_ssd_trainer.py

@@ -0,0 +1,237 @@
+# 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 pytest
+from datasets import load_dataset
+from transformers.utils import is_peft_available
+
+from trl.experimental.ssd import SSDConfig, SSDTrainer
+
+from ..testing_utils import TrlTestCase, require_peft
+
+
+if is_peft_available():
+    from peft import LoraConfig
+
+
+class TestSSDTrainer(TrlTestCase):
+    def test_vllm_config_defaults_match_reference_trainers(self):
+        config = SSDConfig(output_dir=self.tmp_dir)
+
+        assert config.vllm_mode == "colocate"
+        assert config.vllm_model_impl == "vllm"
+
+    def test_train_with_string_prompts(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = SSDConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            max_completion_length=8,
+            max_steps=1,
+        )
+
+        trainer = SSDTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    def test_trust_remote_code(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+        model_id = "trl-internal-testing/tiny-RemoteForCausalLM"
+
+        with pytest.raises(ValueError, match="custom code"):
+            SSDTrainer(
+                model=model_id,
+                args=SSDConfig(output_dir=self.tmp_dir, report_to="none"),
+                train_dataset=dataset,
+            )
+
+        trainer = SSDTrainer(
+            model=model_id,
+            args=SSDConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True),
+            train_dataset=dataset,
+        )
+        assert type(trainer.model).__name__ == "RemoteForCausalLM"
+
+    def test_train_with_chat_prompts(self):
+        dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_only", split="train")
+
+        training_args = SSDConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            max_completion_length=8,
+            max_steps=1,
+        )
+
+        trainer = SSDTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    def test_train_with_temperature_and_truncation(self):
+        """Test with SSD-paper-style hyperparameters: T_train=0.6, top_k=20, top_p=0.95."""
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = SSDConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=5e-6,
+            per_device_train_batch_size=1,
+            max_completion_length=16,
+            max_steps=1,
+            temperature=0.6,
+            top_k=20,
+            top_p=0.95,
+        )
+
+        trainer = SSDTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    def test_train_reuses_buffered_generation_batches(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = SSDConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            steps_per_generation=2,
+            max_completion_length=8,
+            max_steps=2,
+        )
+
+        trainer = SSDTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    def test_train_with_filter_empty_disabled(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = SSDConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            max_completion_length=8,
+            max_steps=1,
+            filter_empty=False,
+        )
+
+        trainer = SSDTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    def test_train_logs_ssd_metrics(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = SSDConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            max_completion_length=8,
+            max_steps=1,
+            logging_steps=1,
+            report_to="none",
+        )
+
+        trainer = SSDTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        trainer.train()
+
+        # The log() override merges _metrics into log_history and clears the buffer.
+        last_log = trainer.state.log_history[-2]
+        assert "ssd/cross_entropy_loss" in last_log
+        assert "ssd/active_sample_ratio" in last_log
+        assert "completions/mean_length" in last_log
+
+    @require_peft
+    def test_train_with_peft_model(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = SSDConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            max_completion_length=8,
+            max_steps=1,
+        )
+
+        trainer = SSDTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+            peft_config=LoraConfig(
+                task_type="CAUSAL_LM",
+                target_modules=["q_proj", "v_proj"],
+            ),
+        )
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    def test_train_with_disable_dropout_false(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = SSDConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            per_device_train_batch_size=1,
+            max_completion_length=8,
+            max_steps=1,
+            disable_dropout=False,
+        )
+
+        trainer = SSDTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_tpo_trainer.py

@@ -0,0 +1,332 @@
+# 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 pytest
+import torch
+from datasets import load_dataset
+from transformers.utils import is_peft_available
+
+from trl.experimental.tpo import TPOConfig, TPOTrainer
+from trl.experimental.tpo.tpo_trainer import DataCollatorForTriplePreference
+
+from ..testing_utils import TrlTestCase, require_peft
+
+
+if is_peft_available():
+    from peft import LoraConfig
+
+
+def _add_reference_column(example):
+    """Synthesize a `reference` (gold) completion for tests by reusing the chosen completion."""
+    example["reference"] = example["chosen"]
+    return example
+
+
+class TestDataCollatorForTriplePreference(TrlTestCase):
+    def test_padding_and_masks(self):
+        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]},
+        ]
+        result = collator(examples)
+
+        expected_input_ids = torch.tensor(
+            [
+                [1, 2, 3, 4, 5],  # prompt + chosen (example 1)
+                [9, 10, 11, 0, 0],  # prompt + chosen (example 2, padded)
+                [1, 2, 3, 6, 0],  # prompt + rejected (example 1, padded)
+                [9, 10, 12, 13, 0],  # prompt + rejected (example 2, padded)
+                [1, 2, 3, 7, 8],  # prompt + reference (example 1)
+                [9, 10, 14, 0, 0],  # prompt + reference (example 2, padded)
+            ]
+        )
+        expected_attention_mask = torch.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],
+            ]
+        )
+        expected_completion_mask = torch.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],
+            ]
+        )
+
+        assert set(result.keys()) == {"input_ids", "attention_mask", "completion_mask"}
+        torch.testing.assert_close(result["input_ids"], expected_input_ids)
+        torch.testing.assert_close(result["attention_mask"], expected_attention_mask)
+        torch.testing.assert_close(result["completion_mask"], expected_completion_mask)
+
+    def test_exclude_reference(self):
+        # When `include_reference=False`, the collator only emits the chosen/rejected halves so the per-step
+        # compute/memory cost matches DPO's `DataCollatorForPreference`. This is the layout used by
+        # `TPOTrainer` when `tpo_alpha=0.0`.
+        collator = DataCollatorForTriplePreference(pad_token_id=0, include_reference=False)
+        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]},
+        ]
+        result = collator(examples)
+
+        expected_input_ids = torch.tensor(
+            [
+                [1, 2, 3, 4, 5],  # prompt + chosen (example 1)
+                [9, 10, 11, 0, 0],  # prompt + chosen (example 2, padded)
+                [1, 2, 3, 6, 0],  # prompt + rejected (example 1, padded)
+                [9, 10, 12, 13, 0],  # prompt + rejected (example 2, padded)
+            ]
+        )
+        assert result["input_ids"].shape == (4, 5)  # 2 * B rows, no reference branch
+        torch.testing.assert_close(result["input_ids"], expected_input_ids)
+        assert set(result.keys()) == {"input_ids", "attention_mask", "completion_mask"}
+
+
+class TestTPOTrainer(TrlTestCase):
+    def test_train(self):
+        # Get the dataset and synthesize a reference (gold) completion
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+        dataset = dataset.map(_add_reference_column)
+
+        training_args = TPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+        )
+        trainer = TPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_trust_remote_code(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+        dataset = dataset.map(_add_reference_column)
+        model_id = "trl-internal-testing/tiny-RemoteForCausalLM"
+
+        with pytest.raises(ValueError, match="custom code"):
+            TPOTrainer(
+                model=model_id,
+                args=TPOConfig(output_dir=self.tmp_dir, report_to="none"),
+                train_dataset=dataset,
+            )
+
+        trainer = TPOTrainer(
+            model=model_id,
+            args=TPOConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True),
+            train_dataset=dataset,
+        )
+        assert type(trainer.model).__name__ == "RemoteForCausalLM"
+
+    @pytest.mark.parametrize("loss_type", ["sigmoid", "hinge", "ipo", "tpo-l"])
+    def test_train_loss_types(self, loss_type):
+        # Get the dataset and synthesize a reference (gold) completion
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference")
+        dataset = dataset.map(_add_reference_column)
+
+        training_args = TPOConfig(
+            output_dir=self.tmp_dir,
+            loss_type=loss_type,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+            eval_strategy="steps",
+            eval_steps=3,
+        )
+        trainer = TPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset["train"],
+            eval_dataset=dataset["test"],
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_conversational(self):
+        # Get the dataset and synthesize a reference (gold) completion
+        dataset = load_dataset("trl-internal-testing/zen", "conversational_preference", split="train")
+        dataset = dataset.map(_add_reference_column)
+
+        training_args = TPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            report_to="none",
+        )
+        trainer = TPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_without_nll(self):
+        # Setting tpo_alpha=0.0 disables the NLL term, skips the corresponding cross-entropy, and also drops the
+        # reference branch from the collated batch so the model doesn't pay the extra forward-pass cost.
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+        dataset = dataset.map(_add_reference_column)
+
+        training_args = TPOConfig(
+            output_dir=self.tmp_dir,
+            tpo_alpha=0.0,
+            learning_rate=0.1,
+            report_to="none",
+        )
+        trainer = TPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        # The default collator should drop the reference branch entirely when `tpo_alpha=0.0`.
+        assert isinstance(trainer.data_collator, DataCollatorForTriplePreference)
+        assert trainer.data_collator.include_reference is False
+
+        # Verify the collated batch is 2 * per_device_train_batch_size (chosen + rejected only), not 3 * B.
+        batch = trainer.data_collator(list(trainer.train_dataset.select(range(2))))
+        assert batch["input_ids"].shape[0] == 4  # 2 branches * 2 examples
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_implicit_prompt(self):
+        # Implicit-prompt variant: no `prompt` column, the prompt is embedded in `chosen`/`rejected` and (for TPO)
+        # also in `reference`. Regression test for the `extract_prompt` bug where the reference column was left
+        # untouched, silently doubling the prompt in the reference branch.
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        # Synthesize a reference column that shares the same implicit prompt as chosen/rejected
+        dataset = dataset.map(_add_reference_column)
+
+        training_args = TPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            report_to="none",
+        )
+        trainer = TPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_implicit_prompt_mismatched_reference_raises(self):
+        # When the dataset has no `prompt` column and the `reference` completion does not share the implicit
+        # prompt prefix of `chosen`/`rejected`, the trainer must raise a clear error rather than silently
+        # corrupting the reference branch.
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        def _set_unrelated_reference(example):
+            example["reference"] = "unrelated completion without the shared prompt prefix."
+            return example
+
+        dataset = dataset.map(_set_unrelated_reference)
+
+        training_args = TPOConfig(output_dir=self.tmp_dir, report_to="none")
+        with pytest.raises(ValueError, match="implicit prompt"):
+            TPOTrainer(
+                model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+                args=training_args,
+                train_dataset=dataset,
+            )
+
+    def test_missing_reference_column_raises(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = TPOConfig(output_dir=self.tmp_dir, report_to="none")
+        with pytest.raises(ValueError, match="reference"):
+            TPOTrainer(
+                model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+                args=training_args,
+                train_dataset=dataset,
+            )
+
+    @require_peft
+    def test_train_with_peft(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+        dataset = dataset.map(_add_reference_column)
+
+        training_args = TPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,
+            report_to="none",
+        )
+        trainer = TPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+            peft_config=LoraConfig(),
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        for n, param in previous_trainable_params.items():
+            if "lora" in n:
+                new_param = trainer.model.get_parameter(n)
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_utils.py

@@ -0,0 +1,160 @@
+# 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 datasets import Dataset, load_dataset
+from transformers import AutoTokenizer
+
+from trl.experimental.utils import DataCollatorForChatML, truncate_dataset
+
+from ..testing_utils import TrlTestCase
+
+
+class TestDataCollatorForChatML(TrlTestCase):
+    def setup_method(self):
+        # Initialize the tokenizer
+        self.tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5")
+        if self.tokenizer.pad_token is None:
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+
+        # Define token IDs
+        self.bos_token_id = self.tokenizer.bos_token_id if self.tokenizer.bos_token_id is not None else 1
+        self.eos_token_id = self.tokenizer.eos_token_id if self.tokenizer.eos_token_id is not None else 2
+        # Token ID for "true", the last assistant's response in the example:
+        self.ignore_index = -100
+        self.max_length = 1024
+        self.messages_key = "messages"
+
+        # Example input
+        dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling", split="train")
+        self.examples = dataset.to_list()
+
+        # Initialize the data collator
+        self.collator = DataCollatorForChatML(
+            tokenizer=self.tokenizer,
+            max_length=self.max_length,
+            ignore_index=self.ignore_index,
+        )
+
+    def test_data_collator_for_chatml(self):
+        # Process the data
+        data = self.collator(self.examples)
+
+        # Verify basic shapes and types
+        assert "input_ids" in data
+        assert "attention_mask" in data
+        assert "labels" in data
+        assert "prompts" in data
+        assert "prompt_attention_mask" in data
+
+        # Decode input_ids and labels for verification
+        input_ids = data["input_ids"][0].tolist()
+        labels = data["labels"][0].tolist()
+        prompt_only = data["prompts"][0].tolist()
+
+        # Get the last assistant's response for comparison
+        last_message = self.examples[0][self.messages_key][-1]
+        assert last_message["role"] == "assistant", "Last message should be from assistant"
+        last_assistant_response = last_message["content"]
+
+        # Verify that input_ids contain both prompt and response
+        decoded_input = self.tokenizer.decode(input_ids)
+        assert last_assistant_response in decoded_input, "Input should contain assistant's response"
+
+        # Verify that prompts only contain the conversation up to the last response
+        decoded_prompt = self.tokenizer.decode(prompt_only)
+        assert last_assistant_response not in decoded_prompt, "Prompt should not contain assistant's response"
+
+        # Verify labels are -100 for non-assistant parts
+        prompt_length = len(prompt_only)
+        assert all(label == self.ignore_index for label in labels[:prompt_length]), (
+            "Labels should be ignore_index for prompt tokens"
+        )
+
+        # Verify labels match assistant response after prompt
+        # Add a filter to remove any trailing tokens after the first <|im_end|>
+        last_assistant_response_with_end = last_assistant_response + self.tokenizer.eos_token
+        last_assistant_response_tokens = self.tokenizer.encode(
+            last_assistant_response_with_end, add_special_tokens=False
+        )
+
+        response_labels = []
+        for label in labels[prompt_length:]:
+            if label == self.ignore_index:
+                continue
+            response_labels.append(label)
+            if label == self.tokenizer.convert_tokens_to_ids("<|im_end|>"):
+                break
+        assert response_labels == last_assistant_response_tokens, "Labels should match assistant response tokens"
+
+        # Verify there isn't a generation prompt at the end
+        generation_prompt = "<|im_start|>assistant"
+        assert not decoded_input.strip().endswith(generation_prompt), (
+            f"Input should not end with generation prompt '{generation_prompt}'"
+        )
+
+        assert response_labels == last_assistant_response_tokens, "Labels should match assistant response tokens"
+
+
+class TestTruncateExamples(TrlTestCase):
+    def test_with_dataset(self):
+        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)
+        dataset = dataset.with_format("numpy", dtype="float32")
+        format = dataset.format
+        max_length = 2
+        expected_output = {
+            "input_ids": [[1, 2], [4, 5], [8]],
+            "attention_mask": [[0, 1], [0, 0], [1]],
+        }
+        dataset = truncate_dataset(dataset, max_length)
+        assert dataset.to_dict() == expected_output
+        assert format == dataset.format
+
+    def test_with_iterable_dataset(self):
+        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).to_iterable_dataset()
+        dataset = dataset.with_format("numpy")
+        formatting = dataset._formatting
+        max_length = 2
+        expected_output = {
+            "input_ids": [[1, 2], [4, 5], [8]],
+            "attention_mask": [[0, 1], [0, 0], [1]],
+        }
+        dataset = truncate_dataset(dataset, max_length)
+        num_examples = len(examples[next(iter(examples))])
+        assert next(iter(dataset.with_format(None).batch(batch_size=num_examples))) == expected_output
+        assert formatting == dataset._formatting
+
+    def test_with_extra_column(self):
+        examples = {
+            "input_ids": [[1, 2, 3], [4, 5, 6, 7], [8]],
+            "attention_mask": [[0, 1, 1], [0, 0, 1, 1], [1]],
+            "my_column": ["a", "b", "c"],
+        }
+        dataset = Dataset.from_dict(examples)
+        max_length = 2
+        expected_output = {
+            "input_ids": [[1, 2], [4, 5], [8]],
+            "attention_mask": [[0, 1], [0, 0], [1]],
+            "my_column": ["a", "b", "c"],
+        }
+        dataset = truncate_dataset(dataset, max_length)
+        assert dataset.to_dict() == expected_output

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_xpo_trainer.py

@@ -0,0 +1,143 @@
+# 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 pytest
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification, AutoTokenizer
+from transformers.utils import is_peft_available
+
+from trl.experimental.xpo import XPOConfig, XPOTrainer
+
+from ..testing_utils import TrlTestCase, require_peft
+
+
+if is_peft_available():
+    from peft import LoraConfig, get_peft_model
+
+
+@pytest.mark.low_priority
+class TestXPOTrainer(TrlTestCase):
+    def setup_method(self):
+        self.model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        self.model = AutoModelForCausalLM.from_pretrained(self.model_id, dtype="float32")
+        self.ref_model = AutoModelForCausalLM.from_pretrained(self.model_id)
+        self.reward_model = AutoModelForSequenceClassification.from_pretrained(self.model_id, num_labels=1)
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+        self.tokenizer.pad_token = self.tokenizer.eos_token
+
+    @pytest.mark.parametrize("config_name", ["standard_prompt_only", "conversational_prompt_only"])
+    def test_xpo_trainer_training(self, config_name):
+        training_args = XPOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            remove_unused_columns=False,
+            gradient_accumulation_steps=1,
+            learning_rate=9e-1,
+            report_to="none",
+        )
+        dataset = load_dataset("trl-internal-testing/zen", config_name, split="train")
+
+        trainer = XPOTrainer(
+            model=self.model,
+            ref_model=self.ref_model,
+            reward_funcs=self.reward_model,
+            args=training_args,
+            processing_class=self.tokenizer,
+            train_dataset=dataset,
+        )
+
+        trainer.train()
+
+        assert "train_loss" in trainer.state.log_history[-1]
+
+    @require_peft
+    def test_train_with_peft(self):
+        lora_config = LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM")
+        training_args = XPOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            learning_rate=5.0e-7,
+            report_to="none",
+        )
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        trainer = XPOTrainer(
+            model=self.model,
+            reward_funcs=self.reward_model,
+            args=training_args,
+            processing_class=self.tokenizer,
+            train_dataset=dataset,
+            peft_config=lora_config,
+        )
+
+        trainer.train()
+
+        assert "train_loss" in trainer.state.log_history[-1]
+
+    @require_peft
+    def test_train_with_peft_and_ref_model(self):
+        lora_config = LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM")
+        training_args = XPOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,
+            max_steps=3,
+            learning_rate=5.0e-7,
+            report_to="none",
+        )
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        trainer = XPOTrainer(
+            model=self.model,
+            ref_model=self.ref_model,
+            reward_funcs=self.reward_model,
+            args=training_args,
+            processing_class=self.tokenizer,
+            train_dataset=dataset,
+            peft_config=lora_config,
+        )
+
+        trainer.train()
+
+        assert "train_loss" in trainer.state.log_history[-1]
+
+    @require_peft
+    def test_train_pre_pefted_model_implicit_ref(self):
+        lora_config = LoraConfig(r=8, lora_alpha=16, lora_dropout=0.1, bias="none", task_type="CAUSAL_LM")
+        peft_model_instance = get_peft_model(self.model, lora_config)
+
+        training_args = XPOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=1,
+            max_steps=2,
+            learning_rate=5.0e-7,
+            eval_strategy="no",
+            report_to="none",
+            remove_unused_columns=False,
+        )
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        trainer = XPOTrainer(
+            model=peft_model_instance,
+            ref_model=None,
+            reward_funcs=self.reward_model,  # Using reward_model to ensure _generate_completions is used as expected
+            args=training_args,
+            processing_class=self.tokenizer,
+            train_dataset=dataset,
+        )
+
+        trainer.train()
+
+        assert "train_loss" in trainer.state.log_history[-1]

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/README.md

@@ -0,0 +1,57 @@
+# Training invariant tests
+
+Catches silent training bugs that don't fail unit tests but shift the training trajectory. Runs on real models, opt-in only.
+
+## How it works
+
+Configs are grouped into **equivalence classes**: configs in the same class must produce the same trajectory (e.g. PDB=1×GAS=8 must equal PDB=8×GAS=1, FA2 must equal eager). Each class has one **canonical** config (the first one) that owns the class's reference snapshot. Every config in the class — canonical included — is asserted to match the saved reference. This catches both invariant breakage (a non-canonical config drifting away from the canonical's pinned trajectory) and numerical regressions (the canonical itself drifting from its committed snapshot across versions).
+
+Recording the references is a separate concern from testing them, so it's a separate entry point (`python tests/invariant/test_invariant.py`).
+
+Each config is a `trl <method>` CLI invocation with a fixed set of args. The harness shells out (`subprocess.run(["trl", method, ...])`), the CLI runs end to end, writes `trainer_state.json` to its `--output_dir`, and the harness parses the `log_history` into a `Trajectory`.
+
+This means the suite tests the actual user-facing entry point, not the Python API. Catches CLI-only bugs (arg parsing, defaults, dispatch) for free. Distributed runs are an additive change: prepend `accelerate launch --config_file <strategy>.yaml` to the same command.
+
+## Scope (initial)
+
+- Trainers: `trl sft`, `trl dpo`
+- Model: `Qwen/Qwen2.5-0.5B-Instruct` (pinned revision)
+- Equivalence classes:
+  - `sft`: `sft_default` (canonical), `sft_pdb1_gas8` (gradient accumulation), `sft_attn_fa2_kernels` (FA2 via kernels)
+  - `dpo`: `dpo_default` (canonical), `dpo_pdb1_gas8` (gradient accumulation)
+- Single GPU, fp32, fixed seed, ~50 optimizer steps.
+
+Other axes (sharding, DDP, more trainers) are deferred and will be additive.
+
+## Trajectory
+
+Per optimizer step: `loss`, `grad_norm`. One JSON per equivalence class in `references/` (`sft.json`, `dpo.json`):
+
+```json
+{
+  "config": {"name": "sft_default", "method": "sft", "args": {...}},
+  "env":    {"accelerate": "...", "torch": "...", "transformers": "...", "trl": "...", "gpu": "H100-80GB"},
+  "steps":  [{"step": 1, "loss": 1.234, "grad_norm": 0.567}, ...]
+}
+```
+
+## Comparison
+
+Scalar series with absolute tolerance + zero-mean-residual. The residual check is what flags bugs like GAS-dropping — they show up as a one-sided systematic shift in the loss curve, not as point-wise outliers.
+
+## Hardware
+
+Reference snapshots are recorded on **H100 80GB** (pinned in `references/env.lock`).
+
+## Running
+
+```bash
+# test
+pytest tests/invariant/ -m invariant
+
+# record references
+python tests/invariant/test_invariant.py      # all classes
+python tests/invariant/test_invariant.py sft  # one class
+```
+
+Snapshot updates must be justified in the PR description.

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/__init__.py

@@ -0,0 +1,14 @@
+# 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.
+

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/references/dpo.json

@@ -0,0 +1,280 @@
+{
+  "config": {
+    "name": "dpo_default",
+    "method": "dpo",
+    "args": {
+      "model_name_or_path": "Qwen/Qwen2.5-0.5B-Instruct",
+      "model_revision": "7ae557604adf67be50417f59c2c2f167def9a775",
+      "attn_implementation": "eager",
+      "dataset_name": "trl-lib/ultrafeedback_binarized",
+      "max_steps": "50",
+      "max_length": "512",
+      "logging_steps": "1",
+      "report_to": "none",
+      "seed": "42",
+      "data_seed": "42",
+      "full_determinism": "True",
+      "bf16": "False"
+    }
+  },
+  "env": {
+    "accelerate": "1.13.0",
+    "torch": "2.10.0+cu128",
+    "transformers": "5.10.0.dev0",
+    "trl": "f4e94c0c10654ab57b94e7cd8096ed4f12246e03",
+    "python": "3.13.13",
+    "gpu": "NVIDIA H100 80GB HBM3"
+  },
+  "steps": [
+    {
+      "step": 1,
+      "loss": 0.6931471824645996,
+      "grad_norm": 157.25071716308594
+    },
+    {
+      "step": 2,
+      "loss": 0.6901174783706665,
+      "grad_norm": 108.38384246826172
+    },
+    {
+      "step": 3,
+      "loss": 0.6326549053192139,
+      "grad_norm": 140.2856903076172
+    },
+    {
+      "step": 4,
+      "loss": 0.7054474353790283,
+      "grad_norm": 151.10508728027344
+    },
+    {
+      "step": 5,
+      "loss": 0.7342866063117981,
+      "grad_norm": 157.84791564941406
+    },
+    {
+      "step": 6,
+      "loss": 0.6869831085205078,
+      "grad_norm": 137.7687530517578
+    },
+    {
+      "step": 7,
+      "loss": 0.7037957906723022,
+      "grad_norm": 130.58058166503906
+    },
+    {
+      "step": 8,
+      "loss": 0.671793520450592,
+      "grad_norm": 164.77792358398438
+    },
+    {
+      "step": 9,
+      "loss": 0.6760100722312927,
+      "grad_norm": 102.67815399169922
+    },
+    {
+      "step": 10,
+      "loss": 0.6628016233444214,
+      "grad_norm": 123.41923522949219
+    },
+    {
+      "step": 11,
+      "loss": 0.6634430885314941,
+      "grad_norm": 83.91616821289062
+    },
+    {
+      "step": 12,
+      "loss": 0.7321300506591797,
+      "grad_norm": 161.53366088867188
+    },
+    {
+      "step": 13,
+      "loss": 0.7024844884872437,
+      "grad_norm": 150.16744995117188
+    },
+    {
+      "step": 14,
+      "loss": 0.6837225556373596,
+      "grad_norm": 123.26526641845703
+    },
+    {
+      "step": 15,
+      "loss": 0.7167133092880249,
+      "grad_norm": 133.57534790039062
+    },
+    {
+      "step": 16,
+      "loss": 0.6835181713104248,
+      "grad_norm": 124.6922378540039
+    },
+    {
+      "step": 17,
+      "loss": 0.6272522211074829,
+      "grad_norm": 100.10560607910156
+    },
+    {
+      "step": 18,
+      "loss": 0.8025375604629517,
+      "grad_norm": 198.8187713623047
+    },
+    {
+      "step": 19,
+      "loss": 0.7497490048408508,
+      "grad_norm": 136.41639709472656
+    },
+    {
+      "step": 20,
+      "loss": 0.7327032089233398,
+      "grad_norm": 135.1873016357422
+    },
+    {
+      "step": 21,
+      "loss": 0.8468657732009888,
+      "grad_norm": 183.79238891601562
+    },
+    {
+      "step": 22,
+      "loss": 0.6504813432693481,
+      "grad_norm": 119.43262481689453
+    },
+    {
+      "step": 23,
+      "loss": 0.8200190663337708,
+      "grad_norm": 221.7334747314453
+    },
+    {
+      "step": 24,
+      "loss": 0.6116989850997925,
+      "grad_norm": 134.1520233154297
+    },
+    {
+      "step": 25,
+      "loss": 0.715190052986145,
+      "grad_norm": 160.9645538330078
+    },
+    {
+      "step": 26,
+      "loss": 0.78664231300354,
+      "grad_norm": 173.35397338867188
+    },
+    {
+      "step": 27,
+      "loss": 0.627922534942627,
+      "grad_norm": 118.79180145263672
+    },
+    {
+      "step": 28,
+      "loss": 0.6171221733093262,
+      "grad_norm": 143.510986328125
+    },
+    {
+      "step": 29,
+      "loss": 0.7258801460266113,
+      "grad_norm": 166.77137756347656
+    },
+    {
+      "step": 30,
+      "loss": 0.6643164157867432,
+      "grad_norm": 109.94638061523438
+    },
+    {
+      "step": 31,
+      "loss": 0.8424814343452454,
+      "grad_norm": 155.43392944335938
+    },
+    {
+      "step": 32,
+      "loss": 0.6372821927070618,
+      "grad_norm": 165.25477600097656
+    },
+    {
+      "step": 33,
+      "loss": 0.6878336668014526,
+      "grad_norm": 132.20591735839844
+    },
+    {
+      "step": 34,
+      "loss": 0.7095304131507874,
+      "grad_norm": 168.26194763183594
+    },
+    {
+      "step": 35,
+      "loss": 0.6994724273681641,
+      "grad_norm": 126.31066131591797
+    },
+    {
+      "step": 36,
+      "loss": 0.6479494571685791,
+      "grad_norm": 162.87469482421875
+    },
+    {
+      "step": 37,
+      "loss": 0.7106008529663086,
+      "grad_norm": 142.19422912597656
+    },
+    {
+      "step": 38,
+      "loss": 0.6147706508636475,
+      "grad_norm": 124.1236343383789
+    },
+    {
+      "step": 39,
+      "loss": 0.6274570226669312,
+      "grad_norm": 97.5869369506836
+    },
+    {
+      "step": 40,
+      "loss": 0.5677652359008789,
+      "grad_norm": 99.20594787597656
+    },
+    {
+      "step": 41,
+      "loss": 0.5417441129684448,
+      "grad_norm": 136.53424072265625
+    },
+    {
+      "step": 42,
+      "loss": 0.6146669983863831,
+      "grad_norm": 117.05335998535156
+    },
+    {
+      "step": 43,
+      "loss": 0.5652309656143188,
+      "grad_norm": 141.68212890625
+    },
+    {
+      "step": 44,
+      "loss": 0.6843374967575073,
+      "grad_norm": 123.86646270751953
+    },
+    {
+      "step": 45,
+      "loss": 0.700664758682251,
+      "grad_norm": 176.58290100097656
+    },
+    {
+      "step": 46,
+      "loss": 0.627228856086731,
+      "grad_norm": 93.38623046875
+    },
+    {
+      "step": 47,
+      "loss": 0.6068558096885681,
+      "grad_norm": 144.66879272460938
+    },
+    {
+      "step": 48,
+      "loss": 0.7041699886322021,
+      "grad_norm": 147.3819122314453
+    },
+    {
+      "step": 49,
+      "loss": 0.6936260461807251,
+      "grad_norm": 114.99978637695312
+    },
+    {
+      "step": 50,
+      "loss": 0.8024596571922302,
+      "grad_norm": 156.8375244140625
+    }
+  ]
+}

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/references/sft.json

@@ -0,0 +1,280 @@
+{
+  "config": {
+    "name": "sft_default",
+    "method": "sft",
+    "args": {
+      "model_name_or_path": "Qwen/Qwen2.5-0.5B-Instruct",
+      "model_revision": "7ae557604adf67be50417f59c2c2f167def9a775",
+      "attn_implementation": "eager",
+      "dataset_name": "trl-lib/Capybara",
+      "max_steps": "50",
+      "max_length": "512",
+      "logging_steps": "1",
+      "report_to": "none",
+      "seed": "42",
+      "data_seed": "42",
+      "full_determinism": "True",
+      "bf16": "False"
+    }
+  },
+  "env": {
+    "accelerate": "1.13.0",
+    "torch": "2.10.0+cu128",
+    "transformers": "5.10.0.dev0",
+    "trl": "f4e94c0c10654ab57b94e7cd8096ed4f12246e03",
+    "python": "3.13.13",
+    "gpu": "NVIDIA H100 80GB HBM3"
+  },
+  "steps": [
+    {
+      "step": 1,
+      "loss": 2.3842217922210693,
+      "grad_norm": 28.170888900756836
+    },
+    {
+      "step": 2,
+      "loss": 1.4120551347732544,
+      "grad_norm": 16.11708641052246
+    },
+    {
+      "step": 3,
+      "loss": 1.6543627977371216,
+      "grad_norm": 9.521869659423828
+    },
+    {
+      "step": 4,
+      "loss": 1.548227071762085,
+      "grad_norm": 9.530509948730469
+    },
+    {
+      "step": 5,
+      "loss": 1.3084965944290161,
+      "grad_norm": 13.43132209777832
+    },
+    {
+      "step": 6,
+      "loss": 1.4568636417388916,
+      "grad_norm": 11.567093849182129
+    },
+    {
+      "step": 7,
+      "loss": 1.6642777919769287,
+      "grad_norm": 8.233135223388672
+    },
+    {
+      "step": 8,
+      "loss": 1.6268576383590698,
+      "grad_norm": 6.363206386566162
+    },
+    {
+      "step": 9,
+      "loss": 1.5339726209640503,
+      "grad_norm": 6.955142974853516
+    },
+    {
+      "step": 10,
+      "loss": 1.547467827796936,
+      "grad_norm": 5.978666305541992
+    },
+    {
+      "step": 11,
+      "loss": 1.7950178384780884,
+      "grad_norm": 7.241233825683594
+    },
+    {
+      "step": 12,
+      "loss": 1.8137775659561157,
+      "grad_norm": 8.63271713256836
+    },
+    {
+      "step": 13,
+      "loss": 1.3856267929077148,
+      "grad_norm": 6.400929927825928
+    },
+    {
+      "step": 14,
+      "loss": 1.3795125484466553,
+      "grad_norm": 6.382791996002197
+    },
+    {
+      "step": 15,
+      "loss": 1.3708516359329224,
+      "grad_norm": 6.692564010620117
+    },
+    {
+      "step": 16,
+      "loss": 1.8075040578842163,
+      "grad_norm": 7.801014423370361
+    },
+    {
+      "step": 17,
+      "loss": 1.254800796508789,
+      "grad_norm": 5.860067367553711
+    },
+    {
+      "step": 18,
+      "loss": 1.6014561653137207,
+      "grad_norm": 7.397754669189453
+    },
+    {
+      "step": 19,
+      "loss": 1.5693073272705078,
+      "grad_norm": 6.078225612640381
+    },
+    {
+      "step": 20,
+      "loss": 1.2925223112106323,
+      "grad_norm": 6.285624027252197
+    },
+    {
+      "step": 21,
+      "loss": 1.261284589767456,
+      "grad_norm": 5.98115348815918
+    },
+    {
+      "step": 22,
+      "loss": 1.016650676727295,
+      "grad_norm": 6.040045261383057
+    },
+    {
+      "step": 23,
+      "loss": 1.222269058227539,
+      "grad_norm": 6.034141540527344
+    },
+    {
+      "step": 24,
+      "loss": 1.45418381690979,
+      "grad_norm": 6.263362407684326
+    },
+    {
+      "step": 25,
+      "loss": 1.23504638671875,
+      "grad_norm": 5.99455451965332
+    },
+    {
+      "step": 26,
+      "loss": 1.2722694873809814,
+      "grad_norm": 5.834524631500244
+    },
+    {
+      "step": 27,
+      "loss": 2.2606589794158936,
+      "grad_norm": 7.2228522300720215
+    },
+    {
+      "step": 28,
+      "loss": 1.4542038440704346,
+      "grad_norm": 6.190547466278076
+    },
+    {
+      "step": 29,
+      "loss": 1.3753437995910645,
+      "grad_norm": 5.7064290046691895
+    },
+    {
+      "step": 30,
+      "loss": 1.0842117071151733,
+      "grad_norm": 6.300862789154053
+    },
+    {
+      "step": 31,
+      "loss": 1.6317358016967773,
+      "grad_norm": 6.022386074066162
+    },
+    {
+      "step": 32,
+      "loss": 1.4107545614242554,
+      "grad_norm": 6.697302341461182
+    },
+    {
+      "step": 33,
+      "loss": 1.5427740812301636,
+      "grad_norm": 6.703666687011719
+    },
+    {
+      "step": 34,
+      "loss": 1.0882741212844849,
+      "grad_norm": 6.260556697845459
+    },
+    {
+      "step": 35,
+      "loss": 2.1459619998931885,
+      "grad_norm": 6.938933849334717
+    },
+    {
+      "step": 36,
+      "loss": 1.7524574995040894,
+      "grad_norm": 6.392754554748535
+    },
+    {
+      "step": 37,
+      "loss": 1.558825135231018,
+      "grad_norm": 7.106125831604004
+    },
+    {
+      "step": 38,
+      "loss": 1.5750346183776855,
+      "grad_norm": 6.705704689025879
+    },
+    {
+      "step": 39,
+      "loss": 1.0681045055389404,
+      "grad_norm": 5.93332576751709
+    },
+    {
+      "step": 40,
+      "loss": 1.4508510828018188,
+      "grad_norm": 6.193344593048096
+    },
+    {
+      "step": 41,
+      "loss": 1.5779269933700562,
+      "grad_norm": 6.469877243041992
+    },
+    {
+      "step": 42,
+      "loss": 1.2731173038482666,
+      "grad_norm": 6.590377330780029
+    },
+    {
+      "step": 43,
+      "loss": 1.34458327293396,
+      "grad_norm": 5.618240833282471
+    },
+    {
+      "step": 44,
+      "loss": 1.5110447406768799,
+      "grad_norm": 5.829492092132568
+    },
+    {
+      "step": 45,
+      "loss": 1.9833546876907349,
+      "grad_norm": 6.42317533493042
+    },
+    {
+      "step": 46,
+      "loss": 2.0645744800567627,
+      "grad_norm": 7.079426288604736
+    },
+    {
+      "step": 47,
+      "loss": 1.0404279232025146,
+      "grad_norm": 5.035366535186768
+    },
+    {
+      "step": 48,
+      "loss": 1.3794283866882324,
+      "grad_norm": 5.685641288757324
+    },
+    {
+      "step": 49,
+      "loss": 1.4115599393844604,
+      "grad_norm": 6.172175407409668
+    },
+    {
+      "step": 50,
+      "loss": 1.3042362928390503,
+      "grad_norm": 5.568996906280518
+    }
+  ]
+}

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/references/sft_fa2.json

@@ -0,0 +1,281 @@
+{
+  "config": {
+    "name": "sft_fa2",
+    "method": "sft",
+    "args": {
+      "model_name_or_path": "Qwen/Qwen2.5-0.5B-Instruct",
+      "model_revision": "7ae557604adf67be50417f59c2c2f167def9a775",
+      "attn_implementation": "kernels-community/flash-attn2",
+      "dataset_name": "trl-lib/Capybara",
+      "max_steps": "50",
+      "max_length": "None",
+      "logging_steps": "1",
+      "report_to": "none",
+      "seed": "42",
+      "data_seed": "42",
+      "full_determinism": "True",
+      "bf16": "True",
+      "per_device_train_batch_size": "2"
+    }
+  },
+  "env": {
+    "accelerate": "1.14.0",
+    "torch": "2.10.0+cu128",
+    "transformers": "5.12.1",
+    "trl": "b58947c7e3f6a3ccddc56771f4bfa65c0d72bb41",
+    "python": "3.13.13",
+    "gpu": "NVIDIA H100 80GB HBM3"
+  },
+  "steps": [
+    {
+      "step": 1,
+      "loss": 2.0777087211608887,
+      "grad_norm": 23.31194496154785
+    },
+    {
+      "step": 2,
+      "loss": 1.5329023599624634,
+      "grad_norm": 18.577106475830078
+    },
+    {
+      "step": 3,
+      "loss": 1.3667995929718018,
+      "grad_norm": 15.29236125946045
+    },
+    {
+      "step": 4,
+      "loss": 2.432100296020508,
+      "grad_norm": 10.477559089660645
+    },
+    {
+      "step": 5,
+      "loss": 1.4821819067001343,
+      "grad_norm": 12.838624954223633
+    },
+    {
+      "step": 6,
+      "loss": 1.2035114765167236,
+      "grad_norm": 9.587946891784668
+    },
+    {
+      "step": 7,
+      "loss": 1.4986138343811035,
+      "grad_norm": 9.106823921203613
+    },
+    {
+      "step": 8,
+      "loss": 1.3387559652328491,
+      "grad_norm": 9.543354034423828
+    },
+    {
+      "step": 9,
+      "loss": 1.7545020580291748,
+      "grad_norm": 8.437145233154297
+    },
+    {
+      "step": 10,
+      "loss": 1.604130744934082,
+      "grad_norm": 45.08439636230469
+    },
+    {
+      "step": 11,
+      "loss": 1.3063030242919922,
+      "grad_norm": 7.061337947845459
+    },
+    {
+      "step": 12,
+      "loss": 1.4820657968521118,
+      "grad_norm": 7.337648391723633
+    },
+    {
+      "step": 13,
+      "loss": 1.0585386753082275,
+      "grad_norm": 9.335886001586914
+    },
+    {
+      "step": 14,
+      "loss": 1.2921745777130127,
+      "grad_norm": 6.186776161193848
+    },
+    {
+      "step": 15,
+      "loss": 1.3104896545410156,
+      "grad_norm": 9.37338924407959
+    },
+    {
+      "step": 16,
+      "loss": 1.5219330787658691,
+      "grad_norm": 9.168572425842285
+    },
+    {
+      "step": 17,
+      "loss": 1.5855588912963867,
+      "grad_norm": 14.43403148651123
+    },
+    {
+      "step": 18,
+      "loss": 0.731721818447113,
+      "grad_norm": 12.131467819213867
+    },
+    {
+      "step": 19,
+      "loss": 1.6662267446517944,
+      "grad_norm": 6.035709381103516
+    },
+    {
+      "step": 20,
+      "loss": 1.0886207818984985,
+      "grad_norm": 9.489429473876953
+    },
+    {
+      "step": 21,
+      "loss": 1.1482083797454834,
+      "grad_norm": 8.50695514678955
+    },
+    {
+      "step": 22,
+      "loss": 1.0655895471572876,
+      "grad_norm": 6.936838150024414
+    },
+    {
+      "step": 23,
+      "loss": 1.3867775201797485,
+      "grad_norm": 9.368760108947754
+    },
+    {
+      "step": 24,
+      "loss": 1.888922095298767,
+      "grad_norm": 19.709505081176758
+    },
+    {
+      "step": 25,
+      "loss": 1.9733335971832275,
+      "grad_norm": 7.740928649902344
+    },
+    {
+      "step": 26,
+      "loss": 2.064484119415283,
+      "grad_norm": 6.624837398529053
+    },
+    {
+      "step": 27,
+      "loss": 0.67816162109375,
+      "grad_norm": 5.390377521514893
+    },
+    {
+      "step": 28,
+      "loss": 1.41758131980896,
+      "grad_norm": 11.643660545349121
+    },
+    {
+      "step": 29,
+      "loss": 2.0091347694396973,
+      "grad_norm": 8.343645095825195
+    },
+    {
+      "step": 30,
+      "loss": 1.5923049449920654,
+      "grad_norm": 7.833315849304199
+    },
+    {
+      "step": 31,
+      "loss": 1.4399499893188477,
+      "grad_norm": 6.47890567779541
+    },
+    {
+      "step": 32,
+      "loss": 1.1694945096969604,
+      "grad_norm": 7.235599517822266
+    },
+    {
+      "step": 33,
+      "loss": 1.8836697340011597,
+      "grad_norm": 16.655620574951172
+    },
+    {
+      "step": 34,
+      "loss": 1.7419353723526,
+      "grad_norm": 10.752205848693848
+    },
+    {
+      "step": 35,
+      "loss": 1.484404444694519,
+      "grad_norm": 7.342534065246582
+    },
+    {
+      "step": 36,
+      "loss": 1.2079955339431763,
+      "grad_norm": 9.161640167236328
+    },
+    {
+      "step": 37,
+      "loss": 1.4994128942489624,
+      "grad_norm": 6.655267238616943
+    },
+    {
+      "step": 38,
+      "loss": 1.1862525939941406,
+      "grad_norm": 6.461650848388672
+    },
+    {
+      "step": 39,
+      "loss": 1.463683009147644,
+      "grad_norm": 8.37391185760498
+    },
+    {
+      "step": 40,
+      "loss": 1.8926860094070435,
+      "grad_norm": 6.237414836883545
+    },
+    {
+      "step": 41,
+      "loss": 1.6285597085952759,
+      "grad_norm": 8.78761100769043
+    },
+    {
+      "step": 42,
+      "loss": 1.6035821437835693,
+      "grad_norm": 8.460630416870117
+    },
+    {
+      "step": 43,
+      "loss": 1.4722487926483154,
+      "grad_norm": 8.564600944519043
+    },
+    {
+      "step": 44,
+      "loss": 2.4026732444763184,
+      "grad_norm": 8.871479988098145
+    },
+    {
+      "step": 45,
+      "loss": 2.15500545501709,
+      "grad_norm": 8.206993103027344
+    },
+    {
+      "step": 46,
+      "loss": 1.3589471578598022,
+      "grad_norm": 8.473345756530762
+    },
+    {
+      "step": 47,
+      "loss": 1.2295477390289307,
+      "grad_norm": 24.53108787536621
+    },
+    {
+      "step": 48,
+      "loss": 1.878961443901062,
+      "grad_norm": 6.903346538543701
+    },
+    {
+      "step": 49,
+      "loss": 0.6936798691749573,
+      "grad_norm": 7.316105365753174
+    },
+    {
+      "step": 50,
+      "loss": 0.9757086038589478,
+      "grad_norm": 12.083908081054688
+    }
+  ]
+}

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/test_invariant.py

@@ -0,0 +1,299 @@
+# 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 os
+import platform
+import subprocess
+import sys
+import tempfile
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+import accelerate
+import pytest
+import torch
+import transformers
+
+
+MODEL = "Qwen/Qwen2.5-0.5B-Instruct"
+MODEL_REVISION = "7ae557604adf67be50417f59c2c2f167def9a775"
+
+SFT_DATASET = "trl-lib/Capybara"
+DPO_DATASET = "trl-lib/ultrafeedback_binarized"
+
+REFERENCES_DIR = Path(__file__).parent / "references"
+
+NUM_STEPS = 50
+SEED = 42
+MAX_LENGTH = 512
+
+
+def _trl_commit() -> str:
+    """Return the current trl commit SHA (with `-dirty` suffix if the working tree has uncommitted changes).
+
+    Assumes the suite is run from a `pip install -e .` checkout — the only intended setup.
+    """
+    cwd = Path(__file__).parent
+    sha = subprocess.run(
+        ["git", "-C", str(cwd), "rev-parse", "HEAD"], capture_output=True, text=True, check=True
+    ).stdout.strip()
+    dirty = subprocess.run(
+        ["git", "-C", str(cwd), "status", "--porcelain"], capture_output=True, text=True, check=True
+    ).stdout.strip()
+    return f"{sha}-dirty" if dirty else sha
+
+
+def env_snapshot() -> dict:
+    return {
+        "accelerate": accelerate.__version__,
+        "torch": torch.__version__,
+        "transformers": transformers.__version__,
+        "trl": _trl_commit(),
+        "python": platform.python_version(),
+        "gpu": torch.cuda.get_device_name(0) if torch.cuda.is_available() else "cpu",
+    }
+
+
+@dataclass
+class StepRecord:
+    step: int
+    loss: float
+    grad_norm: float
+
+
+@dataclass
+class Trajectory:
+    config: dict
+    env: dict
+    steps: list[StepRecord]
+
+
+@dataclass
+class CorrectnessConfig:
+    name: str
+    method: str  # "sft" | "dpo"
+    args: dict[str, str]
+    num_processes: int = 1
+
+    def cli_args(self) -> list[str]:
+        out: list[str] = []
+        for k, v in self.args.items():
+            out.extend([f"--{k}", v])
+        return out
+
+
+def run(config: CorrectnessConfig) -> Trajectory:
+    """Invoke the trl CLI as a subprocess; parse its trainer_state.json into a Trajectory."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        cmd = ["trl", config.method]
+        cmd += ["--num_processes", str(config.num_processes)]
+        cmd += ["--output_dir", tmpdir, *config.cli_args()]
+        env = {**os.environ, "CUDA_VISIBLE_DEVICES": ",".join(str(i) for i in range(config.num_processes))}
+        subprocess.run(cmd, check=True, env=env)
+
+        state_paths = list(Path(tmpdir).glob("**/trainer_state.json"))
+        if not state_paths:
+            raise RuntimeError(f"trainer_state.json not produced in {tmpdir}")
+        state = json.loads(state_paths[0].read_text())
+
+    steps = [
+        StepRecord(
+            step=int(log["step"]),
+            loss=float(log["loss"]),
+            grad_norm=float(log["grad_norm"]),
+        )
+        for log in state["log_history"]
+        if "loss" in log  # skip eval and final-summary entries
+    ]
+
+    return Trajectory(
+        config={"name": config.name, "method": config.method, "args": config.args},
+        env=env_snapshot(),
+        steps=steps,
+    )
+
+
+def save(trajectory: Trajectory, path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(asdict(trajectory), indent=2))
+
+
+def load(path: Path) -> Trajectory:
+    data = json.loads(path.read_text())
+    return Trajectory(
+        config=data["config"],
+        env=data["env"],
+        steps=[StepRecord(**s) for s in data["steps"]],
+    )
+
+
+def compare_scalars(a: Trajectory, b: Trajectory, tol: dict[str, float], residual_tol: dict[str, float]) -> list[str]:
+    """Compare scalar series (loss, grad_norm). `tol` and `residual_tol` are per-field dicts keyed by `'loss'` and
+    `'grad_norm'`."""
+    errors: list[str] = []
+    if len(a.steps) != len(b.steps):
+        return [f"length mismatch: {len(a.steps)} vs {len(b.steps)}"]
+
+    for field in ("loss", "grad_norm"):
+        sa = [getattr(s, field) for s in a.steps]
+        sb = [getattr(s, field) for s in b.steps]
+        diffs = [x - y for x, y in zip(sa, sb, strict=False)]
+        max_abs = max(abs(d) for d in diffs)
+        if max_abs > tol[field]:
+            i = max(range(len(diffs)), key=lambda k: abs(diffs[k]))
+            step = a.steps[i].step
+            errors.append(
+                f"{field}: max |Δ|={max_abs:.3e} at step {step} (a={sa[i]:.6e}, b={sb[i]:.6e}, tol={tol[field]:.1e})"
+            )
+
+        mean = sum(diffs) / len(diffs)
+        if abs(mean) > residual_tol[field]:
+            errors.append(f"{field}: systematic drift, mean Δ={mean:.3e} (tol={residual_tol[field]:.1e})")
+
+    return errors
+
+
+def _build(
+    name: str, method: str, dataset: str, attn: str = "eager", num_processes: int = 1, **overrides
+) -> CorrectnessConfig:
+    args: dict[str, str] = {
+        "model_name_or_path": MODEL,
+        "model_revision": MODEL_REVISION,
+        "attn_implementation": attn,
+        "dataset_name": dataset,
+        "max_steps": str(NUM_STEPS),
+        "max_length": str(MAX_LENGTH),
+        "logging_steps": "1",
+        "report_to": "none",
+        "seed": str(SEED),
+        "data_seed": str(SEED),
+        "full_determinism": "True",
+        # Force pure fp32 training for maximal determinism and to avoid bfloat16-induced divergences.
+        "bf16": "False",
+    }
+    args.update({k: str(v) for k, v in overrides.items()})
+    return CorrectnessConfig(name=name, method=method, args=args, num_processes=num_processes)
+
+
+# Equivalence classes: each maps to a `members` list plus per-field `tol` (max |Δ|) and `residual_tol` (mean Δ)
+# dicts. The first member is the canonical config — it owns the class's reference snapshot and is the only one
+# re-recorded under `--update-references`. Every other member is asserted to match that snapshot.
+# Tuning tip: run `python tests/invariant/test_invariant.py <klass> --report` to see actual Δs and set tolerances
+# to ~1.5–2× the observed noise.
+EQUIVALENCE_CLASSES: dict[str, dict] = {
+    "sft": {
+        "tol": {"loss": 1e-3, "grad_norm": 1e-1},
+        "residual_tol": {"loss": 1e-5, "grad_norm": 1e-3},
+        "members": [
+            _build("sft_default", "sft", SFT_DATASET),
+            _build("sft_pdb1_gas8", "sft", SFT_DATASET, per_device_train_batch_size=1, gradient_accumulation_steps=8),
+            _build("sft_no_grad_ckpt", "sft", SFT_DATASET, gradient_checkpointing=False),
+            _build("sft_ddp2", "sft", SFT_DATASET, per_device_train_batch_size=4, num_processes=2),
+        ],
+    },
+    "sft_fa2": {
+        # loss_type not pinned; this class exercises the current SFTConfig default ("chunked_nll").
+        # Loss is much tighter than grad_norm under FA2+bf16 (grad_norm absorbs bf16 + FA varlen kernel noise).
+        # The grad_norm tol (5.0) is intentionally ~50× looser than the non-FA2 sft class (0.1): it is sized to the
+        # FA2 varlen kernel noise observed in practice, not a regression budget. Do not tighten it without re-running
+        # the class and confirming the new gap; see https://github.com/huggingface/trl/pull/5842#issuecomment-4539190615
+        "tol": {"loss": 1.5e-2, "grad_norm": 5.0},
+        "residual_tol": {"loss": 1e-3, "grad_norm": 2.5e-1},
+        "members": [
+            _build(
+                "sft_fa2",
+                "sft",
+                SFT_DATASET,
+                attn="kernels-community/flash-attn2",  # to avoid cross-contamination between samples when padding_free=True
+                bf16=True,  # required for FA2 kernels, which are bfloat16-only
+                max_length=None,  # Required when padding_free=True
+                per_device_train_batch_size=2,
+            ),
+            _build(
+                "sft_fa2_padfree",
+                "sft",
+                SFT_DATASET,
+                attn="kernels-community/flash-attn2",  # to avoid cross-contamination between samples when padding_free=True
+                bf16=True,  # required for FA2 kernels, which are bfloat16-only
+                max_length=None,  # Required when padding_free=True
+                per_device_train_batch_size=2,
+                padding_free=True,
+            ),
+        ],
+    },
+    "dpo": {
+        "tol": {"loss": 1e-4, "grad_norm": 1e-2},
+        "residual_tol": {"loss": 1e-5, "grad_norm": 1e-3},
+        "members": [
+            _build("dpo_default", "dpo", DPO_DATASET),
+            _build("dpo_pdb1_gas8", "dpo", DPO_DATASET, per_device_train_batch_size=1, gradient_accumulation_steps=8),
+            _build("dpo_no_grad_ckpt", "dpo", DPO_DATASET, gradient_checkpointing=False),
+            _build("dpo_ddp2", "dpo", DPO_DATASET, per_device_train_batch_size=4, num_processes=2),
+        ],
+    },
+}
+
+
+_ALL = [(klass, c) for klass, ec in EQUIVALENCE_CLASSES.items() for c in ec["members"]]
+
+
+@pytest.mark.invariant
+@pytest.mark.parametrize("klass,config", _ALL, ids=[c.name for _, c in _ALL])
+def test_invariant(klass, config):
+    ref_path = REFERENCES_DIR / f"{klass}.json"
+    if not ref_path.exists():
+        pytest.fail(f"no reference at {ref_path}; record it with `python {Path(__file__).name}`")
+
+    if config.num_processes > 1 and torch.cuda.device_count() < config.num_processes:
+        pytest.skip(f"requires {config.num_processes} GPUs, got {torch.cuda.device_count()}")
+
+    trajectory = run(config)
+    reference = load(ref_path)
+    ec = EQUIVALENCE_CLASSES[klass]
+    errors = compare_scalars(trajectory, reference, tol=ec["tol"], residual_tol=ec["residual_tol"])
+    assert not errors, f"'{config.name}' diverges from class '{klass}' reference:\n  " + "\n  ".join(errors)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Record canonical reference trajectories for the invariant tests.")
+    parser.add_argument(
+        "klass",
+        nargs="*",
+        choices=list(EQUIVALENCE_CLASSES),
+        help="Equivalence class(es) to record. Default: all.",
+    )
+    parser.add_argument(
+        "--allow-dirty",
+        action="store_true",
+        help="Allow recording from a dirty working tree (snapshot will pin an irreproducible state).",
+    )
+    cli_args = parser.parse_args()
+
+    if _trl_commit().endswith("-dirty") and not cli_args.allow_dirty:
+        sys.exit(
+            "Refusing to record from a dirty working tree: the snapshot would pin a state that can't be "
+            "reproduced from a commit SHA. Commit your changes first, or pass --allow-dirty to override."
+        )
+
+    classes = cli_args.klass or list(EQUIVALENCE_CLASSES)
+    for klass in classes:
+        canonical = EQUIVALENCE_CLASSES[klass]["members"][0]
+        print(f"recording '{klass}' from canonical config '{canonical.name}'")  # noqa: T201
+        trajectory = run(canonical)
+        ref_path = REFERENCES_DIR / f"{klass}.json"
+        save(trajectory, ref_path)
+        print(f"  → {ref_path}")  # noqa: T201

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/tasksmith_behavior.py

@@ -0,0 +1,202 @@
+import math
+import pickle
+import pytest
+
+
+# ---------------------------------------------------------------------------
+# Adjacent behavior: accuracy_reward already exists on the starting code.
+# These tests pass before and after the PR.
+# ---------------------------------------------------------------------------
+
+def test_accuracy_reward_correct_answer():
+    from trl.rewards import accuracy_reward
+    completions = [[{"content": r"\boxed{\frac{1}{3}}"}]]
+    solution = [r"\frac{1}{3}"]
+    rewards = accuracy_reward(completions, solution)
+    assert rewards == [1.0]
+
+
+def test_accuracy_reward_wrong_answer():
+    from trl.rewards import accuracy_reward
+    completions = [[{"content": r"\boxed{\frac{1}{2}}"}]]
+    solution = [r"\frac{1}{3}"]
+    rewards = accuracy_reward(completions, solution)
+    assert rewards == [0.0]
+
+
+# ---------------------------------------------------------------------------
+# New behavior: get_cosine_scaled_reward (fails on starting code).
+# Each test imports inside the function so collection never fails.
+# ---------------------------------------------------------------------------
+
+def test_importable_from_trl_rewards():
+    from trl.rewards import get_cosine_scaled_reward
+    fn = get_cosine_scaled_reward(max_len=100)
+    assert callable(fn)
+
+
+def test_midpoint_values_default_bounds():
+    """At progress=0.5 (cosine=0): correct->0.75, wrong->-0.75."""
+    from trl.rewards import get_cosine_scaled_reward
+    reward_fn = 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]
+    rewards = reward_fn(completions, solution, completion_ids)
+    assert rewards == [pytest.approx(0.75), pytest.approx(-0.75)]
+
+
+def test_correct_shorter_rewarded_more():
+    """Shorter correct completions receive a higher reward."""
+    from trl.rewards import get_cosine_scaled_reward
+    reward_fn = get_cosine_scaled_reward(max_len=100)
+    completions = [[{"content": r"\boxed{\frac{1}{3}}"}], [{"content": r"\boxed{\frac{1}{3}}"}]]
+    solution = [r"\frac{1}{3}", r"\frac{1}{3}"]
+    completion_ids = [[1] * 25, [1] * 75]
+    rewards = reward_fn(completions, solution, completion_ids)
+    assert rewards[0] > rewards[1]
+    assert rewards[0] == pytest.approx(0.92678, abs=1e-4)
+    assert rewards[1] == pytest.approx(0.57322, abs=1e-4)
+
+
+def test_wrong_longer_penalized_less():
+    """Longer wrong completions are penalized less (closer to zero)."""
+    from trl.rewards import get_cosine_scaled_reward
+    reward_fn = get_cosine_scaled_reward(max_len=100)
+    completions = [[{"content": r"\boxed{\frac{1}{2}}"}], [{"content": r"\boxed{\frac{1}{2}}"}]]
+    solution = [r"\frac{1}{3}", r"\frac{1}{3}"]
+    completion_ids = [[1] * 25, [1] * 75]
+    rewards = reward_fn(completions, solution, completion_ids)
+    assert rewards[1] > rewards[0]
+    assert rewards[0] == pytest.approx(-0.92678, abs=1e-4)
+    assert rewards[1] == pytest.approx(-0.57322, abs=1e-4)
+
+
+def test_correct_boundary_values():
+    """Correct: empty (0 tokens) -> max_value_correct=1.0; full (max_len) -> min_value_correct=0.5."""
+    from trl.rewards import get_cosine_scaled_reward
+    reward_fn = get_cosine_scaled_reward(max_len=100)
+    completions = [[{"content": r"\boxed{\frac{1}{3}}"}], [{"content": r"\boxed{\frac{1}{3}}"}]]
+    solution = [r"\frac{1}{3}", r"\frac{1}{3}"]
+    completion_ids = [[], [1] * 100]
+    rewards = reward_fn(completions, solution, completion_ids)
+    assert rewards == [pytest.approx(1.0), pytest.approx(0.5)]
+
+
+def test_wrong_boundary_values():
+    """Wrong: empty (0 tokens) -> min_value_wrong=-1.0; full (max_len) -> max_value_wrong=-0.5."""
+    from trl.rewards import get_cosine_scaled_reward
+    reward_fn = get_cosine_scaled_reward(max_len=100)
+    completions = [[{"content": r"\boxed{\frac{1}{2}}"}], [{"content": r"\boxed{\frac{1}{2}}"}]]
+    solution = [r"\frac{1}{3}", r"\frac{1}{3}"]
+    completion_ids = [[], [1] * 100]
+    rewards = reward_fn(completions, solution, completion_ids)
+    assert rewards == [pytest.approx(-1.0), pytest.approx(-0.5)]
+
+
+def test_length_exceeding_max_len_is_clamped():
+    """Completions longer than max_len stay at the long-length bound value."""
+    from trl.rewards import get_cosine_scaled_reward
+    reward_fn = 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] * 200, [1] * 200]  # 2x max_len
+    rewards = reward_fn(completions, solution, completion_ids)
+    # same as at exactly max_len
+    assert rewards == [pytest.approx(0.5), pytest.approx(-0.5)]
+
+
+def test_unparsable_gold_yields_none():
+    """An unparseable gold solution results in None reward for that example."""
+    from trl.rewards import get_cosine_scaled_reward
+    reward_fn = get_cosine_scaled_reward(max_len=100)
+    completions = [[{"content": r"\boxed{42}"}]]
+    solution = ["forty two"]  # plain text, not a math expression
+    completion_ids = [[1] * 50]
+    rewards = reward_fn(completions, solution, completion_ids)
+    assert rewards == [None]
+
+
+def test_custom_value_bounds():
+    """Custom bounds are applied correctly in the formula."""
+    from trl.rewards import get_cosine_scaled_reward
+    # At midpoint: 0.0 + 0.5*(2.0-0.0)*(1+0) = 1.0
+    reward_fn = get_cosine_scaled_reward(max_len=100, min_value_correct=0.0, max_value_correct=2.0)
+    completions = [[{"content": r"\boxed{\frac{1}{3}}"}]]
+    solution = [r"\frac{1}{3}"]
+    completion_ids = [[1] * 50]
+    rewards = reward_fn(completions, solution, completion_ids)
+    assert rewards == [pytest.approx(1.0)]
+
+
+def test_nondefault_configuration_and_pickle():
+    """Budgets and all bounds govern fresh evaluations before and after pickling."""
+    from trl.rewards import get_cosine_scaled_reward
+
+    # Rows correspond to progress 0, 1/3, 1/2, 1, and 2 (clamped).
+    # Each row contains the independently expected correct and wrong rewards.
+    configurations = [
+        ({}, [(1.0, -1.0), (0.875, -0.875), (0.75, -0.75),
+              (0.5, -0.5), (0.5, -0.5)]),
+        ({"min_value_wrong": -2.0, "max_value_wrong": -0.25,
+          "min_value_correct": 0.25, "max_value_correct": 1.25},
+         [(1.25, -2.0), (1.0, -1.5625), (0.75, -1.125),
+          (0.25, -0.25), (0.25, -0.25)]),
+    ]
+    for budget in (60, 240):
+        for bounds, rows in configurations:
+            reward_fn = get_cosine_scaled_reward(max_len=budget, **bounds)
+            restored = pickle.loads(pickle.dumps(reward_fn))
+            for fn in (reward_fn, restored):
+                assert fn.__name__ == "cosine_scaled_reward"
+                completions = []
+                solutions = []
+                token_ids = []
+                for length in (0, budget // 3, budget // 2, budget, 2 * budget):
+                    for answer in (r"\boxed{\frac{1}{3}}", r"\boxed{\frac{1}{2}}"):
+                        completions.append([{"content": answer}])
+                        solutions.append(r"\frac{1}{3}")
+                        token_ids.append([7] * length)
+                rewards = fn(completions, solutions, token_ids)
+                assert isinstance(rewards, list)
+                assert rewards == pytest.approx([value for row in rows for value in row])
+
+
+def test_mathematical_correctness_not_substring_matching():
+    """Equivalent expressions count; mentioning the gold is not a correct final answer."""
+    from trl.rewards import accuracy_reward, get_cosine_scaled_reward
+
+    cases = [
+        (r"\boxed{1+1}", "2", 1.0, 0.75),
+        (r"I considered 2, but my final answer is \boxed{3}.", "2", 0.0, -0.75),
+        (r"\boxed{\frac{6}{8}}", r"\frac{3}{4}", 1.0, 0.75),
+        (r"I considered 5, but my final answer is \boxed{6}.", "5", 0.0, -0.75),
+    ]
+    reward_fn = get_cosine_scaled_reward(max_len=80)
+    restored = pickle.loads(pickle.dumps(reward_fn))
+    for fn in (reward_fn, restored):
+        completions = [[{"content": content}] for content, _, _, _ in cases]
+        solutions = [gold for _, gold, _, _ in cases]
+        # Validate fixture semantics against the repository's real math-verification API.
+        # Expected cosine rewards are independent of this submitted accuracy function.
+        assert accuracy_reward(completions, solutions) == [case[2] for case in cases]
+        rewards = fn(
+            completions=completions,
+            solution=solutions,
+            completion_ids=[[7] * 40 for _ in cases],
+            unused_trainer_metadata=None,
+        )
+        assert isinstance(rewards, list)
+        assert rewards == pytest.approx([case[3] for case in cases])
+
+
+def test_reward_is_picklable():
+    """The reward function survives pickle round-trip with correct behavior and __name__."""
+    from trl.rewards import get_cosine_scaled_reward
+    reward_fn = get_cosine_scaled_reward(max_len=100)
+    unpickled = pickle.loads(pickle.dumps(reward_fn))
+    completions = [[{"content": r"\boxed{\frac{1}{3}}"}]]
+    solution = [r"\frac{1}{3}"]
+    completion_ids = [[1] * 50]
+    assert unpickled(completions, solution, completion_ids) == [pytest.approx(0.75)]
+    assert unpickled.__name__ == "cosine_scaled_reward"

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_activation_offloading.py

@@ -0,0 +1,237 @@
+# 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 torch
+from torch import nn
+from transformers import AutoModelForCausalLM
+from transformers.testing_utils import torch_device
+from transformers.utils import is_peft_available
+
+from trl.models.activation_offloading import NoOpManager, OffloadActivations
+
+from .testing_utils import TrlTestCase, require_peft, require_torch_accelerator
+
+
+if is_peft_available():
+    from peft import LoraConfig, get_peft_model
+
+
+class TestActivationOffloading(TrlTestCase):
+    @require_torch_accelerator
+    @require_peft
+    def test_offloading_with_peft_models(self) -> None:
+        """Test that activation offloading works with PEFT models."""
+        model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        model = AutoModelForCausalLM.from_pretrained(model_id).to(torch_device)
+        peft_config = LoraConfig(
+            lora_alpha=16,
+            lora_dropout=0.1,
+            r=8,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        model = get_peft_model(model, peft_config)
+        inp = torch.randint(0, 100, (2, 10), device=torch_device)
+
+        # First forward-backward pass without offloading
+        torch.manual_seed(42)
+        loss = model(inp, labels=inp).loss
+        loss.backward()
+
+        # Store gradients - only from trainable parameters
+        grads_original = []
+        for name, param in model.named_parameters():
+            if param.requires_grad and param.grad is not None:
+                grads_original.append((name, param.grad.clone()))
+
+        # Reset gradients
+        for p in model.parameters():
+            if p.grad is not None:
+                p.grad = None
+
+        # Second forward-backward pass with offloading
+        torch.manual_seed(42)
+        with OffloadActivations():
+            loss_c = model(inp, labels=inp).loss
+        loss_c.backward()
+
+        # Compare gradients - only trainable parameters
+        for name_orig, grad_orig in grads_original:
+            for name_param, param in model.named_parameters():
+                if name_param == name_orig and param.requires_grad and param.grad is not None:
+                    (
+                        torch.testing.assert_close(grad_orig, param.grad, rtol=1e-4, atol=1e-5),
+                        (f"Gradient mismatch for {name_orig}"),
+                    )
+
+    @require_torch_accelerator
+    def test_noop_manager_with_offloading(self):
+        model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        model = AutoModelForCausalLM.from_pretrained(model_id).to(torch_device)
+        inp = torch.randint(0, 100, (2, 10), device=torch_device)
+
+        # Run with offloading but disable for specific section
+        with OffloadActivations():
+            # First forward-backward with normal offloading
+            torch.manual_seed(42)
+            out1 = model(inp, labels=inp)
+            out1.loss.backward()
+            grads1 = [p.grad.clone() for p in model.parameters()]
+
+            # Reset grads
+            for p in model.parameters():
+                p.grad = None
+
+            # Second forward-backward with NoOpManager
+            with NoOpManager():
+                torch.manual_seed(42)
+                out2 = model(inp, labels=inp)
+                out2.loss.backward()
+
+            grads2 = [p.grad.clone() for p in model.parameters()]
+
+        # Gradients should match as NoOpManager should have prevented offloading
+        for g1, g2 in zip(grads1, grads2, strict=True):
+            torch.testing.assert_close(g1, g2, rtol=1e-4, atol=1e-5)
+
+    @require_torch_accelerator
+    def test_min_offload_size(self):
+        """Test that tensors smaller than min_offload_size aren't offloaded"""
+        model = nn.Sequential(
+            nn.Linear(5, 5),  # Small layer that shouldn't be offloaded
+            nn.Linear(5, 1000),  # Large layer that should be offloaded
+        ).to(torch_device)
+
+        inp = torch.randn(2, 5, device=torch_device)
+
+        with OffloadActivations(min_offload_size=1000):
+            out = model(inp)
+            out.sum().backward()
+
+        # The test passes if no errors occur, as we're mainly testing
+        # that the logic handles both offloaded and non-offloaded tensors
+
+    @require_torch_accelerator
+    def test_real_hf_model(self):
+        """Test with an actual HuggingFace model"""
+        model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        model = AutoModelForCausalLM.from_pretrained(model_id).to(torch_device)
+
+        # Create small input
+        inp = torch.randint(0, 100, (2, 10), device=torch_device)
+
+        # Baseline without offloading
+        torch.manual_seed(42)
+        out1 = model(inp, labels=inp).loss
+        out1.backward()
+        grads1 = [p.grad.clone() for p in model.parameters()]
+
+        # Reset grads
+        for p in model.parameters():
+            p.grad = None
+
+        # With offloading
+        with OffloadActivations():
+            torch.manual_seed(42)
+            out2 = model(inp, labels=inp).loss
+            out2.backward()
+
+        grads2 = [p.grad.clone() for p in model.parameters()]
+
+        # Check outputs and gradients match
+        torch.testing.assert_close(out1, out2)
+        for g1, g2 in zip(grads1, grads2, strict=True):
+            torch.testing.assert_close(g1, g2)
+
+    @require_torch_accelerator
+    def test_tensor_deduplication(self):
+        """Test that deduplication works correctly for tensors sharing storage"""
+
+        class ModelWithViews(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.linear = nn.Linear(100, 100)
+
+            def forward(self, x):
+                out = self.linear(x)
+                view1 = out.view(-1)
+                view2 = out.transpose(0, 1)
+                return view1.sum() + view2.sum()
+
+        model = ModelWithViews().to(torch_device)
+        offload_ctx = OffloadActivations(min_offload_size=1)
+        offload_ctx.update_model_params(model)
+
+        x = torch.randn(10, 100, device=torch_device, requires_grad=True)
+        with offload_ctx:
+            loss = model(x)
+
+        total_tensor_ids = offload_ctx.tensor_id
+        assert total_tensor_ids > 0, "Should have created tensor IDs"
+
+        # modified=True means offloaded to CPU, modified=False means kept on GPU (deduplicated)
+        deduplicated_count = sum(1 for _, modified, _, _, _ in offload_ctx.tracker.values() if not modified)
+        offloaded_count = sum(1 for _, modified, _, _, _ in offload_ctx.tracker.values() if modified)
+
+        assert offloaded_count > 0, "Should have offloaded at least one tensor"
+        assert deduplicated_count > 0, "Should have deduplicated at least one tensor (view)"
+
+        unique_storages_offloaded = len(offload_ctx.storage_to_tensor_id)
+        assert unique_storages_offloaded < total_tensor_ids, (
+            f"Deduplication should result in fewer storages ({unique_storages_offloaded}) "
+            f"than total tensors ({total_tensor_ids})"
+        )
+
+        loss.backward()
+
+    @require_torch_accelerator
+    def test_stale_tracker_state_is_cleared_between_forwards(self):
+        """Test that tensors from unused graph branches don't accumulate across steps."""
+
+        class ModelWithUnusedBranch(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.used = nn.Linear(8, 8)
+                self.unused = nn.Linear(8, 8)
+
+            def forward(self, x):
+                return self.used(x).sum(), self.unused(x).sum()
+
+        model = ModelWithUnusedBranch().to(torch_device)
+        offload_ctx = OffloadActivations(use_pin_memory=False, use_streams=False, min_offload_size=1)
+        offload_ctx.update_model_params(model)
+        inp = torch.randn(4, 8, device=torch_device)
+
+        tracker_counts = []
+        for _ in range(3):
+            model.zero_grad(set_to_none=True)
+            with offload_ctx:
+                loss, _ = model(inp)
+            loss.backward()
+            tracker_counts.append(len(offload_ctx.tracker))
+
+        assert tracker_counts == [tracker_counts[0]] * len(tracker_counts)
+
+    @require_torch_accelerator
+    def test_parameter_filtering(self):
+        """Test that model parameters are filtered during offloading"""
+        model = nn.Sequential(nn.Linear(10, 20), nn.Linear(20, 10)).to(torch_device)
+        offload_ctx = OffloadActivations()
+        offload_ctx.update_model_params(model)
+
+        assert len(offload_ctx.param_storages) > 0, "Should have tracked parameter storages"
+
+        param_ptrs = {p.data.untyped_storage().data_ptr() for p in model.parameters()}
+        assert offload_ctx.param_storages == param_ptrs, "Tracked storages should match parameter storages"

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_callbacks.py

@@ -0,0 +1,238 @@
+# 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 os
+from unittest.mock import call, patch
+
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig, Trainer, TrainingArguments
+
+from trl import BEMACallback, LogCompletionsCallback
+
+from .testing_utils import TrlTestCase, require_comet, require_wandb
+
+
+class TestLogCompletionsCallback(TrlTestCase):
+    def setup_method(self):
+        self.model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5")
+        self.tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5")
+        self.tokenizer.pad_token = self.tokenizer.eos_token
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only")
+        dataset["train"] = dataset["train"].select(range(8))
+
+        def tokenize_function(examples):
+            out = self.tokenizer(examples["prompt"], padding="max_length", max_length=16, truncation=True)
+            out["labels"] = out["input_ids"].copy()
+            return out
+
+        self.dataset = dataset.map(tokenize_function, batched=True)
+
+        self.generation_config = GenerationConfig(max_length=32)
+
+    @require_wandb
+    def test_basic_wandb(self):
+        import wandb
+
+        training_args = TrainingArguments(
+            output_dir=self.tmp_dir,
+            eval_strategy="steps",
+            eval_steps=2,  # evaluate every 2 steps
+            per_device_train_batch_size=2,  # 8 samples in total so 4 batches of 2 per epoch
+            per_device_eval_batch_size=2,
+            report_to="wandb",
+        )
+        trainer = Trainer(
+            model=self.model,
+            args=training_args,
+            train_dataset=self.dataset["train"],
+            eval_dataset=self.dataset["test"],
+            processing_class=self.tokenizer,
+        )
+        completions_callback = LogCompletionsCallback(trainer, self.generation_config, num_prompts=2)
+        trainer.add_callback(completions_callback)
+        trainer.train()
+
+        # Get the current run
+        completions_path = wandb.run.summary.completions["path"]
+        json_path = os.path.join(wandb.run.dir, completions_path)
+        with open(json_path) as f:
+            completions = json.load(f)
+
+        # Check that the columns are correct
+        assert "step" in completions["columns"]
+        assert "prompt" in completions["columns"]
+        assert "completion" in completions["columns"]
+
+        # Check that the prompt is in the log
+        assert self.dataset["test"][0]["prompt"] in completions["data"][0]
+
+    @require_comet
+    def test_basic_comet(self):
+        import comet_ml
+
+        training_args = TrainingArguments(
+            output_dir=self.tmp_dir,
+            eval_strategy="steps",
+            eval_steps=2,  # evaluate every 2 steps
+            per_device_train_batch_size=2,  # 8 samples in total so 4 batches of 2 per epoch
+            per_device_eval_batch_size=2,
+            report_to="comet_ml",
+        )
+        trainer = Trainer(
+            model=self.model,
+            args=training_args,
+            train_dataset=self.dataset["train"],
+            eval_dataset=self.dataset["test"],
+            processing_class=self.tokenizer,
+        )
+        completions_callback = LogCompletionsCallback(trainer, self.generation_config, num_prompts=2)
+        trainer.add_callback(completions_callback)
+        trainer.train()
+
+        # close experiment to make sure all pending data are flushed
+        experiment = comet_ml.get_running_experiment()
+        assert experiment is not None
+        experiment.end()
+
+        # get experiment assets and check that all required tables was logged
+        steps = len(self.dataset["train"]) + len(self.dataset["test"])
+        tables_logged = int(steps / 2) + 1  # +1 to include zero step
+
+        api_experiment = comet_ml.APIExperiment(previous_experiment=experiment.id)
+        tables = api_experiment.get_asset_list("dataframe")
+        assert tables is not None
+        assert len(tables) == tables_logged
+        assert all(table["fileName"] == "completions.csv" for table in tables)
+
+
+class TestBEMACallback(TrlTestCase):
+    def setup_method(self):
+        self.model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5")
+        self.tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5")
+        self.tokenizer.pad_token = self.tokenizer.eos_token
+        dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling")
+
+        def tokenize_function(examples, tokenizer):
+            out = tokenizer(examples["text"], padding="max_length", max_length=17)
+            out["labels"] = out["input_ids"].copy()
+            return out
+
+        self.dataset = dataset.map(
+            tokenize_function, fn_kwargs={"tokenizer": self.tokenizer}, remove_columns=["text"], batched=True
+        )
+
+    def test_model_saved(self):
+        """Test that BEMACallback saves the BEMA model."""
+        training_args = TrainingArguments(output_dir=self.tmp_dir, report_to="none")
+        bema_callback = BEMACallback(update_freq=2)
+        trainer = Trainer(
+            model=self.model,
+            args=training_args,
+            train_dataset=self.dataset["train"],
+            processing_class=self.tokenizer,
+            callbacks=[bema_callback],
+        )
+        trainer.train()
+
+        # Check that the BEMA model was saved and can be loaded
+        bema_path = os.path.join(self.tmp_dir, "bema")
+        assert os.path.isdir(bema_path), "BEMA directory was not created"
+        AutoModelForCausalLM.from_pretrained(bema_path)
+
+    def test_update_frequency_0(self):
+        """Test that BEMA callback respects the update frequency."""
+        training_args = TrainingArguments(output_dir=self.tmp_dir, report_to="none")
+        bema_callback = BEMACallback(update_freq=2)
+
+        with patch.object(bema_callback, "_update_bema_weights") as mock_update:
+            trainer = Trainer(
+                model=self.model,
+                args=training_args,
+                train_dataset=self.dataset["train"],
+                processing_class=self.tokenizer,
+                callbacks=[bema_callback],
+            )
+
+            trainer.train()
+
+            # Total 9 steps (17 samples, batch size 8, 3 epochs).
+            # BEMA starts after step 0 and updates every 2 steps → updates at 2, 4, 5, 8
+            assert mock_update.call_args_list == [call(2), call(4), call(6), call(8)]
+
+    def test_update_frequency_1(self):
+        """Test that BEMA callback respects the update frequency."""
+        training_args = TrainingArguments(output_dir=self.tmp_dir, report_to="none")
+        bema_callback = BEMACallback(update_freq=3)
+
+        with patch.object(bema_callback, "_update_bema_weights") as mock_update:
+            trainer = Trainer(
+                model=self.model,
+                args=training_args,
+                train_dataset=self.dataset["train"],
+                processing_class=self.tokenizer,
+                callbacks=[bema_callback],
+            )
+
+            trainer.train()
+
+            # Total 9 steps (17 samples, batch size 8, 3 epochs).
+            # BEMA starts after step 0 and updates every 3 steps → updates at 3, 6, 9
+            assert mock_update.call_args_list == [call(3), call(6), call(9)]
+
+    def test_update_frequency_2(self):
+        """Test that BEMA callback respects the update frequency."""
+        training_args = TrainingArguments(output_dir=self.tmp_dir, report_to="none")
+        bema_callback = BEMACallback(update_freq=2, update_after=3)
+
+        with patch.object(bema_callback, "_update_bema_weights") as mock_update:
+            trainer = Trainer(
+                model=self.model,
+                args=training_args,
+                train_dataset=self.dataset["train"],
+                processing_class=self.tokenizer,
+                callbacks=[bema_callback],
+            )
+
+            trainer.train()
+
+            # Total 9 steps (17 samples, batch size 8, 3 epochs).
+            # BEMA starts after step 3 and updates every 2 steps → updates at 5, 7, 9
+            assert mock_update.call_args_list == [call(5), call(7), call(9)]
+
+    def test_no_bema(self):
+        """Test that BEMACallback works without BEMA updates."""
+        training_args = TrainingArguments(output_dir=self.tmp_dir, report_to="none")
+        bema_callback = BEMACallback(update_freq=2, bias_power=0.0)
+        trainer = Trainer(
+            model=self.model,
+            args=training_args,
+            train_dataset=self.dataset["train"],
+            processing_class=self.tokenizer,
+            callbacks=[bema_callback],
+        )
+        trainer.train()
+
+    def test_no_ema(self):
+        """Test that BEMACallback works without EMA updates."""
+        training_args = TrainingArguments(output_dir=self.tmp_dir, report_to="none")
+        bema_callback = BEMACallback(update_freq=2, ema_power=0.0)
+        trainer = Trainer(
+            model=self.model,
+            args=training_args,
+            train_dataset=self.dataset["train"],
+            processing_class=self.tokenizer,
+            callbacks=[bema_callback],
+        )
+        trainer.train()

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_chat_template_utils.py

@@ -0,0 +1,1258 @@
+# 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 copy
+import textwrap
+
+import pytest
+import transformers
+from packaging.version import Version
+from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification, AutoProcessor, AutoTokenizer
+
+from trl import clone_chat_template
+from trl.chat_template_utils import (
+    add_response_schema,
+    get_training_chat_template,
+    is_chat_template_prefix_preserving,
+    is_chat_template_stop_token_trained,
+    parse_response,
+    supports_tool_calling,
+)
+from trl.data_utils import prepare_multimodal_messages
+
+from .testing_utils import TrlTestCase, require_jmespath, require_vision
+
+
+class TestCloneChatTemplate(TrlTestCase):
+    def test_clone(self):
+        # This tokenizer doesn't have a chat_template by default
+        tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-BloomForCausalLM")
+        model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-BloomForCausalLM")
+        # This one has a chat_template by default
+        source = "trl-internal-testing/tiny-Qwen3ForCausalLM"
+        _, modified_tokenizer, _ = clone_chat_template(model, tokenizer, source)
+
+        # Check if special tokens are correctly set
+        assert modified_tokenizer.eos_token == "<|im_end|>"
+
+    def test_clone_with_resize(self):
+        # This tokenizer doesn't have a chat_template by default
+        tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-BloomForCausalLM")
+        model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-BloomForCausalLM")
+        # This one has a chat_template by default
+        source = "trl-internal-testing/tiny-Qwen3ForCausalLM"
+        modified_model, modified_tokenizer, _ = clone_chat_template(
+            model, tokenizer, source, resize_to_multiple_of=123
+        )
+
+        # Check that the input embeddings have been resized to a multiple of 123
+        assert (modified_model.vocab_size % 123) == 0
+        # Check that the input embeddings size matches the tokenizer vocabulary size
+        assert model.vocab_size == len(modified_tokenizer.vocab)
+
+    def test_clone_with_resize_and_extra_tokens_already_in_vocab(self):
+        # This tokenizer doesn't have a chat_template by default
+        tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-BloomForCausalLM")
+        model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-BloomForCausalLM")
+        # This one has a chat_template by default
+        source = "trl-internal-testing/tiny-Qwen3ForCausalLM"
+        # This will add <extra_id_0>, <extra_id_1>, ... to the tokenizer
+        modified_model, modified_tokenizer, _ = clone_chat_template(
+            model, tokenizer, source, resize_to_multiple_of=123
+        )
+        # Try if we can resize a tokenizer that already has extra these extra tokens
+        modified_model, modified_tokenizer, _ = clone_chat_template(
+            modified_model, modified_tokenizer, source, resize_to_multiple_of=124
+        )
+
+        # Check that the input embeddings have been resized to a multiple of 123
+        assert (modified_model.vocab_size % 124) == 0
+        # Check that the input embeddings size matches the tokenizer vocabulary size
+        assert model.vocab_size == len(modified_tokenizer.vocab)
+
+    def test_apply_new_chat_template(self):
+        # This tokenizer doesn't have a chat_template by default
+        tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-BloomForCausalLM")
+        model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-BloomForCausalLM")
+        # This one has a chat_template by default
+        source = "trl-internal-testing/tiny-Qwen3ForCausalLM"
+        _, modified_tokenizer, _ = clone_chat_template(model, tokenizer, source)
+        messages = [
+            {"role": "system", "content": "You are helpful"},
+            {"role": "user", "content": "Hello"},
+            {"role": "assistant", "content": "Hi, how can I help you?"},
+        ]
+        prompt = modified_tokenizer.apply_chat_template(messages, tokenize=False)
+
+        assert (
+            prompt
+            == "<|im_start|>system\nYou are helpful<|im_end|>\n<|im_start|>user\nHello<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\nHi, how can I help you?<|im_end|>\n"
+        )
+
+    def test_clone_with_sequence_classification_model(self):
+        # This tokenizer doesn't have a chat_template by default
+        tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-GptNeoXForSequenceClassification")
+        model = AutoModelForSequenceClassification.from_pretrained(
+            "trl-internal-testing/tiny-GptNeoXForSequenceClassification"
+        )
+        # This one has a chat_template by default
+        source = "trl-internal-testing/tiny-Qwen3ForCausalLM"
+        _, modified_tokenizer, _ = clone_chat_template(model, tokenizer, source)
+
+        # Check if special tokens are correctly set
+        assert modified_tokenizer.eos_token == "<|im_end|>"
+
+
+@pytest.mark.xfail(
+    condition=Version(transformers.__version__) < Version("5.0.0"),
+    reason="Response parsing is not supported in transformers versions below 5.0.0",
+    strict=True,
+)
+@require_jmespath
+class TestAddResponseSchema:
+    @pytest.mark.parametrize(
+        "tokenizer_name",
+        [
+            pytest.param("trl-internal-testing/tiny-Glm4MoeForCausalLM", id="glm4moe"),
+            pytest.param(
+                "trl-internal-testing/tiny-GptOssForCausalLM",
+                id="gptoss",
+                marks=pytest.mark.xfail(
+                    Version(transformers.__version__) < Version("5.5.0"),
+                    reason="Upstream bug in response parsing (see #5753; fixed in transformers#45166)",
+                    strict=True,
+                ),
+            ),
+            pytest.param("trl-internal-testing/tiny-LlamaForCausalLM-3.1", id="llama3.1"),
+            pytest.param("trl-internal-testing/tiny-LlamaForCausalLM-3.2", id="llama3.2"),
+            pytest.param(
+                "trl-internal-testing/tiny-NemotronHForCausalLM-nano",
+                id="nemotron_3_nano",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.3.0"),
+                    reason="Nemotron 3 tokenizer requires transformers>=5.3.0",
+                ),
+            ),
+            pytest.param(
+                "trl-internal-testing/tiny-NemotronHForCausalLM-super",
+                id="nemotron_3_super",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.3.0"),
+                    reason="Nemotron 3 tokenizer requires transformers>=5.3.0",
+                ),
+            ),
+            pytest.param(
+                "trl-internal-testing/tiny-NemotronHForCausalLM-ultra",
+                id="nemotron_3_ultra",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.3.0"),
+                    reason="Nemotron 3 tokenizer requires transformers>=5.3.0",
+                ),
+            ),
+            pytest.param("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", id="qwen2.5"),
+            pytest.param("trl-internal-testing/tiny-Qwen3MoeForCausalLM", id="qwen3"),
+            pytest.param("trl-internal-testing/tiny-Qwen3ForCausalLM-Instruct-2507", id="qwen3_instruct_2507"),
+        ],
+    )
+    def test_add_response_schema(self, tokenizer_name):
+        tokenizer = AutoTokenizer.from_pretrained(tokenizer_name)
+        tokenizer = add_response_schema(tokenizer)
+        messages = [
+            {"role": "user", "content": "What is 3*4?"},
+            {
+                "role": "assistant",
+                "tool_calls": [{"type": "function", "function": {"name": "multiply", "arguments": {"a": 3, "b": 4}}}],
+            },
+        ]
+        prefix = tokenizer.apply_chat_template(messages[:1], tokenize=False, add_generation_prompt=True)
+        text = tokenizer.apply_chat_template(messages, tokenize=False)
+        response = text[len(prefix) :]
+        # Here, we just test that the parsing doesn't raise an error.
+        # The correctness of the parsing is tested in TestParseResponse
+        tokenizer.parse_response(response)
+
+    @pytest.mark.parametrize(
+        "processor_name",
+        [
+            pytest.param("trl-internal-testing/tiny-Qwen3VLForConditionalGeneration", id="qwen3_vl"),
+            pytest.param("trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink", id="qwen35-nothink"),
+            pytest.param("trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-Think", id="qwen35-think"),
+            pytest.param("trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6", id="qwen36"),
+        ],
+    )
+    def test_add_response_schema_vlm(self, processor_name):
+        # For VLM processors, `add_response_schema` must set the schema on the inner tokenizer, since
+        # `parse_response` is a tokenizer method that reads `self.response_schema` from the tokenizer instance.
+        processor = AutoProcessor.from_pretrained(processor_name)
+        processor = add_response_schema(processor)
+        assert processor.tokenizer.response_schema is not None
+        messages = [
+            {"role": "user", "content": [{"type": "text", "text": "What is 3*4?"}]},
+            {
+                "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": [{"type": "text", "text": ""}],
+                "tool_calls": [{"type": "function", "function": {"name": "multiply", "arguments": {"a": 3, "b": 4}}}],
+            },
+        ]
+        prefix = processor.apply_chat_template(messages[:1], tokenize=False, add_generation_prompt=True)
+        text = processor.apply_chat_template(messages, tokenize=False)
+        response = text[len(prefix) :]
+        # Here, we just test that the parsing doesn't raise an error.
+        # The correctness of the parsing is tested in TestParseResponse
+        processor.tokenizer.parse_response(response)
+
+
+class TestSupportsToolCalling:
+    @pytest.mark.parametrize(
+        "model_id",
+        [
+            pytest.param("trl-internal-testing/tiny-DeepseekV3ForCausalLM", id="deepseekv3"),
+            pytest.param("trl-internal-testing/tiny-DeepseekV3ForCausalLM-0528", id="deepseekv3-0528"),
+            pytest.param(
+                "trl-internal-testing/tiny-Gemma4ForConditionalGeneration",
+                id="gemma4",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.5.0"),
+                    reason="Gemma4 models were introduced in transformers-5.5.0",
+                ),
+            ),
+            pytest.param(
+                "trl-internal-testing/tiny-Glm4MoeForCausalLM",
+                id="glm4moe",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.0.0"),
+                    reason="GLM4 tokenizer requires transformers>=5.0.0",
+                ),
+            ),
+            pytest.param("trl-internal-testing/tiny-GptOssForCausalLM", id="gptoss"),
+            pytest.param("trl-internal-testing/tiny-LlamaForCausalLM-3.1", id="llama3.1"),
+            pytest.param("trl-internal-testing/tiny-LlamaForCausalLM-3.2", id="llama3.2"),
+            pytest.param(
+                "trl-internal-testing/tiny-NemotronHForCausalLM-nano",
+                id="nemotron_3_nano",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.3.0"),
+                    reason="Nemotron 3 tokenizer requires transformers>=5.3.0",
+                ),
+            ),
+            pytest.param(
+                "trl-internal-testing/tiny-NemotronHForCausalLM-super",
+                id="nemotron_3_super",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.3.0"),
+                    reason="Nemotron 3 tokenizer requires transformers>=5.3.0",
+                ),
+            ),
+            pytest.param(
+                "trl-internal-testing/tiny-NemotronHForCausalLM-ultra",
+                id="nemotron_3_ultra",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.3.0"),
+                    reason="Nemotron 3 tokenizer requires transformers>=5.3.0",
+                ),
+            ),
+            pytest.param("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", id="qwen2.5"),
+            pytest.param("trl-internal-testing/tiny-Qwen3ForCausalLM", id="qwen3"),
+            pytest.param("trl-internal-testing/tiny-Qwen3ForCausalLM-Instruct-2507", id="qwen3_instruct_2507"),
+            pytest.param("trl-internal-testing/tiny-Qwen3MoeForCausalLM", id="qwen3moe"),
+            pytest.param(
+                "trl-internal-testing/tiny-Qwen3VLForConditionalGeneration",
+                id="qwen3_vl",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("4.57.0"),
+                    reason="Qwen3-VL was introduced in transformers-4.57.0",
+                ),
+            ),
+            pytest.param(
+                "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink",
+                id="qwen35-nothink",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.0.0"),
+                    reason="Qwen3.5 tokenizer requires transformers>=5.0.0",
+                ),
+            ),
+            pytest.param(
+                "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-Think",
+                id="qwen35-think",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.0.0"),
+                    reason="Qwen3.5 tokenizer requires transformers>=5.0.0",
+                ),
+            ),
+            pytest.param(
+                "trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6",
+                id="qwen36",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.0.0"),
+                    reason="Qwen3.5 tokenizer requires transformers>=5.0.0",
+                ),
+            ),
+        ],
+    )
+    def test_supports_tool_calling(self, model_id):
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        assert supports_tool_calling(tokenizer) is True
+
+    @pytest.mark.parametrize(
+        "model_id",
+        [
+            # No chat template
+            pytest.param("trl-internal-testing/tiny-BartModel", id="bart"),
+            pytest.param("trl-internal-testing/tiny-BloomForCausalLM", id="bloom"),
+            pytest.param("trl-internal-testing/tiny-GPT2LMHeadModel", id="gpt2"),
+            pytest.param("trl-internal-testing/tiny-GPTNeoXForCausalLM", id="gptneox"),
+            pytest.param("trl-internal-testing/tiny-GptNeoXForSequenceClassification", id="gptneox-seq"),
+            pytest.param("trl-internal-testing/tiny-OPTForCausalLM", id="opt"),
+            pytest.param("trl-internal-testing/tiny-T5ForConditionalGeneration", id="t5"),
+            # TemplateError: rejects tool role sequence
+            pytest.param("trl-internal-testing/tiny-CohereForCausalLM", id="cohere"),
+            pytest.param("trl-internal-testing/tiny-FalconMambaForCausalLM", id="falconmamba"),
+            pytest.param("trl-internal-testing/tiny-GemmaForCausalLM", id="gemma"),
+            pytest.param("trl-internal-testing/tiny-Gemma2ForCausalLM", id="gemma2"),
+            pytest.param("trl-internal-testing/tiny-Gemma3ForConditionalGeneration", id="gemma3"),
+            pytest.param("trl-internal-testing/tiny-Idefics2ForConditionalGeneration", id="idefics2"),
+            pytest.param("trl-internal-testing/tiny-Idefics3ForConditionalGeneration", id="idefics3"),
+            pytest.param("trl-internal-testing/tiny-LlavaNextForConditionalGeneration", id="llava_next"),
+            pytest.param("trl-internal-testing/tiny-MistralForCausalLM-0.1", id="mistral0.1"),
+            pytest.param("trl-internal-testing/tiny-MistralForCausalLM-0.2", id="mistral0.2"),
+            pytest.param("trl-internal-testing/tiny-SmolVLMForConditionalGeneration", id="smolvlm"),
+            # Silently drops both tool_calls and tool messages
+            pytest.param("trl-internal-testing/tiny-Cohere2ForCausalLM", id="cohere2"),
+            pytest.param("trl-internal-testing/tiny-LlavaForConditionalGeneration", id="llava"),
+            # Olmo3 uses a bespoke function-calling schema (a `functions`/`function_calls` string on the
+            # message plus an `environment` role) instead of the standard `tools`/`tool_calls`/`tool`
+            # interface, so a standard tool-calling conversation is silently dropped.
+            pytest.param(
+                "trl-internal-testing/tiny-Olmo3ForCausalLM",
+                id="olmo3",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("4.57.0"),
+                    reason="Olmo 3 was introduced in transformers>=4.57.0",
+                ),
+            ),
+            pytest.param("trl-internal-testing/tiny-Phi3ForCausalLM-3", id="phi3"),
+            pytest.param("trl-internal-testing/tiny-Phi3ForCausalLM-3.5", id="phi3.5"),
+            # Renders tool message content as plain text but drops assistant tool_calls
+            pytest.param("trl-internal-testing/tiny-LlamaForCausalLM-3", id="llama3"),
+            pytest.param("trl-internal-testing/tiny-Qwen2VLForConditionalGeneration", id="qwen2_vl"),
+            pytest.param("trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", id="qwen2.5_vl"),
+        ],
+    )
+    def test_does_not_support_tool_calling(self, model_id):
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        assert supports_tool_calling(tokenizer) is False
+
+
+class TestIsChatTemplatePrefixPreserving:
+    def test_prefix_preserving_template(self):
+        tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen3MoeForCausalLM")
+        # docstyle-ignore
+        tokenizer.chat_template = textwrap.dedent(r"""
+        {%- for message in messages %}
+
+        {%- if message.role == 'user' %}
+            {{- '<|im_start|>user\n' + message.content + '<|im_end|>\n' }}
+        {%- elif message.role == 'assistant' %}
+            {{- '<|im_start|>assistant\n' + message.content }}
+            {%- if message.tool_calls %}
+                {%- for tool_call in message.tool_calls %}
+                    {%- if tool_call.function %}
+                        {%- set tool_call = tool_call.function %}
+                    {%- endif %}
+                    {{- '<tool_call>' + tool_call.name + '</tool_call>' }}
+                {%- endfor %}
+            {%- endif %}
+            {{- '<|im_end|>\n' }}
+        {%- elif message.role == 'tool' %}
+            {{- '<|im_start|>tool\n' + message.content + '<|im_end|>\n' }}
+        {%- endif %}
+
+        {%- endfor %}
+
+        {%- if add_generation_prompt %}
+            {{- '<|im_start|>assistant\n' }}
+        {%- endif %}""")
+        assert is_chat_template_prefix_preserving(tokenizer) is True
+
+    def test_non_prefix_preserving_template(self):
+        tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen3MoeForCausalLM")
+        # The following template is quite typical of models like Qwen3 and GPT-OSS, where the thinking part (even
+        # empty) is only present for last assistant message, which makes it non-prefix-preserving: appending a tool
+        # message changes the earlier output.
+        # docstyle-ignore
+        tokenizer.chat_template = textwrap.dedent(r"""
+        {%- if messages[0].role == 'system' %}
+            {{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }}
+        {%- endif %}
+        {%- set ns = namespace(last_query_index=messages|length - 1) %}
+        {%- for message in messages[::-1] %}
+            {%- set index = (messages|length - 1) - loop.index0 %}
+            {%- if message.role == "user" and message.content is string %}
+                {%- set ns.last_query_index = index %}
+                {%- break %}
+            {%- endif %}
+        {%- endfor %}
+        {%- for message in messages %}
+            {%- set content = message.content if message.content is string else '' %}
+            {%- if message.role == "user" or (message.role == "system" and not loop.first) %}
+                {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>\n' }}
+            {%- elif message.role == "assistant" %}
+                {%- set reasoning_content = '' %}
+                {%- if message.reasoning_content is string %}
+                    {%- set reasoning_content = message.reasoning_content %}
+                {%- else %}
+                    {%- if '</think>' in content %}
+                        {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                        {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+                    {%- endif %}
+                {%- endif %}
+                {%- if loop.index0 > ns.last_query_index %}
+                    {%- if loop.last or (not loop.last and reasoning_content) %}
+                        {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content.strip('\n') + '\n</think>\n\n' + content.lstrip('\n') }}
+                    {%- else %}
+                        {{- '<|im_start|>' + message.role + '\n' + content }}
+                    {%- endif %}
+                {%- else %}
+                    {{- '<|im_start|>' + message.role + '\n' + content }}
+                {%- endif %}
+                {%- if message.tool_calls %}
+                    {%- for tool_call in message.tool_calls %}
+                        {%- if tool_call.function %}
+                            {%- set tool_call = tool_call.function %}
+                        {%- endif %}
+                        {{- '<tool_call>' + tool_call.name + '</tool_call>' }}
+                    {%- endfor %}
+                {%- endif %}
+                {{- '<|im_end|>\n' }}
+            {%- elif message.role == "tool" %}
+                {{- '<|im_start|>tool\n' + content + '<|im_end|>\n' }}
+            {%- endif %}
+        {%- endfor %}
+        {%- if add_generation_prompt %}
+            {{- '<|im_start|>assistant\n' }}
+            {%- if enable_thinking is defined and enable_thinking is false %}
+                {{- '<think>\n\n</think>\n\n' }}
+            {%- endif %}
+        {%- endif %}""")
+        assert is_chat_template_prefix_preserving(tokenizer) is False
+
+    @require_vision
+    def test_prefix_preserving_template_processor(self):
+        processor = AutoProcessor.from_pretrained("trl-internal-testing/tiny-Qwen3VLForConditionalGeneration")
+        # Simple prefix-preserving template that mirrors how Qwen-VL templates emit image tokens: a list-of-blocks
+        # content is iterated, and `{"type": "image"}` blocks are rendered as `<|vision_start|><|image_pad|><|vision_end|>`.
+        # docstyle-ignore
+        processor.chat_template = textwrap.dedent(r"""
+        {%- for message in messages %}
+
+        {%- if message.role == 'user' %}
+            {{- '<|im_start|>user\n' }}
+            {%- if message.content is string %}
+                {{- message.content }}
+            {%- else %}
+                {%- for content in message.content %}
+                    {%- if content.type == 'image' or 'image' in content %}
+                        {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
+                    {%- elif 'text' in content %}
+                        {{- content.text }}
+                    {%- endif %}
+                {%- endfor %}
+            {%- endif %}
+            {{- '<|im_end|>\n' }}
+        {%- elif message.role == 'assistant' %}
+            {{- '<|im_start|>assistant\n' }}
+            {%- if message.content is string %}
+                {{- message.content }}
+            {%- else %}
+                {%- for content in message.content %}
+                    {%- if 'text' in content %}
+                        {{- content.text }}
+                    {%- endif %}
+                {%- endfor %}
+            {%- endif %}
+            {%- if message.tool_calls %}
+                {%- for tool_call in message.tool_calls %}
+                    {%- if tool_call.function %}
+                        {%- set tool_call = tool_call.function %}
+                    {%- endif %}
+                    {{- '<tool_call>' + tool_call.name + '</tool_call>' }}
+                {%- endfor %}
+            {%- endif %}
+            {{- '<|im_end|>\n' }}
+        {%- elif message.role == 'tool' %}
+            {{- '<|im_start|>tool\n' }}
+            {%- if message.content is string %}
+                {{- message.content }}
+            {%- else %}
+                {%- for content in message.content %}
+                    {%- if 'text' in content %}
+                        {{- content.text }}
+                    {%- endif %}
+                {%- endfor %}
+            {%- endif %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+
+        {%- endfor %}
+
+        {%- if add_generation_prompt %}
+            {{- '<|im_start|>assistant\n' }}
+        {%- endif %}""")
+        assert is_chat_template_prefix_preserving(processor) is True
+
+
+class TestIsChatTemplateStopTokenTrained:
+    def test_stop_token_trained(self):
+        tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen3MoeForCausalLM")
+        # The assistant turn is closed by <|im_end|> inside the generation span, so the end-of-turn token is masked
+        # in and the model is trained to stop.
+        # docstyle-ignore
+        tokenizer.chat_template = textwrap.dedent(r"""
+        {%- for message in messages %}
+        {%- if message.role == 'user' %}
+            {{- '<|im_start|>user\n' + message.content + '<|im_end|>\n' }}
+        {%- elif message.role == 'assistant' %}
+            {{- '<|im_start|>assistant\n' }}
+            {%- generation %}{{- message.content + '<|im_end|>' }}{%- endgeneration %}
+            {{- '\n' }}
+        {%- endif %}
+        {%- endfor %}
+        {%- if add_generation_prompt %}
+            {{- '<|im_start|>assistant\n' }}
+        {%- endif %}""")
+        assert is_chat_template_stop_token_trained(tokenizer) is True
+
+    def test_stop_token_not_trained(self):
+        tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen3MoeForCausalLM")
+        # GLM-style: the assistant's end-of-turn token is emitted as the prefix of the following message, so the
+        # generation span covers content only and the model is never trained to stop.
+        # docstyle-ignore
+        tokenizer.chat_template = textwrap.dedent(r"""
+        {%- for message in messages %}
+        {%- if message.role == 'user' %}
+            {{- '<|im_start|>user\n' + message.content + '<|im_end|>\n' }}
+        {%- elif message.role == 'assistant' %}
+            {{- '<|im_start|>assistant\n' }}
+            {%- generation %}{{- message.content }}{%- endgeneration %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+        {%- endfor %}
+        {%- if add_generation_prompt %}
+            {{- '<|im_start|>assistant\n' }}
+        {%- endif %}""")
+        assert is_chat_template_stop_token_trained(tokenizer) is False
+
+    def test_template_error_returns_false(self):
+        tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen3MoeForCausalLM")
+        tokenizer.chat_template = "{{ raise_exception('probe rejected') }}"
+        assert is_chat_template_stop_token_trained(tokenizer) is False
+
+
+@pytest.mark.parametrize(
+    "tokenizer_name",
+    [
+        pytest.param("trl-internal-testing/tiny-CohereForCausalLM", id="cohere"),
+        pytest.param("trl-internal-testing/tiny-Cohere2ForCausalLM", id="cohere2"),
+        pytest.param("trl-internal-testing/tiny-DeepseekV3ForCausalLM", id="deepseekv3"),
+        pytest.param("trl-internal-testing/tiny-GemmaForCausalLM", id="gemma"),
+        pytest.param("trl-internal-testing/tiny-Gemma2ForCausalLM", id="gemma2"),
+        pytest.param("trl-internal-testing/tiny-Gemma3ForConditionalGeneration", id="gemma3", marks=require_vision),
+        pytest.param(
+            "trl-internal-testing/tiny-Glm4MoeForCausalLM",
+            id="glm4moe",
+            marks=pytest.mark.skipif(
+                Version(transformers.__version__) < Version("5.0.0"),
+                reason="GLM4 tokenizer requires transformers>=5.0.0",
+            ),
+        ),
+        pytest.param("trl-internal-testing/tiny-GptOssForCausalLM", id="gptoss"),
+        pytest.param(
+            "trl-internal-testing/tiny-Idefics3ForConditionalGeneration", id="idefics3", marks=require_vision
+        ),
+        pytest.param("trl-internal-testing/tiny-LlamaForCausalLM-3", id="llama3"),
+        pytest.param("trl-internal-testing/tiny-LlavaForConditionalGeneration", id="llava", marks=require_vision),
+        pytest.param(
+            "trl-internal-testing/tiny-LlavaNextForConditionalGeneration", id="llava_next", marks=require_vision
+        ),
+        pytest.param(
+            "trl-internal-testing/tiny-NemotronHForCausalLM-nano",
+            id="nemotron_3_nano",
+            marks=pytest.mark.skipif(
+                Version(transformers.__version__) < Version("5.3.0"),
+                reason="Nemotron 3 tokenizer requires transformers>=5.3.0",
+            ),
+        ),
+        pytest.param(
+            "trl-internal-testing/tiny-NemotronHForCausalLM-super",
+            id="nemotron_3_super",
+            marks=pytest.mark.skipif(
+                Version(transformers.__version__) < Version("5.3.0"),
+                reason="Nemotron 3 tokenizer requires transformers>=5.3.0",
+            ),
+        ),
+        pytest.param(
+            "trl-internal-testing/tiny-NemotronHForCausalLM-ultra",
+            id="nemotron_3_ultra",
+            marks=pytest.mark.skipif(
+                Version(transformers.__version__) < Version("5.3.0"),
+                reason="Nemotron 3 tokenizer requires transformers>=5.3.0",
+            ),
+        ),
+        pytest.param("trl-internal-testing/tiny-Phi3ForCausalLM-3", id="phi3"),
+        pytest.param("trl-internal-testing/tiny-Phi3ForCausalLM-3.5", id="phi3.5"),
+        pytest.param("trl-internal-testing/tiny-Qwen2VLForConditionalGeneration", id="qwen2_vl", marks=require_vision),
+        pytest.param("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", id="qwen2.5"),
+        pytest.param(
+            "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", id="qwen2.5_vl", marks=require_vision
+        ),
+        pytest.param("trl-internal-testing/tiny-Qwen3MoeForCausalLM", id="qwen3"),
+        pytest.param("trl-internal-testing/tiny-Qwen3ForCausalLM-Instruct-2507", id="qwen3_instruct_2507"),
+        pytest.param(
+            "trl-internal-testing/tiny-Qwen3VLForConditionalGeneration",
+            id="qwen3_vl",
+            marks=[
+                require_vision,
+                pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("4.57.0"),
+                    reason="Qwen3-VL was introduced in transformers-4.57.0",
+                ),
+            ],
+        ),
+        pytest.param(
+            "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink",
+            id="qwen35-nothink",
+            marks=[
+                require_vision,
+                pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.0.0"),
+                    reason="Qwen3.5 tokenizer requires transformers>=5.0.0",
+                ),
+            ],
+        ),
+        pytest.param(
+            "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-Think",
+            id="qwen35-think",
+            marks=[
+                require_vision,
+                pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.0.0"),
+                    reason="Qwen3.5 tokenizer requires transformers>=5.0.0",
+                ),
+            ],
+        ),
+        pytest.param(
+            "trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6",
+            id="qwen36",
+            marks=[
+                require_vision,
+                pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.0.0"),
+                    reason="Qwen3.5 tokenizer requires transformers>=5.0.0",
+                ),
+            ],
+        ),
+    ],
+)
+class TestGetTrainingChatTemplate:
+    def _load(self, model_name):
+        if "ForCausalLM" in model_name:
+            self.is_vlm = False
+            processing_class = AutoTokenizer.from_pretrained(model_name)
+        elif "ForConditionalGeneration" in model_name:
+            self.is_vlm = True
+            processing_class = AutoProcessor.from_pretrained(model_name)
+
+        return processing_class
+
+    def test_new_chat_template_is_prefix_preserving(self, tokenizer_name):
+        tokenizer = self._load(tokenizer_name)
+        new_chat_template = get_training_chat_template(tokenizer)
+        if new_chat_template is not None:
+            tokenizer.chat_template = new_chat_template
+        # Prefix-preservation is only meaningful for templates that actually support tool messages — the check
+        # itself renders one. Skip the assertion for tool-less templates (e.g. Gemma).
+        if not supports_tool_calling(tokenizer):
+            pytest.skip("Template does not support tool calling; prefix-preservation check is not applicable.")
+        assert is_chat_template_prefix_preserving(tokenizer) is True
+
+    def test_new_chat_template_trains_stop_token(self, tokenizer_name, request):
+        if tokenizer_name in (
+            "trl-internal-testing/tiny-LlavaForConditionalGeneration",
+            "trl-internal-testing/tiny-LlavaNextForConditionalGeneration",
+        ):
+            reason = f"{tokenizer_name}: the processor returns an all-zero assistant tokens mask"
+            request.node.add_marker(pytest.mark.xfail(strict=False, reason=reason))
+        tokenizer = self._load(tokenizer_name)
+        new_chat_template = get_training_chat_template(tokenizer)
+        assert is_chat_template_stop_token_trained(tokenizer, chat_template=new_chat_template) is True
+
+    def test_behavior_unchanged_single_user_no_generation_prompt(self, tokenizer_name):
+        tokenizer = self._load(tokenizer_name)
+        messages = [{"role": "user", "content": "What color is the sky?"}]
+        if self.is_vlm:
+            messages = prepare_multimodal_messages(messages)
+
+        before = tokenizer.apply_chat_template(messages, tokenize=False)
+        new_chat_template = get_training_chat_template(tokenizer)
+        after = tokenizer.apply_chat_template(messages, tokenize=False, chat_template=new_chat_template)
+        assert before == after
+
+    def test_behavior_unchanged_single_user_with_generation_prompt(self, tokenizer_name):
+        tokenizer = self._load(tokenizer_name)
+        messages = [{"role": "user", "content": "What color is the sky?"}]
+        if self.is_vlm:
+            messages = prepare_multimodal_messages(messages)
+
+        before = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
+        new_chat_template = get_training_chat_template(tokenizer)
+        after = tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            chat_template=new_chat_template,
+        )
+        assert before == after
+
+    def test_behavior_unchanged_single_user_and_final_assistant_plain_content(self, tokenizer_name):
+        tokenizer = self._load(tokenizer_name)
+        messages = [
+            {"role": "user", "content": "What color is the sky?"},
+            {"role": "assistant", "content": "It is blue."},
+        ]
+        if self.is_vlm:
+            messages = prepare_multimodal_messages(messages)
+
+        before = tokenizer.apply_chat_template(messages, tokenize=False)
+        new_chat_template = get_training_chat_template(tokenizer)
+        after = tokenizer.apply_chat_template(messages, tokenize=False, chat_template=new_chat_template)
+        if tokenizer_name == "trl-internal-testing/tiny-Glm4MoeForCausalLM":
+            # GLM's native template doesn't terminate an assistant turn with an end-of-turn token; the turn is ended
+            # by the following message's role marker. The training template appends that terminator to the final
+            # assistant turn so the stop token is trained — here the `<|user|>` that would open the next turn.
+            assert after == before + "<|user|>"
+        else:
+            assert before == after
+
+    def test_behavior_unchanged_final_assistant_with_reasoning_content(self, tokenizer_name):
+        tokenizer = self._load(tokenizer_name)
+        messages = [
+            {"role": "user", "content": "What color is the sky?"},
+            {
+                "role": "assistant",
+                "content": "It is blue.",
+                "reasoning_content": "The sky appears blue due to Rayleigh scattering.",
+            },
+        ]
+        if self.is_vlm:
+            messages = prepare_multimodal_messages(messages)
+
+        before = tokenizer.apply_chat_template(messages, tokenize=False)
+        new_chat_template = get_training_chat_template(tokenizer)
+        after = tokenizer.apply_chat_template(messages, tokenize=False, chat_template=new_chat_template)
+        if tokenizer_name == "trl-internal-testing/tiny-Glm4MoeForCausalLM":
+            # GLM's native template doesn't terminate an assistant turn with an end-of-turn token; the turn is ended
+            # by the following message's role marker. The training template appends that terminator to the final
+            # assistant turn so the stop token is trained — here the `<|user|>` that would open the next turn.
+            assert after == before + "<|user|>"
+        else:
+            assert before == after
+
+    def test_behavior_unchanged_final_assistant_with_existing_think_tags(self, tokenizer_name):
+        tokenizer = self._load(tokenizer_name)
+        messages = [
+            {"role": "user", "content": "What color is the sky?"},
+            {
+                "role": "assistant",
+                "content": "<think>\nThe sky scatters shorter wavelengths.\n</think>\n\nIt is blue.",
+            },
+        ]
+        if self.is_vlm:
+            messages = prepare_multimodal_messages(messages)
+
+        before = tokenizer.apply_chat_template(messages, tokenize=False)
+        new_chat_template = get_training_chat_template(tokenizer)
+        after = tokenizer.apply_chat_template(messages, tokenize=False, chat_template=new_chat_template)
+        if tokenizer_name == "trl-internal-testing/tiny-Glm4MoeForCausalLM":
+            # GLM's native template doesn't terminate an assistant turn with an end-of-turn token; the turn is ended
+            # by the following message's role marker. The training template appends that terminator to the final
+            # assistant turn so the stop token is trained — here the `<|user|>` that would open the next turn.
+            assert after == before + "<|user|>"
+        else:
+            assert before == after
+
+    def test_behavior_unchanged_assistant_with_tool_calls(self, tokenizer_name):
+        tokenizer = self._load(tokenizer_name)
+        tool_calls = [{"type": "function", "function": {"name": "multiply", "arguments": {"a": 3, "b": 4}}}]
+        messages = [
+            {"role": "user", "content": "Multiply 3 by 4."},
+            {"role": "assistant", "content": "I will call a tool.", "tool_calls": tool_calls},
+        ]
+        if self.is_vlm:
+            messages = prepare_multimodal_messages(messages)
+
+        messages_before = copy.deepcopy(messages)
+        if tokenizer_name == "trl-internal-testing/tiny-DeepseekV3ForCausalLM":
+            # Best-effort fallback for templates that reject dict args (e.g. DeepSeek-V3). This is a chat template
+            # bug (see transformers#45419), and the training chat template fixes it to avoid blocking users.
+            messages_before[1]["tool_calls"][0]["function"]["arguments"] = '{"a": 3, "b": 4}'
+
+        before = tokenizer.apply_chat_template(messages_before, tokenize=False)
+        new_chat_template = get_training_chat_template(tokenizer)
+        after = tokenizer.apply_chat_template(messages, tokenize=False, chat_template=new_chat_template)
+        if tokenizer_name == "trl-internal-testing/tiny-Glm4MoeForCausalLM":
+            # GLM's native template doesn't terminate an assistant turn with an end-of-turn token; the turn is ended
+            # by the following message's role marker. The training template appends that terminator to the final
+            # assistant turn so the stop token is trained — here `<|observation|>`, which closes a tool call.
+            assert after == before + "<|observation|>"
+        else:
+            assert before == after
+
+    def test_behavior_unchanged_with_tools_with_and_without_system_message(self, tokenizer_name):
+        tokenizer = self._load(tokenizer_name)
+        tools = [
+            {
+                "type": "function",
+                "function": {
+                    "name": "multiply",
+                    "description": "Multiply two numbers.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "a": {"type": "number"},
+                            "b": {"type": "number"},
+                        },
+                        "required": ["a", "b"],
+                    },
+                },
+            }
+        ]
+        messages = [{"role": "user", "content": "Multiply 3 by 4."}]
+        if self.is_vlm:
+            messages = prepare_multimodal_messages(messages)
+
+        before = tokenizer.apply_chat_template(messages, tokenize=False, tools=tools)
+        new_chat_template = get_training_chat_template(tokenizer)
+        after = tokenizer.apply_chat_template(messages, tokenize=False, tools=tools, chat_template=new_chat_template)
+        assert before == after
+
+    def test_behavior_unchanged_with_tools_with_system_message(self, tokenizer_name):
+        tokenizer = self._load(tokenizer_name)
+        if not supports_tool_calling(tokenizer):
+            pytest.skip("Template does not support tool calling; skipping tool_calls test.")
+        tools = [
+            {
+                "type": "function",
+                "function": {
+                    "name": "multiply",
+                    "description": "Multiply two numbers.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {"a": {"type": "number"}, "b": {"type": "number"}},
+                        "required": ["a", "b"],
+                    },
+                },
+            }
+        ]
+        messages = [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "Multiply 3 by 4."},
+        ]
+        if self.is_vlm:
+            messages = prepare_multimodal_messages(messages)
+
+        before = tokenizer.apply_chat_template(messages, tokenize=False, tools=tools)
+        new_chat_template = get_training_chat_template(tokenizer)
+        after = tokenizer.apply_chat_template(messages, tokenize=False, tools=tools, chat_template=new_chat_template)
+        assert before == after
+
+    def test_behavior_unchanged_generation_prompt_with_enable_thinking_false(self, tokenizer_name):
+        tokenizer = self._load(tokenizer_name)
+        messages = [{"role": "user", "content": "What color is the sky?"}]
+        if self.is_vlm:
+            messages = prepare_multimodal_messages(messages)
+
+        before = tokenizer.apply_chat_template(
+            messages, tokenize=False, add_generation_prompt=True, enable_thinking=False
+        )
+        new_chat_template = get_training_chat_template(tokenizer)
+        after = tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            enable_thinking=False,
+            chat_template=new_chat_template,
+        )
+        assert before == after
+
+    def test_assistant_masks(self, tokenizer_name, request):
+        if tokenizer_name == "trl-internal-testing/tiny-LlavaForConditionalGeneration":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Llava's official chat template `{% generation %}` markers don't yield assistant masks "
+                    "through the processor path. It is not a supported training template.",
+                    strict=True,
+                )
+            )
+        tokenizer = self._load(tokenizer_name)
+        messages = [
+            {"role": "user", "content": "What color is the sky?"},
+            {"role": "assistant", "content": "It is blue."},
+        ]
+        if self.is_vlm:
+            messages = prepare_multimodal_messages(messages)
+
+        chat_template = get_training_chat_template(tokenizer)
+        result = tokenizer.apply_chat_template(
+            messages, chat_template=chat_template, return_assistant_tokens_mask=True, return_dict=True, tokenize=True
+        )
+        masks = result["assistant_masks"]
+        if self.is_vlm:  # VLM processors return batched output
+            masks = masks[0]
+        assert 1 in masks
+        # The first tokens (user turn) should not be masked
+        assert masks[0] == 0
+        # The last tokens (assistant turn ending with <|im_end|>) should be masked
+        assert masks[-1] == 1
+
+    def test_assistant_masks_multi_turn(self, tokenizer_name, request):
+        if tokenizer_name == "trl-internal-testing/tiny-LlavaForConditionalGeneration":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Llava's official chat template `{% generation %}` markers don't yield assistant masks "
+                    "through the processor path. It is not a supported training template.",
+                    strict=True,
+                )
+            )
+        tokenizer = self._load(tokenizer_name)
+        messages = [
+            {"role": "user", "content": "Hi"},
+            {"role": "assistant", "content": "Hello!"},
+            {"role": "user", "content": "Bye"},
+            {"role": "assistant", "content": "Goodbye!"},
+        ]
+        if self.is_vlm:
+            messages = prepare_multimodal_messages(messages)
+
+        chat_template = get_training_chat_template(tokenizer)
+        result = tokenizer.apply_chat_template(
+            messages, chat_template=chat_template, return_assistant_tokens_mask=True, return_dict=True, tokenize=True
+        )
+        masks = result["assistant_masks"]
+        if self.is_vlm:  # VLM processors return batched output
+            masks = masks[0]
+        # Should have two masked regions (two assistant turns): 0→1, 1→0, 0→1
+        transitions = sum(1 for i in range(1, len(masks)) if masks[i] != masks[i - 1])
+        assert transitions == 3
+
+
+@pytest.mark.parametrize(
+    "model_name",
+    [
+        pytest.param("trl-internal-testing/tiny-Glm4MoeForCausalLM", id="glm4moe"),
+        pytest.param("trl-internal-testing/tiny-GptOssForCausalLM", id="gptoss"),
+        pytest.param("trl-internal-testing/tiny-LlamaForCausalLM-3.1", id="llama3.1"),
+        pytest.param("trl-internal-testing/tiny-LlamaForCausalLM-3.2", id="llama3.2"),
+        pytest.param(
+            "trl-internal-testing/tiny-NemotronHForCausalLM-nano",
+            id="nemotron_3_nano",
+            marks=pytest.mark.skipif(
+                Version(transformers.__version__) < Version("5.3.0"),
+                reason="Nemotron 3 tokenizer requires transformers>=5.3.0",
+            ),
+        ),
+        pytest.param(
+            "trl-internal-testing/tiny-NemotronHForCausalLM-super",
+            id="nemotron_3_super",
+            marks=pytest.mark.skipif(
+                Version(transformers.__version__) < Version("5.3.0"),
+                reason="Nemotron 3 tokenizer requires transformers>=5.3.0",
+            ),
+        ),
+        pytest.param(
+            "trl-internal-testing/tiny-NemotronHForCausalLM-ultra",
+            id="nemotron_3_ultra",
+            marks=pytest.mark.skipif(
+                Version(transformers.__version__) < Version("5.3.0"),
+                reason="Nemotron 3 tokenizer requires transformers>=5.3.0",
+            ),
+        ),
+        pytest.param("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", id="qwen2.5"),
+        pytest.param("trl-internal-testing/tiny-Qwen3MoeForCausalLM", id="qwen3"),
+        pytest.param("trl-internal-testing/tiny-Qwen3ForCausalLM-Instruct-2507", id="qwen3_instruct_2507"),
+        pytest.param("trl-internal-testing/tiny-Qwen3VLForConditionalGeneration", id="qwen3_vl"),
+        pytest.param("trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink", id="qwen35-nothink"),
+        pytest.param("trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-Think", id="qwen35-think"),
+        pytest.param("trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6", id="qwen36"),
+        pytest.param(
+            "trl-internal-testing/tiny-Gemma4ForConditionalGeneration",
+            id="gemma4",
+            marks=pytest.mark.skipif(
+                Version(transformers.__version__) < Version("5.5.0"),
+                reason="Gemma4 models were introduced in transformers-5.5.0",
+            ),
+        ),
+    ],
+)
+@pytest.mark.xfail(
+    condition=Version(transformers.__version__) < Version("5.0.0"),
+    reason="Response parsing is not supported in transformers versions below 5.0.0",
+    strict=True,
+)
+@require_jmespath
+class TestParseResponse:
+    def _load(self, model_name):
+        if "ForCausalLM" in model_name:
+            self.is_vlm = False
+            processing_class = AutoTokenizer.from_pretrained(model_name)
+            response_schema = getattr(processing_class, "response_schema", None)
+        elif "ForConditionalGeneration" in model_name:
+            self.is_vlm = True
+            processing_class = AutoProcessor.from_pretrained(model_name)
+            response_schema = getattr(processing_class.tokenizer, "response_schema", None)
+
+        if response_schema is None:
+            processing_class = add_response_schema(processing_class)
+
+        return processing_class
+
+    def test_parse_response(self, model_name):
+        if model_name in ("trl-internal-testing/tiny-GptOssForCausalLM",) and Version(
+            transformers.__version__
+        ) < Version("5.5.0"):
+            pytest.skip("Upstream bug in response parsing (see #5753; fixed in transformers#45166)")
+        processing_class = self._load(model_name)
+        messages = [
+            {"role": "user", "content": "What is 3*4?"},
+            {"role": "assistant", "content": "12"},
+        ]
+        expected = messages[-1]
+        messages = prepare_multimodal_messages(messages) if self.is_vlm else messages
+        prefix = processing_class.apply_chat_template(
+            messages[:1], add_generation_prompt=True, tokenize=True, return_dict=True
+        ).input_ids
+        text = processing_class.apply_chat_template(messages, tokenize=True, return_dict=True).input_ids
+        if self.is_vlm:  # VLM processors return batched output
+            prefix = prefix[0]
+            text = text[0]
+        response = text[len(prefix) :]
+        tokenizer = processing_class.tokenizer if self.is_vlm else processing_class
+        parsed = parse_response(tokenizer, response)
+        assert parsed == expected
+
+    def test_parse_response_with_reasoning_content(self, model_name):
+        if model_name in (
+            "trl-internal-testing/tiny-Gemma4ForConditionalGeneration",
+            "trl-internal-testing/tiny-GptOssForCausalLM",
+            "trl-internal-testing/tiny-LlamaForCausalLM-3.1",
+            "trl-internal-testing/tiny-LlamaForCausalLM-3.2",
+            "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            "trl-internal-testing/tiny-Qwen3ForCausalLM-Instruct-2507",
+            "trl-internal-testing/tiny-Qwen3VLForConditionalGeneration",
+        ):
+            pytest.skip("This tokenizer doesn't support inline reasoning_content.")
+
+        processing_class = self._load(model_name)
+        messages = [
+            {"role": "user", "content": "What is 3*4?"},
+            {"role": "assistant", "reasoning_content": "Hmmm.", "content": "12"},
+        ]
+        expected = messages[-1]
+        messages = prepare_multimodal_messages(messages) if self.is_vlm else messages
+        # enable_thinking=True is required here because the Qwen3.5 NoThink fixture disables thinking by default
+        # for the generation prompt.
+        prefix = processing_class.apply_chat_template(
+            messages[:1], add_generation_prompt=True, enable_thinking=True, tokenize=True, return_dict=True
+        ).input_ids
+        text = processing_class.apply_chat_template(messages, tokenize=True, return_dict=True).input_ids
+        if self.is_vlm:  # VLM processors return batched output
+            prefix = prefix[0]
+            text = text[0]
+        response = text[len(prefix) :]
+        tokenizer = processing_class.tokenizer if self.is_vlm else processing_class
+        parsed = parse_response(tokenizer, response)
+        assert parsed == expected
+
+    def test_parse_response_tool_call(self, model_name):
+        if model_name in (
+            "trl-internal-testing/tiny-GptOssForCausalLM",
+            "trl-internal-testing/tiny-LlamaForCausalLM-3.1",
+            "trl-internal-testing/tiny-LlamaForCausalLM-3.2",
+        ) and Version(transformers.__version__) < Version("5.5.0"):
+            pytest.skip("Upstream bug in response parsing (see #5753; fixed in transformers#45166)")
+        processing_class = self._load(model_name)
+        tool_calls = [{"type": "function", "function": {"name": "multiply", "arguments": {"a": 3, "b": 4}}}]
+        messages = [
+            {"role": "user", "content": "What is 3*4?"},
+            {
+                "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": tool_calls,
+            },
+        ]
+        expected = messages[-1]
+        messages = prepare_multimodal_messages(messages) if self.is_vlm else messages
+        prefix = processing_class.apply_chat_template(
+            messages[:1], add_generation_prompt=True, tokenize=True, return_dict=True
+        ).input_ids
+        text = processing_class.apply_chat_template(messages, tokenize=True, return_dict=True).input_ids
+        if self.is_vlm:  # VLM processors return batched output
+            prefix = prefix[0]
+            text = text[0]
+        response = text[len(prefix) :]
+        tokenizer = processing_class.tokenizer if self.is_vlm else processing_class
+        parsed = parse_response(tokenizer, response)
+        assert parsed == expected
+
+    def test_parse_response_tool_call_with_content(self, model_name):
+        if model_name in (
+            "trl-internal-testing/tiny-LlamaForCausalLM-3.1",
+            "trl-internal-testing/tiny-LlamaForCausalLM-3.2",
+        ):
+            pytest.skip("Llama 3.1 / 3.2 templates only allow a single tool call per assistant turn, with no content.")
+        if model_name in ("trl-internal-testing/tiny-GptOssForCausalLM",) and Version(
+            transformers.__version__
+        ) < Version("5.5.0"):
+            pytest.skip("Upstream bug in response parsing (see #5753; fixed in transformers#45166)")
+        processing_class = self._load(model_name)
+        tool_calls = [{"type": "function", "function": {"name": "multiply", "arguments": {"a": 3, "b": 4}}}]
+        messages = [
+            {"role": "user", "content": "What is 3*4?"},
+            {"role": "assistant", "content": "Let's call the tool.", "tool_calls": tool_calls},
+        ]
+        expected = messages[-1]
+        messages = prepare_multimodal_messages(messages) if self.is_vlm else messages
+        prefix = processing_class.apply_chat_template(
+            messages[:1], add_generation_prompt=True, tokenize=True, return_dict=True
+        ).input_ids
+        text = processing_class.apply_chat_template(messages, tokenize=True, return_dict=True).input_ids
+        if self.is_vlm:  # VLM processors return batched output
+            prefix = prefix[0]
+            text = text[0]
+        response = text[len(prefix) :]
+        tokenizer = processing_class.tokenizer if self.is_vlm else processing_class
+        parsed = parse_response(tokenizer, response)
+        assert parsed == expected
+
+    def test_parse_response_tool_call_without_arguments(self, model_name):
+        if model_name in ("trl-internal-testing/tiny-GptOssForCausalLM",) and Version(
+            transformers.__version__
+        ) < Version("5.5.0"):
+            pytest.skip("Upstream bug in response parsing (see #5753; fixed in transformers#45166)")
+        processing_class = self._load(model_name)
+        tool_calls = [{"type": "function", "function": {"name": "ping", "arguments": {}}}]
+        messages = [
+            {"role": "user", "content": "Ping the service."},
+            {
+                "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": tool_calls,
+            },
+        ]
+        expected = messages[-1]
+        messages = prepare_multimodal_messages(messages) if self.is_vlm else messages
+        prefix = processing_class.apply_chat_template(
+            messages[:1], add_generation_prompt=True, tokenize=True, return_dict=True
+        ).input_ids
+        text = processing_class.apply_chat_template(messages, tokenize=True, return_dict=True).input_ids
+        if self.is_vlm:  # VLM processors return batched output
+            prefix = prefix[0]
+            text = text[0]
+        response = text[len(prefix) :]
+        tokenizer = processing_class.tokenizer if self.is_vlm else processing_class
+        parsed = parse_response(tokenizer, response)
+        assert parsed == expected
+
+    def test_parse_response_multiple_tool_calls(self, model_name):
+        if model_name in (
+            "trl-internal-testing/tiny-GptOssForCausalLM",
+            "trl-internal-testing/tiny-LlamaForCausalLM-3.1",
+            "trl-internal-testing/tiny-LlamaForCausalLM-3.2",
+        ):
+            pytest.skip("This template only renders one tool call per assistant message.")
+        processing_class = self._load(model_name)
+        tool_calls = [
+            {"type": "function", "function": {"name": "multiply", "arguments": {"a": 3, "b": 4}}},
+            {"type": "function", "function": {"name": "addition", "arguments": {"a": 4, "b": 3}}},
+        ]
+        messages = [
+            {"role": "user", "content": "What is 3*4?"},
+            {
+                "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": tool_calls,
+            },
+        ]
+        expected = messages[-1]
+        messages = prepare_multimodal_messages(messages) if self.is_vlm else messages
+        prefix = processing_class.apply_chat_template(
+            messages[:1], add_generation_prompt=True, tokenize=True, return_dict=True
+        ).input_ids
+        text = processing_class.apply_chat_template(messages, tokenize=True, return_dict=True).input_ids
+        if self.is_vlm:  # VLM processors return batched output
+            prefix = prefix[0]
+            text = text[0]
+        response = text[len(prefix) :]
+        tokenizer = processing_class.tokenizer if self.is_vlm else processing_class
+        parsed = parse_response(tokenizer, response)
+        assert parsed == expected
+
+    def test_parse_response_malformed_tool_call(self, model_name):
+        if model_name != "trl-internal-testing/tiny-Qwen3MoeForCausalLM":
+            pytest.skip("For simplicity, we only test the malformed tool call case on one tokenizer.")
+        processing_class = self._load(model_name)
+        text = '<tool_call>\n{"name": "multiply", "arguments": {"a": 3, "b": 4}\n</tool_call><|im_end|>'
+        assistant_text = processing_class(text)["input_ids"]
+        parsed = parse_response(processing_class, assistant_text)
+        expected = {
+            "role": "assistant",
+            "content": '<tool_call>\n{"name": "multiply", "arguments": {"a": 3, "b": 4}\n</tool_call>',
+        }
+
+        assert parsed == expected
+
+    def test_parse_response_truncated(self, model_name):
+        processing_class = self._load(model_name)
+        # Here we use 2 tool calls as it seems to be a more common source of failure when truncated.
+        # Llama 3.1 / 3.2 templates only allow a single tool call per assistant turn, so fall back to one.
+        tool_calls = [{"type": "function", "function": {"name": "multiply", "arguments": {"a": 3, "b": 4}}}]
+        if model_name not in (
+            "trl-internal-testing/tiny-LlamaForCausalLM-3.1",
+            "trl-internal-testing/tiny-LlamaForCausalLM-3.2",
+        ):
+            tool_calls.append({"type": "function", "function": {"name": "addition", "arguments": {"a": 4, "b": 3}}})
+        messages = [
+            {"role": "user", "content": "What is 3*4?"},
+            {"role": "assistant", "content": "", "tool_calls": tool_calls},
+        ]
+        messages = prepare_multimodal_messages(messages) if self.is_vlm else messages
+        prefix = processing_class.apply_chat_template(
+            messages[:1], add_generation_prompt=True, tokenize=True, return_dict=True
+        ).input_ids
+        text = processing_class.apply_chat_template(messages, tokenize=True, return_dict=True).input_ids
+        if self.is_vlm:  # VLM processors return batched output
+            prefix = prefix[0]
+            text = text[0]
+        response = text[len(prefix) :]
+        tokenizer = processing_class.tokenizer if self.is_vlm else processing_class
+        # Truncate the response mid-tool-call and just check that parsing doesn't crash.
+        for end in range(1, len(response)):
+            parse_response(tokenizer, response[:end])

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_cli.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.
+
+import os
+from io import StringIO
+from unittest.mock import patch
+
+import pytest
+import yaml
+
+from .testing_utils import TrlTestCase
+
+
+@pytest.mark.parametrize("command", ["dpo", "grpo", "kto", "reward", "rloo", "sft"])
+def test_help_no_type_error(command):
+    # Regression test for https://github.com/huggingface/trl/issues/5099:
+    # TrainingArguments help strings with unescaped "%" caused TypeError in argparse.
+    from trl.cli import main
+
+    with pytest.raises(SystemExit) as exc_info:
+        with patch("sys.argv", ["trl", command, "--help"]), patch("sys.stdout", new_callable=StringIO):
+            main()
+    assert exc_info.value.code == 0
+
+
+class TestCLI(TrlTestCase):
+    def test_dpo(self):
+        from trl.cli import main
+
+        command = f"trl dpo --output_dir {self.tmp_dir} --model_name_or_path trl-internal-testing/tiny-Qwen2ForCausalLM-2.5 --dataset_name trl-internal-testing/zen --dataset_config standard_preference --report_to none"
+        with patch("sys.argv", command.split(" ")):
+            main()
+
+    def test_dpo_multiple_loss_types(self):
+        from trl.cli import main
+
+        command = f"trl dpo --output_dir {self.tmp_dir} --model_name_or_path trl-internal-testing/tiny-Qwen2ForCausalLM-2.5 --dataset_name trl-internal-testing/zen --dataset_config standard_preference --report_to none --loss_type sigmoid bco_pair --loss_weights 1.0 0.5"
+        with patch("sys.argv", command.split(" ")):
+            main()
+
+    @patch("sys.stdout", new_callable=StringIO)
+    def test_env(self, mock_stdout):
+        from trl.cli import main
+
+        command = "trl env"
+        with patch("sys.argv", command.split(" ")):
+            main()
+        assert "TRL version: " in mock_stdout.getvalue().strip()
+
+    def test_grpo(self):
+        from trl.cli import main
+
+        command = f"trl grpo --output_dir {self.tmp_dir} --model_name_or_path trl-internal-testing/tiny-Qwen2ForCausalLM-2.5 --reward_model_name_or_path trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5 --dataset_name trl-internal-testing/zen --dataset_config standard_prompt_only --num_generations 4 --max_completion_length 32 --report_to none"
+        with patch("sys.argv", command.split(" ")):
+            main()
+
+    def test_kto(self):
+        from trl.cli import main
+
+        command = f"trl kto --output_dir {self.tmp_dir} --model_name_or_path trl-internal-testing/tiny-Qwen2ForCausalLM-2.5 --dataset_name trl-internal-testing/zen --dataset_config standard_unpaired_preference --report_to none"
+        with patch("sys.argv", command.split(" ")):
+            main()
+
+    def test_reward(self):
+        from trl.cli import main
+
+        command = f"trl reward --output_dir {self.tmp_dir} --model_name_or_path trl-internal-testing/tiny-Qwen2ForCausalLM-2.5 --dataset_name trl-internal-testing/zen --dataset_config standard_implicit_prompt_preference --report_to none"
+        with patch("sys.argv", command.split(" ")):
+            main()
+
+    def test_rloo(self):
+        from trl.cli import main
+
+        command = f"trl rloo --output_dir {self.tmp_dir} --model_name_or_path trl-internal-testing/tiny-Qwen2ForCausalLM-2.5 --reward_model_name_or_path trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5 --dataset_name trl-internal-testing/zen --dataset_config standard_prompt_only --num_generations 2 --max_completion_length 32 --report_to none"
+        with patch("sys.argv", command.split(" ")):
+            main()
+
+    def test_sft(self):
+        from trl.cli import main
+
+        command = f"trl sft --output_dir {self.tmp_dir} --model_name_or_path trl-internal-testing/tiny-Qwen2ForCausalLM-2.5 --dataset_name trl-internal-testing/zen --dataset_config standard_language_modeling --report_to none"
+        with patch("sys.argv", command.split(" ")):
+            main()
+
+    def test_sft_config_file(self):
+        from trl.cli import main
+
+        output_dir = os.path.join(self.tmp_dir, "output")
+
+        # Create a temporary config file
+        config_path = os.path.join(self.tmp_dir, "config.yaml")
+        config_content = {
+            "model_name_or_path": "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            "dataset_name": "trl-internal-testing/zen",
+            "dataset_config": "standard_language_modeling",
+            "report_to": "none",
+            "output_dir": output_dir,
+            "lr_scheduler_type": "cosine_with_restarts",
+        }
+        with open(config_path, "w") as config_file:
+            yaml.dump(config_content, config_file)
+
+        # Test the CLI with config file
+        command = f"trl sft --config {config_path}"
+        with patch("sys.argv", command.split(" ")):
+            main()
+
+        # Verify that output directory was created
+        assert os.path.exists(output_dir)
+
+    def test_vllm_serve_config_file(self):
+        """
+        Test `trl vllm-serve --config config.yaml` must not raise "the following arguments are required: --model" when
+        the required field is satisfied by the config file rather than the command line.
+        """
+        from trl.cli import main
+
+        config_path = os.path.join(self.tmp_dir, "config.yaml")
+        with open(config_path, "w") as f:
+            yaml.dump({"model": "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"}, f)
+
+        # Patch the actual function that `VllmServeCommand.run` imports as `vllm_serve_main`
+        with patch("trl.scripts.vllm_serve.main") as mock_serve:
+            with patch("sys.argv", ["trl", "vllm-serve", "--config", config_path]):
+                main()
+
+        mock_serve.assert_called_once()
+        script_args = mock_serve.call_args.args[0]
+        assert script_args.model == "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_cli_utils.py

@@ -0,0 +1,426 @@
+# 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 tempfile
+from dataclasses import dataclass
+from unittest.mock import mock_open, patch
+
+import pytest
+from datasets import DatasetDict, load_dataset
+
+from trl import DatasetMixtureConfig, TrlParser, get_dataset
+from trl.scripts.utils import DatasetConfig
+
+from .testing_utils import TrlTestCase
+
+
+@dataclass
+class MyDataclass:
+    arg1: int
+    arg2: str = "default"
+
+
+@dataclass
+class InvalidDataclass:
+    config: str  # This should raise an error in the TrlParser
+
+
+class TestTrlParser(TrlTestCase):
+    def test_init_without_config_field(self):
+        """Test initialization without 'config' field in the dataclasses."""
+        parser = TrlParser(dataclass_types=[MyDataclass])
+        assert isinstance(parser, TrlParser)
+
+    def test_init_with_config_field(self):
+        """Test initialization with a 'config' field in the dataclass (should raise ValueError)."""
+        with pytest.raises(ValueError, match="has a field named 'config'"):
+            TrlParser(dataclass_types=[InvalidDataclass])
+
+    @patch("builtins.open", mock_open(read_data="env:\n VAR1: value1\n VAR2: value2\narg1: 2"))
+    @patch("yaml.safe_load")
+    @patch("os.environ", new_callable=dict)  # Mock os.environ as a dictionary
+    def test_parse_args_and_config_with_valid_config(self, mock_environ, mock_yaml_load):
+        """Test parse_args_and_config method with valid arguments and config."""
+        mock_yaml_load.return_value = {"env": {"VAR1": "value1", "VAR2": "value2"}, "arg1": 2}
+
+        parser = TrlParser(dataclass_types=[MyDataclass])
+
+        args = ["--arg2", "value", "--config", "config.yaml"]  # don't set arg1 to test default value
+
+        # Simulate the config being loaded and environment variables being set
+        result_args = parser.parse_args_and_config(args)
+
+        # Set the environment variables using the mock
+        mock_environ["VAR1"] = "value1"
+        mock_environ["VAR2"] = "value2"
+
+        # Ensure that the environment variables were set correctly
+        assert mock_environ.get("VAR1") == "value1"
+        assert mock_environ.get("VAR2") == "value2"
+
+        # Check the parsed arguments
+        assert len(result_args) == 1
+        assert isinstance(result_args[0], MyDataclass)
+        assert result_args[0].arg1 == 2
+        assert result_args[0].arg2 == "value"
+
+    @patch("builtins.open", mock_open(read_data="arg1: 2"))
+    @patch("yaml.safe_load")
+    def test_parse_args_and_arg_override_config(self, mock_yaml_load):
+        """Test parse_args_and_config method and check that arguments override the config."""
+        mock_yaml_load.return_value = {"arg1": 2}  # this arg is meant to be overridden
+
+        parser = TrlParser(dataclass_types=[MyDataclass])
+
+        args = ["--arg1", "3", "--config", "config.yaml"]  # override arg1 default with 3
+
+        # Simulate the config being loaded and arguments being passed
+        result_args = parser.parse_args_and_config(args)
+
+        # Check the parsed arguments
+        assert len(result_args) == 1
+        assert isinstance(result_args[0], MyDataclass)
+        assert result_args[0].arg1 == 3
+
+    @patch("builtins.open", mock_open(read_data="env: not_a_dict"))
+    @patch("yaml.safe_load")
+    def test_parse_args_and_config_with_invalid_env(self, mock_yaml_load):
+        """Test parse_args_and_config method when the 'env' field is not a dictionary."""
+        mock_yaml_load.return_value = {"env": "not_a_dict"}
+
+        parser = TrlParser(dataclass_types=[MyDataclass])
+
+        args = ["--arg1", "2", "--arg2", "value", "--config", "config.yaml"]
+
+        with pytest.raises(ValueError, match="`env` field should be a dict in the YAML file."):
+            parser.parse_args_and_config(args)
+
+    def test_parse_args_and_config_without_config(self):
+        """Test parse_args_and_config without the `--config` argument."""
+        parser = TrlParser(dataclass_types=[MyDataclass])
+
+        args = ["--arg1", "2", "--arg2", "value"]
+
+        # Simulate no config, just parse args normally
+        result_args = parser.parse_args_and_config(args)
+
+        # Check that the arguments are parsed as is
+        assert len(result_args) == 1
+        assert isinstance(result_args[0], MyDataclass)
+        assert result_args[0].arg1 == 2
+        assert result_args[0].arg2 == "value"
+
+    def test_set_defaults_with_config(self):
+        """Test set_defaults_with_config updates the defaults."""
+        parser = TrlParser(dataclass_types=[MyDataclass])
+
+        # Update defaults
+        parser.set_defaults_with_config(arg1=42)
+
+        # Ensure the default value is updated
+        result_args = parser.parse_args_and_config([])
+        assert len(result_args) == 1
+        assert isinstance(result_args[0], MyDataclass)
+        assert result_args[0].arg1 == 42
+
+    def test_parse_args_and_config_with_remaining_strings(self):
+        parser = TrlParser(dataclass_types=[MyDataclass])
+
+        args = ["--arg1", "2", "--arg2", "value", "remaining"]
+
+        # Simulate no config, just parse args normally
+        result_args = parser.parse_args_and_config(args, return_remaining_strings=True)
+
+        # Check that the arguments are parsed as is
+        assert len(result_args) == 2
+        assert isinstance(result_args[0], MyDataclass)
+        assert result_args[0].arg1 == 2
+        assert result_args[0].arg2 == "value"
+        assert result_args[1] == ["remaining"]
+
+    @patch("builtins.open", mock_open(read_data="remaining_string_in_config: abc"))
+    @patch("yaml.safe_load")
+    def test_parse_args_and_config_with_remaining_strings_in_config_and_args(self, mock_yaml_load):
+        mock_yaml_load.return_value = {"remaining_string_in_config": "abc"}
+
+        parser = TrlParser(dataclass_types=[MyDataclass])
+
+        args = ["--arg1", "2", "--remaining_string_in_args", "def", "--config", "config.yaml"]
+
+        # Simulate the config being loaded and arguments being passed
+        result_args = parser.parse_args_and_config(args, return_remaining_strings=True)
+
+        # Check that the arguments are parsed as is
+        assert len(result_args) == 2
+        assert isinstance(result_args[0], MyDataclass)
+        assert result_args[0].arg1 == 2
+        assert result_args[1] == ["--remaining_string_in_config", "abc", "--remaining_string_in_args", "def"]
+
+    @patch("builtins.open", mock_open(read_data="arg1: 2\narg2: config_value"))
+    @patch("yaml.safe_load")
+    def test_subparsers_with_config_defaults(self, mock_yaml_load):
+        """Test that config defaults are applied to all subparsers."""
+        mock_yaml_load.return_value = {"arg1": 2, "arg2": "config_value"}
+
+        # Create the main parser
+        parser = TrlParser()
+
+        # Add subparsers
+        subparsers = parser.add_subparsers(dest="command", parser_class=TrlParser)
+
+        # Create a subparser for a specific command
+        subparsers.add_parser("subcommand", dataclass_types=[MyDataclass])
+
+        # Parse with config file
+        args = ["subcommand", "--config", "config.yaml"]
+        result_args = parser.parse_args_and_config(args)
+
+        # Check main parser arguments
+        assert len(result_args) == 1
+
+        # Check that config values were applied to the subparser
+        assert result_args[0].arg1 == 2  # Default from config
+        assert result_args[0].arg2 == "config_value"  # Default from config
+
+    @patch("builtins.open", mock_open(read_data="arg1: 2\narg2: config_value"))
+    @patch("yaml.safe_load")
+    def test_subparsers_with_config_defaults_and_arg_override(self, mock_yaml_load):
+        """Test that config defaults are applied to all subparsers."""
+        mock_yaml_load.return_value = {"arg1": 2, "arg2": "config_value"}
+
+        # Create the main parser
+        parser = TrlParser()
+
+        # Add subparsers
+        subparsers = parser.add_subparsers(dest="command", parser_class=TrlParser)
+
+        # Create a subparser for a specific command
+        subparsers.add_parser("subcommand", dataclass_types=[MyDataclass])
+
+        # Test with command line arguments overriding config
+        args = ["subcommand", "--arg1", "3", "--config", "config.yaml"]
+        result_args = parser.parse_args_and_config(args)
+
+        # Command line arguments should override config
+        assert result_args[0].arg1 == 3
+        assert result_args[0].arg2 == "config_value"  # Still from config
+
+    @patch("builtins.open", mock_open(read_data="arg1: 2\nthis_arg_does_not_exist: config_value"))
+    @patch("yaml.safe_load")
+    def test_subparsers_with_config_defaults_and_arg_override_wrong_name(self, mock_yaml_load):
+        """Test that config defaults are applied to all subparsers."""
+        mock_yaml_load.return_value = {"arg1": 2, "this_arg_does_not_exist": "config_value"}
+
+        # Create the main parser
+        parser = TrlParser()
+
+        # Add subparsers
+        subparsers = parser.add_subparsers(dest="command", parser_class=TrlParser)
+
+        # Create a subparser for a specific command
+        subparsers.add_parser("subcommand", dataclass_types=[MyDataclass])
+
+        # Test with command line arguments overriding config
+        args = ["subcommand", "--arg1", "3", "--config", "config.yaml"]
+        with pytest.raises(ValueError):
+            parser.parse_args_and_config(args)
+
+        parser.parse_args_and_config(args, fail_with_unknown_args=False)
+
+    @patch("builtins.open", mock_open(read_data="arg1: 2\narg2: config_value"))
+    @patch("yaml.safe_load")
+    def test_subparsers_multiple_with_config_defaults(self, mock_yaml_load):
+        """Test that config defaults are applied to all subparsers."""
+        mock_yaml_load.return_value = {"arg1": 2, "arg2": "config_value"}
+
+        # Create the main parser
+        parser = TrlParser()
+
+        # Add subparsers
+        subparsers = parser.add_subparsers(dest="command", parser_class=TrlParser)
+
+        # Create a subparser for a specific command
+        subparsers.add_parser("subcommand0", dataclass_types=[MyDataclass])
+        subparsers.add_parser("subcommand1", dataclass_types=[MyDataclass])
+
+        for idx in range(2):
+            # Parse with config file
+            args = [f"subcommand{idx}", "--config", "config.yaml"]
+            result_args = parser.parse_args_and_config(args)
+
+            # Check main parser arguments
+            assert len(result_args) == 1
+
+            # Check that config values were applied to the subparser
+            assert result_args[0].arg1 == 2  # Default from config
+            assert result_args[0].arg2 == "config_value"  # Default from config
+
+
+class TestGetDataset:
+    def test_single_dataset_with_config(self):
+        mixture_config = DatasetMixtureConfig(
+            datasets=[DatasetConfig(path="trl-internal-testing/zen", name="standard_language_modeling")]
+        )
+        result = get_dataset(mixture_config)
+        expected = load_dataset("trl-internal-testing/zen", "standard_language_modeling")
+        assert expected["train"][:] == result["train"][:]
+
+    def test_single_dataset_preference_config(self):
+        mixture_config = DatasetMixtureConfig(
+            datasets=[DatasetConfig(path="trl-internal-testing/zen", name="standard_preference")]
+        )
+        result = get_dataset(mixture_config)
+        expected = load_dataset("trl-internal-testing/zen", "standard_preference")
+        assert expected["train"][:] == result["train"][:]
+
+    def test_single_dataset_streaming(self):
+        mixture_config = DatasetMixtureConfig(
+            datasets=[DatasetConfig(path="trl-internal-testing/zen", name="standard_language_modeling")],
+            streaming=True,
+        )
+        result = get_dataset(mixture_config)
+        expected = load_dataset("trl-internal-testing/zen", "standard_language_modeling")
+        assert expected["train"].to_list() == list(result["train"])
+
+    def test_dataset_mixture_basic(self):
+        dataset_config1 = DatasetConfig(
+            path="trl-internal-testing/zen", name="standard_prompt_completion", split="train", columns=["prompt"]
+        )
+        dataset_config2 = DatasetConfig(
+            path="trl-internal-testing/zen", name="standard_preference", split="train", columns=["prompt"]
+        )
+        mixture_config = DatasetMixtureConfig(datasets=[dataset_config1, dataset_config2])
+        result = get_dataset(mixture_config)
+        assert isinstance(result, DatasetDict)
+        assert "train" in result
+        train_dataset = result["train"]
+        assert train_dataset.column_names == ["prompt"]
+        prompts = train_dataset["prompt"]
+        expected_first_half = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+        assert prompts[: len(prompts) // 2] == expected_first_half["prompt"]
+        expected_second_half = load_dataset("trl-internal-testing/zen", "standard_prompt_completion", split="train")
+        assert prompts[len(prompts) // 2 :] == expected_second_half["prompt"]
+
+    def test_dataset_mixture_with_weights(self):
+        dataset_config1 = DatasetConfig(
+            path="trl-internal-testing/zen", name="standard_prompt_completion", split="train[:50%]", columns=["prompt"]
+        )
+        dataset_config2 = DatasetConfig(
+            path="trl-internal-testing/zen", name="standard_preference", split="train[:50%]", columns=["prompt"]
+        )
+        mixture_config = DatasetMixtureConfig(datasets=[dataset_config1, dataset_config2])
+        result = get_dataset(mixture_config)
+        assert isinstance(result, DatasetDict)
+        assert "train" in result
+        train_dataset = result["train"]
+        assert train_dataset.column_names == ["prompt"]
+        prompts = train_dataset["prompt"]
+        expected_first_half = load_dataset("trl-internal-testing/zen", "standard_preference", split="train[:50%]")
+        assert prompts[: len(prompts) // 2] == expected_first_half["prompt"]
+        expected_second_half = load_dataset(
+            "trl-internal-testing/zen", "standard_prompt_completion", split="train[:50%]"
+        )
+        assert prompts[len(prompts) // 2 :] == expected_second_half["prompt"]
+
+    def test_dataset_mixture_with_test_split(self):
+        mixture_config = DatasetMixtureConfig(
+            datasets=[DatasetConfig(path="trl-internal-testing/zen", name="standard_language_modeling")],
+            test_split_size=2,
+        )
+        result = get_dataset(mixture_config)
+        assert isinstance(result, DatasetDict)
+        assert "train" in result
+        assert "test" in result
+        assert len(result["train"]) == 15
+        assert len(result["test"]) == 2
+
+    def test_empty_dataset_mixture_raises_error(self):
+        mixture_config = DatasetMixtureConfig(datasets=[])
+
+        with pytest.raises(ValueError, match="No datasets were loaded"):
+            get_dataset(mixture_config)
+
+    def test_mixture_multiple_different_configs(self):
+        dataset_config1 = DatasetConfig(
+            path="trl-internal-testing/zen", name="conversational_preference", split="train", columns=["prompt"]
+        )
+        dataset_config2 = DatasetConfig(
+            path="trl-internal-testing/zen", name="conversational_prompt_only", split="test"
+        )
+        mixture_config = DatasetMixtureConfig(datasets=[dataset_config1, dataset_config2])
+        result = get_dataset(mixture_config)
+        assert isinstance(result, DatasetDict)
+        assert "train" in result
+        assert len(result["train"]) > 0
+
+    def test_trlparser_parses_yaml_config_correctly(self):
+        # Prepare YAML content exactly like your example
+        # docstyle-ignore
+        yaml_content = """
+        datasets:
+        - path: trl-internal-testing/zen
+          name: standard_prompt_only
+        - path: trl-internal-testing/zen
+          name: standard_preference
+          columns:
+          - prompt
+        """
+
+        # Write YAML to a temporary file
+        with tempfile.NamedTemporaryFile("w+", suffix=".yaml") as tmpfile:
+            tmpfile.write(yaml_content)
+            tmpfile.flush()
+            parser = TrlParser((DatasetMixtureConfig,))
+            args = parser.parse_args_and_config(args=["--config", tmpfile.name])[0]
+
+        # Assert that we got DatasetMixtureConfig instance
+        assert isinstance(args, DatasetMixtureConfig)
+
+        # Assert datasets list length
+        assert len(args.datasets) == 2
+
+        # Check first dataset
+        dataset_config1 = args.datasets[0]
+        assert isinstance(dataset_config1, DatasetConfig)
+        assert dataset_config1.path == "trl-internal-testing/zen"
+        assert dataset_config1.name == "standard_prompt_only"
+        assert dataset_config1.columns is None  # No columns specified
+
+        # Check second dataset
+        dataset_config2 = args.datasets[1]
+        assert isinstance(dataset_config2, DatasetConfig)
+        assert dataset_config2.path == "trl-internal-testing/zen"
+        assert dataset_config2.name == "standard_preference"
+        assert dataset_config2.columns == ["prompt"]  # Columns specified
+
+    def test_trlparser_parses_yaml_and_loads_dataset(self):
+        # Prepare YAML content exactly like your example
+        # docstyle-ignore
+        yaml_content = """
+        datasets:
+        - path: trl-internal-testing/zen
+          name: standard_language_modeling
+        """
+
+        # Write YAML to a temporary file
+        with tempfile.NamedTemporaryFile("w+", suffix=".yaml") as tmpfile:
+            tmpfile.write(yaml_content)
+            tmpfile.flush()
+            parser = TrlParser((DatasetMixtureConfig,))
+            args = parser.parse_args_and_config(args=["--config", tmpfile.name])[0]
+
+        # Load the dataset using get_dataset
+        result = get_dataset(args)
+        expected = load_dataset("trl-internal-testing/zen", "standard_language_modeling")
+        assert expected["train"][:] == result["train"][:]

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_data_utils.py

@@ -0,0 +1,1335 @@
+# 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 copy
+import textwrap
+from time import strftime
+
+import pytest
+import transformers
+from datasets import Dataset, DatasetDict
+from packaging.version import Version
+from transformers import AutoProcessor, AutoTokenizer, is_vision_available
+
+from trl.data_utils import (
+    apply_chat_template,
+    extract_prompt,
+    is_conversational,
+    is_conversational_from_value,
+    maybe_apply_chat_template,
+    maybe_convert_to_chatml,
+    maybe_extract_prompt,
+    maybe_unpair_preference_dataset,
+    pack_dataset,
+    prepare_multimodal_messages,
+    prepare_multimodal_messages_vllm,
+    unpair_preference_dataset,
+)
+
+from .testing_utils import TrlTestCase, require_vision
+
+
+if is_vision_available():
+    from PIL import Image
+
+
+@require_vision
+class TestPrepareMultimodalMessages:
+    def test_basic_user_assistant_conversation(self):
+        """Test basic conversation with user and assistant messages."""
+        messages = [
+            {"role": "user", "content": "What color is the sky?"},
+            {"role": "assistant", "content": "It is blue."},
+        ]
+        image = Image.new("RGB", (10, 10), color="blue")
+        messages = prepare_multimodal_messages(messages, images=[image])
+
+        expected = [
+            {
+                "role": "user",
+                "content": [{"type": "image", "image": image}, {"type": "text", "text": "What color is the sky?"}],
+            },
+            {
+                "role": "assistant",
+                "content": [{"type": "text", "text": "It is blue."}],
+            },
+        ]
+
+        assert messages == expected
+
+    def test_first_user_message_gets_image(self):
+        """Test that only the first user message gets an image."""
+        messages = [
+            {"role": "user", "content": "What color is the sky?"},
+            {"role": "assistant", "content": "It is blue."},
+            {"role": "user", "content": "How about the grass?"},
+        ]
+
+        image = Image.new("RGB", (10, 10), color="blue")
+        messages = prepare_multimodal_messages(messages, images=[image])
+
+        expected = [
+            {
+                "role": "user",
+                "content": [{"type": "image", "image": image}, {"type": "text", "text": "What color is the sky?"}],
+            },
+            {
+                "role": "assistant",
+                "content": [{"type": "text", "text": "It is blue."}],
+            },
+            {
+                "role": "user",
+                "content": [{"type": "text", "text": "How about the grass?"}],
+            },
+        ]
+
+        assert messages == expected
+
+    def test_multiple_images(self):
+        """Test that multiple images are added to the first user message."""
+        messages = [
+            {"role": "user", "content": "What color is the sky?"},
+            {"role": "assistant", "content": "It is blue."},
+        ]
+        images = [Image.new("RGB", (10, 10), color=color) for color in ["red", "green", "blue"]]
+        messages = prepare_multimodal_messages(messages, images=images)
+
+        expected = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": images[0]},
+                    {"type": "image", "image": images[1]},
+                    {"type": "image", "image": images[2]},
+                    {"type": "text", "text": "What color is the sky?"},
+                ],
+            },
+            {
+                "role": "assistant",
+                "content": [{"type": "text", "text": "It is blue."}],
+            },
+        ]
+
+        assert messages == expected
+
+    def test_system_message_transformation(self):
+        """Test that system messages are properly transformed."""
+        messages = [
+            {"role": "system", "content": "You are a helpful assistant"},
+            {"role": "user", "content": "What color is the sky?"},
+        ]
+
+        image = Image.new("RGB", (10, 10), color="blue")
+        messages = prepare_multimodal_messages(messages, images=[image])
+
+        expected = [
+            {
+                "role": "system",
+                "content": [{"type": "text", "text": "You are a helpful assistant"}],
+            },
+            {
+                "role": "user",
+                "content": [{"type": "image", "image": image}, {"type": "text", "text": "What color is the sky?"}],
+            },
+        ]
+
+        assert messages == expected
+
+    def test_already_prepared_messages_unchanged(self):
+        """Test that messages with list content are not modified."""
+        messages = [
+            {"role": "system", "content": [{"type": "text", "text": "You are a helpful assistant"}]},
+            {"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What color is the sky?"}]},
+            {"role": "assistant", "content": [{"type": "text", "text": "It is blue."}]},
+        ]
+
+        image = Image.new("RGB", (10, 10), color="blue")
+        messages = prepare_multimodal_messages(messages, images=[image])
+
+        expected = [
+            {
+                "role": "system",
+                "content": [{"type": "text", "text": "You are a helpful assistant"}],
+            },
+            {
+                "role": "user",
+                "content": [{"type": "image", "image": image}, {"type": "text", "text": "What color is the sky?"}],
+            },
+            {
+                "role": "assistant",
+                "content": [{"type": "text", "text": "It is blue."}],
+            },
+        ]
+
+        assert messages == expected
+
+    def test_mixed_prepared_and_unprepared_messages(self):
+        """Test handling of mixed prepared and unprepared messages."""
+        messages = [
+            {"role": "user", "content": "What color is the sky?"},
+            {"role": "assistant", "content": [{"type": "text", "text": "It is blue."}]},
+            {"role": "user", "content": "What about the grass?"},
+        ]
+
+        image = Image.new("RGB", (10, 10), color="blue")
+        messages = prepare_multimodal_messages(messages, images=[image])
+
+        expected = [
+            {
+                "role": "user",
+                "content": [{"type": "image", "image": image}, {"type": "text", "text": "What color is the sky?"}],
+            },
+            {
+                "role": "assistant",
+                "content": [{"type": "text", "text": "It is blue."}],
+            },
+            {
+                "role": "user",
+                "content": [{"type": "text", "text": "What about the grass?"}],
+            },
+        ]
+
+        assert messages == expected
+
+    def test_message_with_tool_calling_turns(self):
+        """Test that both the assistant tool call and the tool role turns messages are properly transformed."""
+        messages = [
+            {"role": "user", "content": "What's the weather like in New York?"},
+            {
+                "role": "assistant",
+                "tool_calls": [
+                    {
+                        "type": "tool",
+                        "function": {"name": "get_current_weather", "arguments": {"location": "New York"}},
+                    }
+                ],
+            },
+            {"role": "tool", "name": "get_current_weather", "content": "22.0"},
+            {"role": "assistant", "content": "The current weather in New York is 22.0 degrees Celsius."},
+        ]
+
+        messages = prepare_multimodal_messages(messages)
+
+        expected = [
+            {
+                "role": "user",
+                "content": [{"type": "text", "text": "What's the weather like in New York?"}],
+            },
+            {
+                "role": "assistant",
+                "tool_calls": [
+                    {
+                        "type": "tool",
+                        "function": {"name": "get_current_weather", "arguments": {"location": "New York"}},
+                    }
+                ],
+            },
+            {"role": "tool", "name": "get_current_weather", "content": [{"type": "text", "text": "22.0"}]},
+            {
+                "role": "assistant",
+                "content": [{"type": "text", "text": "The current weather in New York is 22.0 degrees Celsius."}],
+            },
+        ]
+
+        assert messages == expected
+
+    def test_prepared_image_blocks_without_new_images(self):
+        """Test that existing image payloads are preserved when no new images are provided."""
+        image = Image.new("RGB", (10, 10), color="blue")
+        messages = [
+            {
+                "role": "user",
+                "content": [{"type": "image", "image": image}, {"type": "text", "text": "What color is the sky?"}],
+            },
+            {"role": "assistant", "content": "It is blue."},
+        ]
+
+        messages = prepare_multimodal_messages(messages)
+
+        expected = [
+            {
+                "role": "user",
+                "content": [{"type": "image", "image": image}, {"type": "text", "text": "What color is the sky?"}],
+            },
+            {"role": "assistant", "content": [{"type": "text", "text": "It is blue."}]},
+        ]
+
+        assert messages == expected
+
+
+@require_vision
+class TestPrepareMultimodalMessagesVLLM:
+    def test_single_image_conversion(self):
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": Image.new("RGB", (10, 10), color="blue")},
+                    {"type": "text", "text": "What color is the sky?"},
+                ],
+            }
+        ]
+
+        result = prepare_multimodal_messages_vllm(messages)
+
+        # Original should remain unchanged (deepcopy test)
+        assert messages[0]["content"][0]["type"] == "image"
+
+        # Converted version should have correct structure
+        assert result[0]["content"][0]["type"] == "image_pil"
+        assert "image_pil" in result[0]["content"][0]
+        assert "image" not in result[0]["content"][0]
+        assert isinstance(result[0]["content"][0]["image_pil"], Image.Image)
+        assert result[0]["content"][1]["type"] == "text"
+
+    def test_mixed_content_conversion(self):
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": "What color is the sky?"},
+                    {"type": "image", "image": Image.new("RGB", (10, 10), color="blue")},
+                ],
+            }
+        ]
+
+        result = prepare_multimodal_messages_vllm(messages)
+
+        # The image part should be converted, text should be unchanged
+        assert result[0]["content"][0]["type"] == "text"
+        assert result[0]["content"][1]["type"] == "image_pil"
+
+    def test_no_images(self):
+        messages = [{"role": "user", "content": [{"type": "text", "text": "What color is the sky?"}]}]
+
+        result = prepare_multimodal_messages_vllm(messages)
+
+        # Should be identical since there are no images
+        assert result == messages
+        # And a deepcopy — not the same object
+        assert result is not messages
+        assert result[0] is not messages[0]
+
+    def test_multiple_messages(self):
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": "What color is the sky?"},
+                    {"type": "image", "image": Image.new("RGB", (10, 10), color="blue")},
+                ],
+            },
+            {
+                "role": "assistant",
+                "content": [{"type": "text", "text": "It is blue."}],
+            },
+        ]
+
+        result = prepare_multimodal_messages_vllm(messages)
+
+        assert result[0]["content"][1]["type"] == "image_pil"
+        assert result[1]["content"][0]["type"] == "text"
+        assert result[1]["content"][0]["text"] == "It is blue."
+
+    def test_deepcopy_integrity(self):
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": "What color is the sky?"},
+                    {"type": "image", "image": Image.new("RGB", (10, 10), color="blue")},
+                ],
+            },
+        ]
+        original = copy.deepcopy(messages)
+
+        _ = prepare_multimodal_messages_vllm(messages)
+
+        # Original should not be mutated
+        assert messages == original
+
+
+class TestIsConversational(TrlTestCase):
+    # fmt: off
+    conversational_examples = [
+        {  # Language modeling
+            "messages": [
+                {"role": "user", "content": "What color is the sky?"},
+                {"role": "assistant", "content": "It is blue."},
+            ],
+        },
+        {  # Prompt-only
+            "prompt": [{"role": "user", "content": "What color is the sky?"}],
+        },
+        {  # Prompt-completion
+            "prompt": [{"role": "user", "content": "What color is the sky?"}],
+            "completion": [{"role": "assistant", "content": "It is blue."}],
+        },
+        {  # Preference
+            "prompt": [{"role": "user", "content": "What color is the sky?"}],
+            "chosen": [{"role": "assistant", "content": "It is blue."}],
+            "rejected": [{"role": "assistant", "content": "It is green."}],
+        },
+        {  # Preference with implicit prompt
+            "chosen": [
+                {"role": "user", "content": "What color is the sky?"},
+                {"role": "assistant", "content": "It is blue."},
+            ],
+            "rejected": [
+                {"role": "user", "content": "What color is the sky?"},
+                {"role": "assistant", "content": "It is green."},
+            ],
+        },
+        {  # Preference with tool calls
+            "prompt": [{"role": "user", "content": "What color is the sky?"}],
+            "chosen": [
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_color", "arguments": {"what": "sky"}}}]},
+                {"role": "tool", "name": "get_color", "content": "blue"},
+                {"role": "assistant", "content": "It is blue."},
+            ],
+            "rejected": [
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_color", "arguments": {"what": "tree"}}}]},
+                {"role": "tool", "name": "get_color", "content": "green"},
+                {"role": "assistant", "content": "It is green."},
+            ],
+            "tools": [
+                {
+                    "type": "function",
+                    "function": {
+                        "description": "Gets the color.",
+                        "name": "get_color",
+                        "parameters": {"properties": {"what": {"description": "What to get the color of.", "type": "string"}}, "required": ["what"], "type": "object"},
+                        "return": {"description": "The color.", "type": "string"},
+                    },
+                },
+            ],
+        },
+        {  # Unpaired preference
+            "prompt": [{"role": "user", "content": "What color is the sky?"}],
+            "completion": [{"role": "assistant", "content": "It is blue."}],
+            "label": True,
+        },
+        {  # Language modeling with harmony
+            "messages": [
+                {"role": "system", "content": "Respond in a friendly manner."},
+                {"role": "user", "content": "What color is the sky?"},
+                {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."},
+            ],
+        },
+        {  # Prompt-only with harmony
+            "prompt": [
+                {"role": "system", "content": "Respond in a friendly manner."},
+                {"role": "user", "content": "What color is the sky?"},
+            ],
+        },
+        {  # Prompt-completion with harmony
+            "prompt": [
+                {"role": "system", "content": "Respond in a friendly manner."},
+                {"role": "user", "content": "What color is the sky?"},
+            ],
+            "completion": [
+                {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."},
+            ],
+        },
+        {  # Preference with harmony
+            "prompt": [
+                {"role": "system", "content": "Respond in a friendly manner."},
+                {"role": "user", "content": "What color is the sky?"},
+            ],
+            "chosen": [
+                {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."},
+            ],
+            "rejected": [
+                {"role": "assistant", "thinking": "The user asks the color of the tree...", "content": "It is green."},
+            ],
+        },
+        {  # Preference with implicit prompt and harmony
+            "chosen": [
+                {"role": "system", "content": "Respond in a friendly manner."},
+                {"role": "user", "content": "What color is the sky?"},
+                {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."},
+            ],
+            "rejected": [
+                {"role": "system", "content": "Respond in a friendly manner."},
+                {"role": "user", "content": "What color is the sky?"},
+                {"role": "assistant", "thinking": "The user asks the color of the tree...", "content": "It is green."},
+            ],
+        },
+        {  # Unpaired preference with harmony
+            "prompt": [
+                {"role": "system", "content": "Respond in a friendly manner."},
+                {"role": "user", "content": "What color is the sky?"},
+            ],
+            "completion": [
+                {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."},
+            ],
+            "label": True,
+        },
+    ]
+    # fmt: on
+
+    non_conversational_examples = [
+        {"prompt": "The sky is", "completion": " blue."},
+        {"text": "The sky is blue."},
+        {"prompt": "The sky is"},
+        {"prompt": "The sky is", "chosen": " blue.", "rejected": " green."},
+        {"prompt": "The sky is", "completion": " blue.", "label": True},
+    ]
+
+    @pytest.mark.parametrize("example", conversational_examples)
+    def test_conversational(self, example):
+        assert is_conversational(example)
+
+    @pytest.mark.parametrize("example", non_conversational_examples)
+    def test_non_conversational(self, example):
+        assert not is_conversational(example)
+
+
+class TestIsConversationalFromValue(TrlTestCase):
+    def test_positive_1(self):
+        example = {
+            "conversations": [
+                {"from": "user", "value": "What color is the sky?"},
+                {"from": "assistant", "value": "It is blue."},
+            ],
+        }
+        assert is_conversational_from_value(example)
+
+    def test_negative_1(self):
+        example = {
+            "messages": [
+                {"role": "user", "content": "What color is the sky?"},
+                {"role": "assistant", "content": "It is blue."},
+            ],
+        }
+        assert not is_conversational_from_value(example)
+
+    def test_negative_2(self):
+        example = {"text": "The sky is blue."}
+        assert not is_conversational_from_value(example)
+
+
+class TestApplyChatTemplate(TrlTestCase):
+    tokenizers = [
+        "trl-internal-testing/tiny-CohereForCausalLM",
+        "trl-internal-testing/tiny-Cohere2ForCausalLM",
+        "trl-internal-testing/tiny-DeepseekV3ForCausalLM",
+        "trl-internal-testing/tiny-DeepseekV3ForCausalLM-0528",
+        "trl-internal-testing/tiny-FalconMambaForCausalLM",
+        "trl-internal-testing/tiny-Gemma2ForCausalLM",
+        "trl-internal-testing/tiny-GemmaForCausalLM",
+        "trl-internal-testing/tiny-GptOssForCausalLM",
+        pytest.param(
+            "trl-internal-testing/tiny-Glm4MoeForCausalLM",
+            marks=pytest.mark.skipif(
+                Version(transformers.__version__) < Version("5.0.0"),
+                reason="GLM4 tokenizer requires transformers>=5.0.0",
+            ),
+        ),
+        "trl-internal-testing/tiny-LlamaForCausalLM-3.1",
+        "trl-internal-testing/tiny-LlamaForCausalLM-3.2",
+        "trl-internal-testing/tiny-LlamaForCausalLM-3",
+        "trl-internal-testing/tiny-MistralForCausalLM-0.1",
+        "trl-internal-testing/tiny-MistralForCausalLM-0.2",
+        pytest.param(
+            "trl-internal-testing/tiny-NemotronHForCausalLM-nano",
+            marks=pytest.mark.skipif(
+                Version(transformers.__version__) < Version("5.3.0"),
+                reason="Nemotron 3 tokenizer requires transformers>=5.3.0",
+            ),
+        ),
+        pytest.param(
+            "trl-internal-testing/tiny-NemotronHForCausalLM-super",
+            marks=pytest.mark.skipif(
+                Version(transformers.__version__) < Version("5.3.0"),
+                reason="Nemotron 3 tokenizer requires transformers>=5.3.0",
+            ),
+        ),
+        pytest.param(
+            "trl-internal-testing/tiny-NemotronHForCausalLM-ultra",
+            marks=pytest.mark.skipif(
+                Version(transformers.__version__) < Version("5.3.0"),
+                reason="Nemotron 3 tokenizer requires transformers>=5.3.0",
+            ),
+        ),
+        pytest.param(
+            "trl-internal-testing/tiny-Olmo3ForCausalLM",
+            marks=pytest.mark.skipif(
+                Version(transformers.__version__) < Version("4.57.0"),
+                reason="Olmo 3 requires transformers>=4.57.0",
+            ),
+        ),
+        "trl-internal-testing/tiny-Phi3ForCausalLM-3",
+        "trl-internal-testing/tiny-Phi3ForCausalLM-3.5",
+        "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+        "trl-internal-testing/tiny-Qwen3ForCausalLM",
+        "trl-internal-testing/tiny-Qwen3ForCausalLM-Instruct-2507",
+        pytest.param(
+            "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink",
+            marks=pytest.mark.skipif(
+                Version(transformers.__version__) < Version("5.0.0"),
+                reason="Qwen3.5 tokenizer requires transformers>=5.0.0",
+            ),
+        ),
+        pytest.param(
+            "trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6",
+            marks=pytest.mark.skipif(
+                Version(transformers.__version__) < Version("5.0.0"),
+                reason="Qwen3.5 tokenizer requires transformers>=5.0.0",
+            ),
+        ),
+    ]
+
+    conversational_examples = [
+        {  # Language modeling
+            "messages": [
+                {"role": "user", "content": "What color is the sky?"},
+                {"role": "assistant", "content": "It is blue."},
+            ],
+        },
+        {  # Prompt-only
+            "prompt": [{"role": "user", "content": "What color is the sky?"}],
+        },
+        {  # Prompt-completion
+            "prompt": [{"role": "user", "content": "What color is the sky?"}],
+            "completion": [{"role": "assistant", "content": "It is blue."}],
+        },
+        {  # Preference
+            "prompt": [{"role": "user", "content": "What color is the sky?"}],
+            "chosen": [{"role": "assistant", "content": "It is blue."}],
+            "rejected": [{"role": "assistant", "content": "It is green."}],
+        },
+        {  # Preference with implicit prompt
+            "chosen": [
+                {"role": "user", "content": "What color is the sky?"},
+                {"role": "assistant", "content": "It is blue."},
+            ],
+            "rejected": [
+                {"role": "user", "content": "What color is the sky?"},
+                {"role": "assistant", "content": "It is green."},
+            ],
+        },
+        {  # Unpaired preference
+            "prompt": [{"role": "user", "content": "What color is the sky?"}],
+            "completion": [{"role": "assistant", "content": "It is blue."}],
+            "label": True,
+        },
+    ]
+
+    non_conversational_examples = [
+        {"text": "The sky is blue."},  # Language modeling
+        {"prompt": "The sky is"},  # Prompt-only
+        {"prompt": "The sky is", "completion": " blue."},  # Prompt-completion
+        {"prompt": "The sky is", "chosen": " blue.", "rejected": " green."},  # Preference
+        {"chosen": "The sky is blue.", "rejected": "The sky is green."},  # Preference with implicit prompt
+        {"prompt": "The sky is", "completion": " blue.", "label": True},  # Unpaired preference
+    ]
+
+    @pytest.mark.parametrize("example", conversational_examples)
+    @pytest.mark.parametrize("tokenizer_id", tokenizers)
+    def test_apply_chat_template(self, tokenizer_id, example):
+        tokenizer = AutoTokenizer.from_pretrained(tokenizer_id)
+        result = apply_chat_template(example, tokenizer)
+
+        # Checking if the result is a dictionary
+        assert isinstance(result, dict)
+
+        # The chat template should be applied to the following keys
+        for key in ["prompt", "chosen", "rejected", "completion"]:
+            if key in example:
+                assert key in result
+                assert isinstance(result[key], str)
+
+        # Exception for messages, the key is "text" once the chat template is applied
+        if "messages" in example:
+            assert "text" in result
+            assert isinstance(result["text"], str)
+
+        # The label should be kept
+        if "label" in example:
+            assert "label" in result
+            assert isinstance(result["label"], bool)
+            assert result["label"] == example["label"]
+
+    # both conversational and non-conversational examples
+    @pytest.mark.parametrize("example", conversational_examples + non_conversational_examples)
+    @pytest.mark.parametrize("tokenizer_id", tokenizers)
+    def test_maybe_apply_chat_template(self, tokenizer_id, example):
+        tokenizer = AutoTokenizer.from_pretrained(tokenizer_id)
+        result = maybe_apply_chat_template(example, tokenizer)
+
+        # Checking if the result is a dictionary
+        assert isinstance(result, dict)
+
+        # The chat template should be applied to the following keys
+        for key in ["prompt", "chosen", "rejected", "completion"]:
+            if key in example:
+                assert key in result
+                assert isinstance(result[key], str)
+
+        # Exception for messages, the key is "text" once the chat template is applied
+        if "messages" in example:
+            assert "text" in result
+            assert isinstance(result["text"], str)
+
+        # The label should be kept
+        if "label" in example:
+            assert "label" in result
+            assert isinstance(result["label"], bool)
+            assert result["label"] == example["label"]
+
+    def test_apply_chat_template_with_chat_template_kwargs(self):
+        tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen3ForCausalLM")
+
+        example = {
+            "prompt": [{"role": "user", "content": "What color is the sky?"}],
+            # with this tokenizer, when you pass enable_thinking=False, it will add "<think>\n\n</think>\n\n"
+            "chat_template_kwargs": {"enable_thinking": False},
+        }
+        result = apply_chat_template(example, tokenizer)
+
+        # docstyle-ignore
+        expected = textwrap.dedent("""\
+        <|im_start|>user
+        What color is the sky?<|im_end|>
+        <|im_start|>assistant
+        <think>
+
+        </think>
+
+        """)
+
+        assert result["prompt"] == expected
+
+    def test_apply_chat_template_with_tools(self):
+        tokenizer = AutoProcessor.from_pretrained("trl-internal-testing/tiny-LlamaForCausalLM-3.2")
+
+        # Define dummy test tools
+        def get_current_temperature(location: str):
+            """
+            Gets the temperature at a given location.
+
+            Args:
+                location: The location to get the temperature for
+            """
+            return 22.0
+
+        # Define test case
+        test_case = {
+            "prompt": [
+                {"content": "What's the temperature in London?", "role": "user"},
+            ]
+        }
+        # Test with tools
+        result_with_tools = apply_chat_template(test_case, tokenizer, tools=[get_current_temperature])
+
+        # Verify tools are included in the output
+        assert "get_current_temperature" in result_with_tools["prompt"]
+
+        # Test without tools
+        result_without_tools = apply_chat_template(test_case, tokenizer, tools=None)
+
+        # Verify tools are not included in the output
+        assert "get_current_temperature" not in result_without_tools["prompt"]
+
+
+class TestApplyChatTemplateHarmony(TrlTestCase):
+    def test_language_modeling(self):
+        messages = {
+            "messages": [
+                {"role": "system", "content": "Respond in a friendly manner."},
+                {"role": "user", "content": "What color is the sky?"},
+                {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."},
+            ],
+        }
+        output = apply_chat_template(
+            messages,
+            processing_class=AutoTokenizer.from_pretrained("trl-internal-testing/tiny-GptOssForCausalLM"),
+            reasoning_effort="low",
+            model_identity="You are HuggingGPT.",
+        )
+
+        # docstyle-ignore
+        expected = textwrap.dedent(f"""\
+        <|start|>system<|message|>You are HuggingGPT.
+        Knowledge cutoff: 2024-06
+        Current date: {strftime("%Y-%m-%d")}
+
+        Reasoning: low
+
+        # Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>developer<|message|># Instructions
+
+        Respond in a friendly manner.
+
+        <|end|><|start|>user<|message|>What color is the sky?<|end|><|start|>assistant<|channel|>analysis<|message|>The user asks the color of the sky...<|end|><|start|>assistant<|channel|>final<|message|>It is blue.<|return|>""")
+
+        assert output["text"] == expected
+
+    def test_prompt_only(self):
+        messages = {
+            "prompt": [
+                {"role": "system", "content": "Respond in a friendly manner."},
+                {"role": "user", "content": "What color is the sky?"},
+            ],
+        }
+        output = apply_chat_template(
+            messages,
+            processing_class=AutoTokenizer.from_pretrained("trl-internal-testing/tiny-GptOssForCausalLM"),
+            reasoning_effort="low",
+            model_identity="You are HuggingGPT.",
+        )
+
+        # docstyle-ignore
+        expected = textwrap.dedent(f"""\
+        <|start|>system<|message|>You are HuggingGPT.
+        Knowledge cutoff: 2024-06
+        Current date: {strftime("%Y-%m-%d")}
+
+        Reasoning: low
+
+        # Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>developer<|message|># Instructions
+
+        Respond in a friendly manner.
+
+        <|end|><|start|>user<|message|>What color is the sky?<|end|><|start|>assistant""")
+
+        assert output["prompt"] == expected
+
+    def test_prompt_completion(self):
+        messages = {
+            "prompt": [
+                {"role": "system", "content": "Respond in a friendly manner."},
+                {"role": "user", "content": "What color is the sky?"},
+            ],
+            "completion": [
+                {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."},
+            ],
+        }
+        output = apply_chat_template(
+            messages,
+            processing_class=AutoTokenizer.from_pretrained("trl-internal-testing/tiny-GptOssForCausalLM"),
+            reasoning_effort="low",
+            model_identity="You are HuggingGPT.",
+        )
+
+        # docstyle-ignore
+        expected_prompt = textwrap.dedent(f"""\
+        <|start|>system<|message|>You are HuggingGPT.
+        Knowledge cutoff: 2024-06
+        Current date: {strftime("%Y-%m-%d")}
+
+        Reasoning: low
+
+        # Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>developer<|message|># Instructions
+
+        Respond in a friendly manner.
+
+        <|end|><|start|>user<|message|>What color is the sky?<|end|><|start|>assistant""")
+        expected_completion = "<|channel|>analysis<|message|>The user asks the color of the sky...<|end|><|start|>assistant<|channel|>final<|message|>It is blue.<|return|>"
+
+        assert output["prompt"] == expected_prompt
+        assert output["completion"] == expected_completion
+
+    def test_preference(self):
+        messages = {
+            "prompt": [
+                {"role": "system", "content": "Respond in a friendly manner."},
+                {"role": "user", "content": "What color is the sky?"},
+            ],
+            "chosen": [
+                {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."},
+            ],
+            "rejected": [
+                {"role": "assistant", "thinking": "The user asks the color of the tree...", "content": "It is green."},
+            ],
+        }
+        output = apply_chat_template(
+            messages,
+            processing_class=AutoTokenizer.from_pretrained("trl-internal-testing/tiny-GptOssForCausalLM"),
+            reasoning_effort="low",
+            model_identity="You are HuggingGPT.",
+        )
+
+        # docstyle-ignore
+        expected_prompt = textwrap.dedent(f"""\
+        <|start|>system<|message|>You are HuggingGPT.
+        Knowledge cutoff: 2024-06
+        Current date: {strftime("%Y-%m-%d")}
+
+        Reasoning: low
+
+        # Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>developer<|message|># Instructions
+
+        Respond in a friendly manner.
+
+        <|end|><|start|>user<|message|>What color is the sky?<|end|><|start|>assistant""")
+        expected_chosen = "<|channel|>analysis<|message|>The user asks the color of the sky...<|end|><|start|>assistant<|channel|>final<|message|>It is blue.<|return|>"
+        expected_rejected = "<|channel|>analysis<|message|>The user asks the color of the tree...<|end|><|start|>assistant<|channel|>final<|message|>It is green.<|return|>"
+
+        assert output["prompt"] == expected_prompt
+        assert output["chosen"] == expected_chosen
+        assert output["rejected"] == expected_rejected
+
+    def test_preference_with_implicit_prompt(self):
+        messages = {
+            "chosen": [
+                {"role": "system", "content": "Respond in a friendly manner."},
+                {"role": "user", "content": "What color is the sky?"},
+                {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."},
+            ],
+            "rejected": [
+                {"role": "system", "content": "Respond in a friendly manner."},
+                {"role": "user", "content": "What color is the sky?"},
+                {"role": "assistant", "thinking": "The user asks the color of the tree...", "content": "It is green."},
+            ],
+        }
+        output = apply_chat_template(
+            messages,
+            processing_class=AutoTokenizer.from_pretrained("trl-internal-testing/tiny-GptOssForCausalLM"),
+            reasoning_effort="low",
+            model_identity="You are HuggingGPT.",
+        )
+
+        # docstyle-ignore
+        expected_chosen = textwrap.dedent(f"""\
+        <|start|>system<|message|>You are HuggingGPT.
+        Knowledge cutoff: 2024-06
+        Current date: {strftime("%Y-%m-%d")}
+
+        Reasoning: low
+
+        # Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>developer<|message|># Instructions
+
+        Respond in a friendly manner.
+
+        <|end|><|start|>user<|message|>What color is the sky?<|end|><|start|>assistant<|channel|>analysis<|message|>The user asks the color of the sky...<|end|><|start|>assistant<|channel|>final<|message|>It is blue.<|return|>""")
+
+        # docstyle-ignore
+        expected_rejected = textwrap.dedent(f"""\
+        <|start|>system<|message|>You are HuggingGPT.
+        Knowledge cutoff: 2024-06
+        Current date: {strftime("%Y-%m-%d")}
+
+        Reasoning: low
+
+        # Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>developer<|message|># Instructions
+
+        Respond in a friendly manner.
+
+        <|end|><|start|>user<|message|>What color is the sky?<|end|><|start|>assistant<|channel|>analysis<|message|>The user asks the color of the tree...<|end|><|start|>assistant<|channel|>final<|message|>It is green.<|return|>""")
+
+        assert output["chosen"] == expected_chosen
+        assert output["rejected"] == expected_rejected
+
+    def test_unpaired_preference(self):
+        messages = {
+            "prompt": [
+                {"role": "system", "content": "Respond in a friendly manner."},
+                {"role": "user", "content": "What color is the sky?"},
+            ],
+            "completion": [
+                {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."},
+            ],
+            "label": True,
+        }
+        output = apply_chat_template(
+            messages,
+            processing_class=AutoTokenizer.from_pretrained("trl-internal-testing/tiny-GptOssForCausalLM"),
+            reasoning_effort="low",
+            model_identity="You are HuggingGPT.",
+        )
+
+        # docstyle-ignore
+        expected_prompt = textwrap.dedent(f"""\
+        <|start|>system<|message|>You are HuggingGPT.
+        Knowledge cutoff: 2024-06
+        Current date: {strftime("%Y-%m-%d")}
+
+        Reasoning: low
+
+        # Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>developer<|message|># Instructions
+
+        Respond in a friendly manner.
+
+        <|end|><|start|>user<|message|>What color is the sky?<|end|><|start|>assistant""")
+        expected_completion = "<|channel|>analysis<|message|>The user asks the color of the sky...<|end|><|start|>assistant<|channel|>final<|message|>It is blue.<|return|>"
+
+        assert output["prompt"] == expected_prompt
+        assert output["completion"] == expected_completion
+        assert output["label"]
+
+
+class TestUnpairPreferenceDataset(TrlTestCase):
+    paired_dataset = Dataset.from_dict(
+        {
+            "prompt": ["The sky is", "The sun is"],
+            "chosen": [" blue.", " in the sky."],
+            "rejected": [" green.", " in the sea."],
+        }
+    )
+
+    unpaired_dataset = Dataset.from_dict(
+        {
+            "prompt": ["The sky is", "The sun is", "The sky is", "The sun is"],
+            "completion": [" blue.", " in the sky.", " green.", " in the sea."],
+            "label": [True, True, False, False],
+        }
+    )
+
+    def test_unpair_preference_dataset(self):
+        # Test that a paired dataset is correctly converted to unpaired
+        unpaired_dataset = unpair_preference_dataset(self.paired_dataset)
+        assert unpaired_dataset.to_dict() == self.unpaired_dataset.to_dict(), (
+            "The paired dataset should be converted to unpaired."
+        )
+
+    def test_unpair_preference_dataset_extra_columns(self):
+        # Test that extra columns are dropped (not causing a length mismatch error)
+        paired_dataset = Dataset.from_dict(
+            {
+                "prompt": ["The sky is", "The sun is"],
+                "chosen": [" blue.", " in the sky."],
+                "rejected": [" green.", " in the sea."],
+                "extra": [1, 2],
+            }
+        )
+        unpaired_dataset = unpair_preference_dataset(paired_dataset)
+        assert unpaired_dataset.to_dict() == self.unpaired_dataset.to_dict()
+
+    def test_unpair_preference_dataset_iterable(self):
+        # Test that an IterableDataset with extra columns is correctly unpaired
+        paired_dataset = self.paired_dataset.to_iterable_dataset()
+        unpaired_dataset = unpair_preference_dataset(paired_dataset)
+        assert list(unpaired_dataset) == [
+            dict(zip(self.unpaired_dataset.column_names, vals, strict=False))
+            for vals in zip(*self.unpaired_dataset.to_dict().values(), strict=False)
+        ]
+
+    def test_unpair_preference_dataset_iterable_extra_columns(self):
+        # Test that an IterableDataset with extra columns drops them without error
+        paired_iterable = Dataset.from_dict(
+            {
+                "prompt": ["The sky is", "The sun is"],
+                "chosen": [" blue.", " in the sky."],
+                "rejected": [" green.", " in the sea."],
+                "extra": [1, 2],
+            }
+        ).to_iterable_dataset()
+        unpaired_dataset = unpair_preference_dataset(paired_iterable)
+        assert list(unpaired_dataset) == [
+            dict(zip(self.unpaired_dataset.column_names, vals, strict=False))
+            for vals in zip(*self.unpaired_dataset.to_dict().values(), strict=False)
+        ]
+
+    def test_unpair_preference_dataset_dict(self):
+        # Test that a paired dataset dict is correctly converted to unpaired
+        paired_dataset_dict = DatasetDict({"abc": self.paired_dataset})
+        unpaired_dataset_dict = unpair_preference_dataset(paired_dataset_dict)
+        assert unpaired_dataset_dict["abc"].to_dict() == self.unpaired_dataset.to_dict(), (
+            "The paired dataset should be converted to unpaired."
+        )
+
+    def test_maybe_unpair_preference_dataset(self):
+        # Test that a paired dataset is correctly converted to unpaired with maybe_unpair_preference_dataset
+        unpaired_dataset = maybe_unpair_preference_dataset(self.paired_dataset)
+        assert unpaired_dataset.to_dict() == self.unpaired_dataset.to_dict(), (
+            "The paired dataset should be converted to unpaired."
+        )
+
+    def test_maybe_unpair_preference_dataset_dict(self):
+        # Test that a paired dataset dict is correctly converted to unpaired with maybe_unpair_preference_dataset
+        paired_dataset_dict = DatasetDict({"abc": self.paired_dataset})
+        unpaired_dataset_dict = maybe_unpair_preference_dataset(paired_dataset_dict)
+        assert unpaired_dataset_dict["abc"].to_dict() == self.unpaired_dataset.to_dict(), (
+            "The paired dataset should be converted to unpaired."
+        )
+
+    def test_maybe_unpair_preference_dataset_already_paired(self):
+        # Test that a paired dataset remains unchanged with maybe_unpair_preference_dataset
+        unpaired_dataset = maybe_unpair_preference_dataset(self.unpaired_dataset)
+        assert unpaired_dataset.to_dict() == self.unpaired_dataset.to_dict(), (
+            "The unpaired dataset should remain unchanged."
+        )
+
+    def test_maybe_unpair_preference_dataset_dict_already_paired(self):
+        # Test that a paired dataset dict remains unchanged with maybe_unpair_preference_dataset
+        unpaired_dataset_dict = maybe_unpair_preference_dataset(DatasetDict({"abc": self.unpaired_dataset}))
+        assert unpaired_dataset_dict["abc"].to_dict() == self.unpaired_dataset.to_dict(), (
+            "The unpaired dataset should remain unchanged."
+        )
+
+
+class TestExtractPrompt(TrlTestCase):
+    example_implicit_prompt_conversational = {
+        "chosen": [
+            {"role": "user", "content": "What color is the sky?"},
+            {"role": "assistant", "content": "It is blue."},
+        ],
+        "rejected": [
+            {"role": "user", "content": "What color is the sky?"},
+            {"role": "assistant", "content": "It is green."},
+        ],
+    }
+
+    example_explicit_prompt_conversational = {
+        "prompt": [
+            {"role": "user", "content": "What color is the sky?"},
+        ],
+        "chosen": [
+            {"role": "assistant", "content": "It is blue."},
+        ],
+        "rejected": [
+            {"role": "assistant", "content": "It is green."},
+        ],
+    }
+
+    example_implicit_prompt_standard = {
+        "chosen": "The sky is blue.",
+        "rejected": "The sky is green.",
+    }
+
+    example_explicit_prompt_standard = {
+        "prompt": "The sky is",
+        "chosen": " blue.",
+        "rejected": " green.",
+    }
+
+    def test_extract_prompt_conversational(self):
+        # Test that the prompt is correctly extracted from the dataset
+        example_extracted_prompt = extract_prompt(self.example_implicit_prompt_conversational)
+        assert example_extracted_prompt == self.example_explicit_prompt_conversational, (
+            "The prompt is not correctly extracted from the dataset."
+        )
+
+    def test_maybe_extract_prompt_conversational(self):
+        # Test that the prompt is correctly extracted from the dataset with maybe_extract_prompt
+        example_extracted_prompt = maybe_extract_prompt(self.example_implicit_prompt_conversational)
+        assert example_extracted_prompt == self.example_explicit_prompt_conversational, (
+            "The prompt is not correctly extracted from the dataset."
+        )
+
+    def test_maybe_extract_prompt_conversational_already_explicit(self):
+        # Test that the prompt remains unchanged with maybe_extract_prompt
+        example_extracted_prompt = maybe_extract_prompt(self.example_explicit_prompt_conversational)
+        assert example_extracted_prompt == self.example_explicit_prompt_conversational, (
+            "The prompt should remain unchanged."
+        )
+
+    def test_extract_prompt_standard(self):
+        # Test that the prompt is correctly extracted from the dataset
+        example_extracted_prompt = extract_prompt(self.example_implicit_prompt_standard)
+        assert example_extracted_prompt == self.example_explicit_prompt_standard, (
+            "The prompt is not correctly extracted from the dataset."
+        )
+
+    def test_maybe_extract_prompt_standard(self):
+        # Test that the prompt is correctly extracted from the dataset with maybe_extract_prompt
+        example_extracted_prompt = maybe_extract_prompt(self.example_implicit_prompt_standard)
+        assert example_extracted_prompt == self.example_explicit_prompt_standard, (
+            "The prompt is not correctly extracted from the dataset."
+        )
+
+    def test_maybe_extract_prompt_standard_already_explicit(self):
+        # Test that the prompt remains unchanged with maybe_extract_prompt
+        example_extracted_prompt = maybe_extract_prompt(self.example_explicit_prompt_standard)
+        assert example_extracted_prompt == self.example_explicit_prompt_standard, "The prompt should remain unchanged."
+
+
+class TestPackDatasetWrapped(TrlTestCase):
+    def test_with_dataset(self):
+        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)
+        dataset = dataset.with_format("numpy", dtype="float32")
+        format = dataset.format
+        seq_length = 3
+        expected_output = {
+            "input_ids": [[1, 2, 3], [4, 5, 6], [7, 8]],
+            "attention_mask": [[0, 1, 1], [0, 0, 1], [1, 1]],
+        }
+        dataset = pack_dataset(dataset, seq_length, strategy="wrapped")
+        assert dataset.to_dict() == expected_output
+        assert format == dataset.format
+
+    def test_with_iterable_dataset(self):
+        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).to_iterable_dataset()
+        dataset = dataset.with_format("numpy")
+        formatting = dataset._formatting
+        seq_length = 3
+        expected_output = {
+            "input_ids": [[1, 2, 3], [4, 5, 6], [7, 8]],
+            "attention_mask": [[0, 1, 1], [0, 0, 1], [1, 1]],
+        }
+        dataset = pack_dataset(dataset, seq_length, strategy="wrapped")
+        num_examples = len(examples[next(iter(examples))])
+        assert next(iter(dataset.with_format(None).batch(batch_size=num_examples))) == expected_output
+        assert formatting == dataset._formatting
+
+
+class TestPackDatasetBfd(TrlTestCase):
+    def test_with_dataset(self):
+        examples = {
+            "input_ids": [[1, 2, 3], [4, 5, 6, 7], [8]],
+        }
+        dataset = Dataset.from_dict(examples)
+        dataset = dataset.with_format("numpy", dtype="float32")
+        format = dataset.format
+        seq_length = 4
+        expected_output = {
+            "input_ids": [[4, 5, 6, 7], [1, 2, 3, 8]],
+            "seq_lengths": [[4], [3, 1]],
+        }
+        dataset = pack_dataset(dataset, seq_length, strategy="bfd")
+        expected_format = dataset.format
+        assert dataset.to_dict() == expected_output
+        assert "seq_lengths" in expected_format["columns"]
+        expected_format["columns"].remove("seq_lengths")
+        assert format == dataset.format
+
+    def test_with_iterable_dataset(self):
+        examples = {
+            "input_ids": [[1, 2, 3], [4, 5, 6, 7], [8]],
+        }
+        dataset = Dataset.from_dict(examples).to_iterable_dataset()
+        dataset = dataset.with_format("numpy")
+        formatting = dataset._formatting
+        seq_length = 4
+        expected_output = {
+            "input_ids": [[4, 5, 6, 7], [1, 2, 3, 8]],
+            "seq_lengths": [[4], [3, 1]],
+        }
+        dataset = pack_dataset(dataset, seq_length, strategy="bfd")
+        num_examples = len(examples[next(iter(examples))])
+        assert next(iter(dataset.with_format(None).batch(batch_size=num_examples))) == expected_output
+        assert formatting == dataset._formatting
+
+    def test_with_overlong_0(self):
+        examples = {
+            "input_ids": [[1, 2, 3, 4, 5], [6, 7], [8, 9, 10, 11], [12]],
+        }
+        dataset = Dataset.from_dict(examples)
+        seq_length = 4
+        expected_output = {
+            "input_ids": [[1, 2, 3, 4], [8, 9, 10, 11], [6, 7, 5, 12]],
+            "seq_lengths": [[4], [4], [2, 1, 1]],
+        }
+        dataset = pack_dataset(dataset, seq_length, strategy="bfd_split")
+        assert dataset.to_dict() == expected_output
+
+    def test_with_overlong_two_coluns(self):
+        examples = {
+            "col1": [[1, -2, 3, -4, 5, -6], [7, -8, 9], [-10, 11, -12], [13, -14, 15, -16]],
+            "col2": [[-1, 2, -3, 4, -5, 6], [-7, 8, -9], [10, -11, 12], [-13, 14, -15, 16]],
+        }
+        dataset = Dataset.from_dict(examples)
+        seq_length = 4
+        expected_output = {
+            "col1": [[1, -2, 3, -4], [13, -14, 15, -16], [7, -8, 9], [-10, 11, -12], [5, -6]],
+            "col2": [[-1, 2, -3, 4], [-13, 14, -15, 16], [-7, 8, -9], [10, -11, 12], [-5, 6]],
+            "seq_lengths": [[4], [4], [3], [3], [2]],
+        }
+        dataset = pack_dataset(dataset, seq_length, strategy="bfd_split")
+        assert dataset.to_dict() == expected_output
+
+    def test_with_non_power_of_2(self):
+        examples = {
+            "input_ids": [[1, 2, 3, 4, 5], [6], [7, 8, 9, 10], [11, 12, 13]],
+        }
+        dataset = Dataset.from_dict(examples)
+        seq_length = 5
+        expected_output = {
+            "input_ids": [[1, 2, 3, 4, 5], [7, 8, 9, 10, 6], [11, 12, 13]],
+            "seq_lengths": [[5], [4, 1], [3]],
+        }
+        dataset = pack_dataset(dataset, seq_length, strategy="bfd_split")
+        assert dataset.to_dict() == expected_output
+
+    def test_default_no_split(self):
+        """Test default 'bfd' strategy for SFT datasets (truncates overflow)."""
+        examples = {
+            "input_ids": [[1, 2, 3, 4, 5], [6, 7], [8, 9, 10, 11], [12]],
+        }
+        dataset = Dataset.from_dict(examples)
+        seq_length = 4
+        # With default 'bfd' strategy, overflow tokens are discarded
+        expected_output = {
+            "input_ids": [[1, 2, 3, 4], [8, 9, 10, 11], [6, 7, 12]],
+            "seq_lengths": [[4], [4], [2, 1]],
+        }
+        dataset = pack_dataset(dataset, seq_length, strategy="bfd")
+        assert dataset.to_dict() == expected_output
+
+    def test_with_empty_sequences(self):
+        examples = {
+            "input_ids": [[1, 2], [], [3, 4, 5], [], [6]],
+        }
+        dataset = Dataset.from_dict(examples)
+        seq_length = 4
+        expected_output = {
+            "input_ids": [[3, 4, 5, 6], [1, 2]],
+            "seq_lengths": [[3, 1], [2]],
+        }
+        dataset = pack_dataset(dataset, seq_length, strategy="bfd_split")
+        assert dataset.to_dict() == expected_output
+
+
+class TestMaybeConvertToChatML(TrlTestCase):
+    def test_with_conversations_key(self):
+        # Particular case where the key is "conversations": we rename it to "messages"
+        example = {
+            "conversations": [
+                {"from": "user", "value": "What color is the sky?"},
+                {"from": "assistant", "value": "It is blue."},
+            ]
+        }
+        expected_output = {
+            "messages": [
+                {"role": "user", "content": "What color is the sky?"},
+                {"role": "assistant", "content": "It is blue."},
+            ]
+        }
+        assert maybe_convert_to_chatml(example) == expected_output
+
+    def test_without_conversations_key(self):
+        # Same as before, but we don't rename the keys
+        example = {
+            "prompt": [{"from": "user", "value": "What color is the sky?"}],
+            "completion": [{"from": "assistant", "value": "It is blue."}],
+        }
+        expected_output = {
+            "prompt": [{"role": "user", "content": "What color is the sky?"}],
+            "completion": [{"role": "assistant", "content": "It is blue."}],
+        }
+        assert maybe_convert_to_chatml(example) == expected_output
+
+    def test_not_conversional(self):
+        # When not needed, the example should remain unchanged
+        example = {"text": "The sky is blue."}
+        assert maybe_convert_to_chatml(example) == example
+
+    def test_already_chatml(self):
+        # When the example is already in ChatML format, it should remain unchanged
+        example = {
+            "messages": [
+                {"role": "user", "content": "What color is the sky?"},
+                {"role": "assistant", "content": "It is blue."},
+            ]
+        }
+        assert maybe_convert_to_chatml(example) == example

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_dpo_trainer.py

@@ -0,0 +1,1358 @@
+# 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 pytest
+import torch
+import transformers
+from datasets import load_dataset
+from packaging.version import Version
+from packaging.version import parse as parse_version
+from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+from transformers.testing_utils import torch_device
+from transformers.utils import is_peft_available
+
+from trl import DPOConfig, DPOTrainer
+from trl.trainer.dpo_trainer import DataCollatorForPreference, DataCollatorForVisionPreference
+
+from .testing_utils import (
+    TrlTestCase,
+    is_ampere_or_newer,
+    require_bitsandbytes,
+    require_kernels,
+    require_liger_kernel,
+    require_peft,
+    require_vision,
+)
+
+
+if is_peft_available():
+    from peft import LoraConfig, get_peft_model
+
+
+class TestDataCollatorForPreference(TrlTestCase):
+    def test_padding_and_masks(self):
+        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, 10], "rejected_ids": [11, 12, 13]},
+        ]
+        result = collator(examples)
+
+        expected_input_ids = torch.tensor(
+            [
+                [1, 2, 3, 4, 5],  # prompt + chosen (example 1)
+                [7, 8, 9, 10, 0],  # prompt + chosen (example 2, padded)
+                [1, 2, 3, 6, 0],  # prompt + rejected (example 1, padded)
+                [7, 8, 11, 12, 13],  # prompt + rejected (example 2)
+            ]
+        )
+        expected_attention_mask = torch.tensor(
+            [
+                [1, 1, 1, 1, 1],
+                [1, 1, 1, 1, 0],
+                [1, 1, 1, 1, 0],
+                [1, 1, 1, 1, 1],
+            ]
+        )
+        expected_completion_mask = torch.tensor(
+            [
+                [0, 0, 0, 1, 1],  # chosen completion (example 1)
+                [0, 0, 1, 1, 0],  # chosen completion (example 2, padded)
+                [0, 0, 0, 1, 0],  # rejected completion (example 1, padded)
+                [0, 0, 1, 1, 1],  # rejected completion (example 2)
+            ]
+        )
+
+        assert set(result.keys()) == {"input_ids", "attention_mask", "completion_mask"}
+        torch.testing.assert_close(result["input_ids"], expected_input_ids)
+        torch.testing.assert_close(result["attention_mask"], expected_attention_mask)
+        torch.testing.assert_close(result["completion_mask"], expected_completion_mask)
+
+    def test_optional_reference_logps(self):
+        collator = DataCollatorForPreference(pad_token_id=0)
+        examples = [
+            {
+                "prompt_ids": [1, 2],
+                "chosen_ids": [3],
+                "rejected_ids": [4],
+                "ref_chosen_logps": 0.1,
+                "ref_rejected_logps": 0.2,
+            },
+            {
+                "prompt_ids": [5],
+                "chosen_ids": [6, 7],
+                "rejected_ids": [8, 9],
+                "ref_chosen_logps": 0.3,
+                "ref_rejected_logps": 0.4,
+            },
+        ]
+        result = collator(examples)
+
+        expected_ref_chosen_logps = torch.tensor([0.1, 0.3])
+        expected_ref_rejected_logps = torch.tensor([0.2, 0.4])
+
+        assert set(result.keys()) == {
+            "input_ids",
+            "attention_mask",
+            "completion_mask",
+            "ref_chosen_logps",
+            "ref_rejected_logps",
+        }
+        torch.testing.assert_close(result["ref_chosen_logps"], expected_ref_chosen_logps)
+        torch.testing.assert_close(result["ref_rejected_logps"], expected_ref_rejected_logps)
+
+    def test_with_pad_to_multiple_of(self):
+        collator = DataCollatorForPreference(pad_token_id=0, pad_to_multiple_of=5)
+        examples = [
+            {"prompt_ids": [1], "chosen_ids": [2], "rejected_ids": [3]},
+            {"prompt_ids": [4, 5], "chosen_ids": [6, 7], "rejected_ids": [8, 9]},
+        ]
+        result = collator(examples)
+
+        expected_input_ids = torch.tensor(
+            [
+                [1, 2, 0, 0, 0],  # prompt + chosen (example 1, padded to multiple of 5)
+                [4, 5, 6, 7, 0],  # prompt + chosen (example 2)
+                [1, 3, 0, 0, 0],  # prompt + rejected (example 1, padded to multiple of 5)
+                [4, 5, 8, 9, 0],  # prompt + rejected (example 2)
+            ]
+        )
+
+        assert set(result.keys()) == {"input_ids", "attention_mask", "completion_mask"}
+        torch.testing.assert_close(result["input_ids"], expected_input_ids)
+
+
+class TestDataCollatorForVisionPreference(TrlTestCase):
+    @pytest.mark.skipif(
+        Version(transformers.__version__) < Version("5.3.0"),
+        reason="mm_token_type_ids are returned by default since transformers-5.3.0 (see transformers#43972)",
+    )
+    @require_vision
+    def test_mm_token_type_ids_shape(self):
+        # Regression test: when the processor returns mm_token_type_ids (e.g. Qwen2.5-VL after
+        # transformers#43972), the collator must concatenate it with zeros for the completion part
+        # so that its shape matches input_ids. Without the fix this raises an IndexError in the model.
+        from PIL import Image
+        from transformers import AutoProcessor
+
+        processor = AutoProcessor.from_pretrained("trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration")
+        collator = DataCollatorForVisionPreference(processor)
+        image = Image.new("RGB", (16, 16))
+        examples = [
+            {
+                "images": [image],
+                "prompt": [{"role": "user", "content": "What is this?"}],
+                "chosen": [{"role": "assistant", "content": "A red square."}],
+                "rejected": [{"role": "assistant", "content": "A blue circle."}],
+            }
+        ]
+        output = collator(examples)
+        assert "mm_token_type_ids" in output
+        assert output["mm_token_type_ids"].shape == output["input_ids"].shape, (
+            f"mm_token_type_ids shape {output['mm_token_type_ids'].shape} != "
+            f"input_ids shape {output['input_ids'].shape}"
+        )
+
+
+class TestDPOTrainer(TrlTestCase):
+    @pytest.mark.parametrize(
+        "model_id",
+        [
+            "trl-internal-testing/tiny-Cohere2ForCausalLM",
+            pytest.param(
+                "trl-internal-testing/tiny-Glm4MoeForCausalLM",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.0.0"),
+                    reason="GLM4 tokenizer requires transformers>=5.0.0",
+                ),
+            ),
+            "trl-internal-testing/tiny-GptOssForCausalLM",
+            "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            "trl-internal-testing/tiny-Qwen3MoeForCausalLM",
+            pytest.param(
+                "trl-internal-testing/tiny-NemotronHForCausalLM-nano",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.7.0"),
+                    reason="Nemotron 3 gradient checkpointing requires transformers>=5.7.0 (see transformers#45625)",
+                ),
+            ),
+            pytest.param(
+                "trl-internal-testing/tiny-Olmo3ForCausalLM",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("4.57.0"),
+                    reason="Olmo 3 requires transformers>=4.57.0",
+                ),
+            ),
+        ],
+    )
+    def test_train(self, model_id):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+        )
+        trainer = DPOTrainer(model=model_id, args=training_args, train_dataset=dataset)
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @pytest.mark.parametrize("precompute_ref_log_probs", [False, True])
+    def test_evaluate_with_raw_dataset(self, precompute_ref_log_probs):
+        # `evaluate` should accept the same (unprocessed) dataset types as the trainer, e.g. a held-out test set
+        # passed directly to `evaluate`. With `precompute_ref_log_probs=True`, the reference log-probs must also be
+        # precomputed for the freshly-passed dataset. See https://github.com/huggingface/trl/issues/6115.
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir, precompute_ref_log_probs=precompute_ref_log_probs, report_to="none"
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset
+        )
+
+        metrics = trainer.evaluate(eval_dataset=dataset)
+        assert metrics["eval_loss"] is not None
+
+    def test_trust_remote_code(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+        model_id = "trl-internal-testing/tiny-RemoteForCausalLM"
+
+        with pytest.raises(ValueError, match="custom code"):
+            DPOTrainer(
+                model=model_id,
+                args=DPOConfig(output_dir=self.tmp_dir, report_to="none"),
+                train_dataset=dataset,
+            )
+
+        trainer = DPOTrainer(
+            model=model_id,
+            args=DPOConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True),
+            train_dataset=dataset,
+        )
+        assert type(trainer.model).__name__ == "RemoteForCausalLM"
+
+    @pytest.mark.parametrize(
+        "config_name",
+        [
+            "standard_preference",
+            "conversational_preference",
+            "standard_implicit_prompt_preference",
+            "conversational_implicit_prompt_preference",
+        ],
+    )
+    def test_train_dataset_format(self, config_name):
+        dataset = load_dataset("trl-internal-testing/zen", config_name, split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    # Special case for harmony
+    def test_train_gpt_oss(self):
+        dataset = load_dataset("trl-internal-testing/harmony", "preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-GptOssForCausalLM", args=training_args, train_dataset=dataset
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_model(self):
+        model = AutoModelForCausalLM.from_pretrained(
+            "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            dtype="float32",
+        )
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+        )
+        trainer = DPOTrainer(model=model, args=training_args, train_dataset=dataset)
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @pytest.mark.parametrize(
+        "loss_type",
+        [
+            "sigmoid",
+            "hinge",
+            "ipo",
+            "exo_pair",
+            "nca_pair",
+            "robust",
+            "bco_pair",
+            "sppo_hard",
+            "aot",
+            "aot_unpaired",
+            "apo_zero",
+            "apo_down",
+            "discopop",
+            "sft",
+            "sigmoid_norm",
+        ],
+    )
+    def test_train_loss_types(self, loss_type):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            loss_type=loss_type,
+            label_smoothing=1e-3 if loss_type == "exo_pair" else 0.0,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+            eval_strategy="steps",
+            eval_steps=3,
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset["train"],
+            eval_dataset=dataset["test"],
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_multi_loss_types(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            loss_type=["sigmoid", "bco_pair", "sft"],  # this specific combination is used in MPO
+            report_to="none",
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_wpo(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+            use_weighting=True,
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_ld(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+            ld_alpha=0.5,
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @pytest.mark.parametrize(
+        "f_divergence_type",
+        ["reverse_kl", "forward_kl", "js_divergence", "alpha_divergence"],
+    )
+    def test_train_with_f_divergence(self, f_divergence_type):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+            f_divergence_type=f_divergence_type,
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_explicit_ref_model(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+        )
+        # When specifying a ref model, it's usually because we want it to be a different checkpoint, but for testing
+        # purposes we will just just use the same checkpoint
+        ref_model = AutoModelForCausalLM.from_pretrained(
+            "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32"
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            ref_model=ref_model,
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+            new_ref_param = trainer.ref_model.get_parameter(n)
+            torch.testing.assert_close(param, new_ref_param, msg=f"Reference model parameter {n} has changed.")
+
+    def test_train_with_sync_ref_model(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            sync_ref_model=True,
+            ref_model_sync_steps=2,  # reduce sync steps to ensure a sync happens
+            report_to="none",
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+        assert trainer.ref_model is not None
+        previous_ref_params = {n: param.clone() for n, param in trainer.ref_model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+            new_ref_param = trainer.ref_model.get_parameter(n)
+            assert not torch.equal(previous_ref_params[n], new_ref_param), f"Ref Parameter {n} has not changed."
+
+    def test_train_model_dtype(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            model_init_kwargs={"dtype": torch.float16},
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            # For some reasonn model.layers.0.input_layernorm.weight doesn't change in GitHub Actions but does
+            # locally. We ignore this parameter for now
+            if "layernorm" in n:
+                continue
+            new_param = trainer.model.get_parameter(n)
+            # Check the torch dtype
+            assert new_param.dtype == torch.float16
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @require_peft
+    def test_train_dense_with_peft_config_lora(self):
+        model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+        base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()]
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=1.0,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+        )
+
+        trainer = DPOTrainer(
+            model=model_id,
+            args=training_args,
+            train_dataset=dataset,
+            peft_config=LoraConfig(),
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the peft params have changed and the base model params have not changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n in base_param_names:  # We expect the base model params to be the same
+                torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.")
+            elif "base_layer" not in n:  # We expect the peft params to be different (except for the base layer)
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @require_peft
+    def test_train_moe_with_peft_config(self):
+        model_id = "trl-internal-testing/tiny-GptOssForCausalLM"
+        model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+        base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()]
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+        )
+
+        trainer = DPOTrainer(
+            model=model_id,
+            args=training_args,
+            train_dataset=dataset,
+            peft_config=LoraConfig(target_parameters=["mlp.experts.down_proj", "mlp.experts.gate_up_proj"]),
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the peft params have changed and the base model params have not changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n in base_param_names:  # We expect the base model params to be the same
+                torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.")
+            elif "base_layer" not in n:  # We expect the peft params to be different (except for the base layer)
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @require_peft
+    def test_train_peft_model(self):
+        model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+
+        base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()]
+
+        lora_config = LoraConfig()
+        model = get_peft_model(model, lora_config)
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=1.0,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+        )
+        trainer = DPOTrainer(model=model, args=training_args, train_dataset=dataset)
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the peft params have changed and the base model params have not changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n in base_param_names:  # We expect the base model params to be the same
+                torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.")
+            elif "base_layer" not in n and "ref" not in n:  # and the peft params to be different (except base and ref)
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @require_peft
+    def test_train_moe_peft_model(self):
+        # Regression test for https://github.com/huggingface/trl/issues/5222. PEFT only supports one adapter per model
+        # when the LoRA config uses `target_parameters` (see peft#3340), so no "ref" adapter can be created and the
+        # reference log probs are computed with adapters disabled instead.
+        model_id = "trl-internal-testing/tiny-GptOssForCausalLM"
+        model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+        base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()]
+
+        lora_config = LoraConfig(target_parameters=["mlp.experts.down_proj", "mlp.experts.gate_up_proj"])
+        model = get_peft_model(model, lora_config)
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+        )
+        trainer = DPOTrainer(model=model, args=training_args, train_dataset=dataset)
+
+        assert "ref" not in trainer.model.peft_config
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the peft params have changed and the base model params have not changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n in base_param_names:  # We expect the base model params to be the same
+                torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.")
+            elif "base_layer" not in n:  # We expect the peft params to be different (except for the base layer)
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    # In practice, this test is the same as `test_train_dense_with_peft_config_lora`, since gradient checkpointing is
+    # enabled by default in `DPOTrainer`. We keep it as a regression guard: if the default ever changes, we still
+    # explicitly test PEFT + gradient checkpointing, which has caused issues in the past.
+    @require_peft
+    def test_train_with_peft_config_and_gradient_checkpointing(self):
+        model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+        base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()]
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            gradient_checkpointing=True,
+            report_to="none",
+        )
+
+        trainer = DPOTrainer(
+            model=model_id,
+            args=training_args,
+            train_dataset=dataset,
+            peft_config=LoraConfig(),
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the peft params have changed and the base model params have not changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n in base_param_names:  # We expect the base model params to be the same
+                torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.")
+            elif "base_layer" not in n:  # We expect the peft params to be different (except for the base layer)
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @require_liger_kernel
+    def test_train_with_liger(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            use_liger_kernel=True,
+            report_to="none",
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @require_liger_kernel
+    @require_peft
+    def test_init_fails_with_peft_and_liger(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            use_liger_kernel=True,
+            report_to="none",
+        )
+
+        with pytest.raises(NotImplementedError, match="Liger DPO loss is not implemented for PEFT models."):
+            DPOTrainer(
+                model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+                args=training_args,
+                train_dataset=dataset,
+                peft_config=LoraConfig(),
+            )
+
+    def test_train_with_iterable_dataset(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train", streaming=True)
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            max_steps=3,
+            report_to="none",
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @require_kernels
+    @pytest.mark.skipif(
+        not is_ampere_or_newer() and torch_device != "xpu",
+        reason="Flash Attention 2 requires Ampere or newer GPU, or XPU",
+    )
+    def test_train_padding_free(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            padding_free=True,
+            model_init_kwargs={"attn_implementation": "kernels-community/flash-attn2"},
+            bf16=True,  # flash_attention_2 only supports bf16 and fp16
+            report_to="none",
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_chat_template_kwargs(self):
+        dataset = load_dataset("trl-internal-testing/zen", "conversational_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+        )
+
+        tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5")
+        # The following template is a simplified version of the Qwen chat template, where an additional argument
+        # `role_capital` is used to control the capitalization of roles.
+        tokenizer.chat_template = '{%- if messages[0]["role"] == "system" -%}    {{ "<|im_start|>" + ("SYSTEM" if role_capital else "system") + "\\n" + messages[0]["content"] + "<|im_end|>\\n" }}{%- else -%}    {{ "<|im_start|>" + ("SYSTEM" if role_capital else "system") + "\\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\\n" }}{%- endif -%}{%- for message in messages -%}    {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) -%}        {{ "<|im_start|>" + (message.role.upper() if role_capital else message.role) + "\\n" + message.content + "<|im_end|>\\n" }}    {%- elif message.role == "assistant" -%}        {{ "<|im_start|>" + ("ASSISTANT" if role_capital else "assistant") }}        {%- if message.content -%}            {{ "\\n" + message.content }}        {%- endif -%}        {{ "<|im_end|>\\n" }}    {%- elif message.role == "tool" -%}        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") -%}            {{ "<|im_start|>" + ("USER" if role_capital else "user") }}        {%- endif -%}        {{ "\\n<tool_response>\\n" + message.content + "\\n</tool_response>" }}        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") -%}            {{ "<|im_end|>\\n" }}        {%- endif -%}    {%- endif -%}{%- endfor -%}{%- if add_generation_prompt -%}    {{ "<|im_start|>" + ("ASSISTANT" if role_capital else "assistant") + "\\n" }}{%- endif -%}'
+
+        dataset = dataset.add_column(
+            "chat_template_kwargs", [{"role_capital": bool(i % 2)} for i in range(len(dataset))]
+        )
+        assert "chat_template_kwargs" in dataset.features
+
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+            processing_class=tokenizer,
+        )
+
+        assert trainer.processing_class.chat_template == tokenizer.chat_template
+
+        for i in range(2):
+            role = "SYSTEM" if i else "system"
+            system_prompt = (
+                f"<|im_start|>{role}\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>"
+            )
+            system_prompt_ids = trainer.processing_class(system_prompt)["input_ids"]
+            assert trainer.train_dataset[i]["prompt_ids"][: len(system_prompt_ids)] == system_prompt_ids
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_toolcall_data(self):
+        dataset = load_dataset("trl-internal-testing/toolcall", "preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=2,  # toolcall sequences are longer than standard data, reduce batch size to avoid OOM
+            max_length=512,  # toolcall sequences are longer than standard data, limit length to avoid OOM
+            report_to="none",
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_eval(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference")
+
+        training_args = DPOConfig(output_dir=self.tmp_dir, eval_strategy="steps", eval_steps=3, report_to="none")
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset["train"],
+            eval_dataset=dataset["test"],
+        )
+
+        trainer.train()
+
+        assert trainer.state.log_history[0]["eval_loss"] is not None
+
+    def test_train_with_multiple_eval_dataset(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference")
+
+        training_args = DPOConfig(output_dir=self.tmp_dir, eval_strategy="steps", eval_steps=3, report_to="none")
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset["train"],
+            eval_dataset={"data1": dataset["test"], "data2": dataset["test"]},
+        )
+        trainer.train()
+
+        assert trainer.state.log_history[-3]["eval_data1_loss"] is not None
+        assert trainer.state.log_history[-2]["eval_data2_loss"] is not None
+
+    def test_train_with_compute_metrics(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference")
+
+        def dummy_compute_metrics(eval_pred):
+            return {"my_metric": 0.123}
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            eval_strategy="steps",
+            eval_steps=3,
+            report_to="none",
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset["train"],
+            eval_dataset=dataset["test"],
+            compute_metrics=dummy_compute_metrics,
+        )
+
+        trainer.train()
+
+        assert trainer.state.log_history[-2]["eval_my_metric"] == 0.123
+
+    # In practice, this test is the same as `test_train`, since gradient checkpointing is enabled by default in
+    # `DPOTrainer`. We keep it as a regression guard: if the default ever changes, we still explicitly test gradient
+    # checkpointing, which has caused issues in the past.
+    def test_train_with_gradient_checkpointing(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            gradient_checkpointing=True,
+            report_to="none",
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_tag_added(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            train_dataset=dataset,
+        )
+
+        for tag in ["dpo", "trl"]:
+            assert tag in trainer.model.model_tags
+
+    @require_peft
+    def test_tag_added_peft(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            train_dataset=dataset,
+            peft_config=LoraConfig(),
+        )
+
+        for tag in ["dpo", "trl"]:
+            assert tag in trainer.model.model_tags
+
+    @require_peft
+    @require_bitsandbytes
+    def test_peft_with_quantization(self):
+        model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+
+        quantization_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_use_double_quant=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.float16,
+        )
+        model = AutoModelForCausalLM.from_pretrained(
+            model_id,
+            dtype="float32",
+            quantization_config=quantization_config,
+        )
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")
+
+        # Initialize the trainer with the already configured PeftModel
+        training_args = DPOConfig(output_dir=self.tmp_dir, learning_rate=0.1, report_to="none")
+        trainer = DPOTrainer(model=model, args=training_args, train_dataset=dataset, peft_config=LoraConfig())
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+        assert trainer.state.log_history[-1]["mean_token_accuracy"] is not None
+
+        # Check that the peft params have changed and the base model params have not changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            # In bitsandbytes, bias parameters are automatically cast to the input dtype during the forward pass if
+            # their dtype doesn’t match. This causes the module to change unexpectedly during the first forward pass of
+            # the training. To handle this, we cast these specific bias parameters to float32 before comparison.
+            # https://github.com/bitsandbytes-foundation/bitsandbytes/blob/45553f7392e524eacf400b132cfe01261f6477be/bitsandbytes/nn/modules.py#L518
+            # We still need to investigate why the compute dtype ends up being different than for these parameters.
+            if n in [
+                "base_model.model.model.layers.1.self_attn.k_proj.bias",
+                "base_model.model.model.layers.1.self_attn.q_proj.base_layer.bias",
+                "base_model.model.model.layers.1.self_attn.v_proj.base_layer.bias",
+            ]:
+                param = param.float()
+
+            if "lora" not in n:  # We expect the base model params to be the same
+                torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.")
+            elif "lora" in n:  # We expect the peft params to be different
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+            else:
+                raise ValueError(f"Unexpected parameter {n} in model: {trainer.model}")
+
+
+@require_vision
+class TestDPOTrainerVLM(TrlTestCase):
+    @pytest.mark.parametrize(
+        "model_id",
+        [
+            "trl-internal-testing/tiny-Gemma3ForConditionalGeneration",
+            pytest.param(
+                "trl-internal-testing/tiny-Gemma4ForConditionalGeneration",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.5.0"),
+                    reason="Gemma4 models were introduced in transformers-5.5.0",
+                ),
+            ),
+            # "trl-internal-testing/tiny-Idefics2ForConditionalGeneration",  high memory peak, skipped for now
+            # "trl-internal-testing/tiny-Idefics3ForConditionalGeneration",  high memory peak, skipped for now
+            "trl-internal-testing/tiny-LlavaForConditionalGeneration",
+            "trl-internal-testing/tiny-LlavaNextForConditionalGeneration",
+            "trl-internal-testing/tiny-Qwen2VLForConditionalGeneration",
+            "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+            # "trl-internal-testing/tiny-SmolVLMForConditionalGeneration", seems not to support bf16 properly
+            pytest.param(
+                "trl-internal-testing/tiny-Qwen3VLForConditionalGeneration",
+                marks=[
+                    pytest.mark.skipif(
+                        Version(transformers.__version__) < Version("4.57.0"),
+                        reason="Qwen3-VL series were introduced in transformers-4.57.0",
+                    ),
+                ],
+            ),
+            pytest.param(
+                "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.2.0"),
+                    reason="Qwen3.5 models were introduced in transformers-5.2.0",
+                ),
+            ),
+            pytest.param(
+                "trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.2.0"),
+                    reason="Qwen3.5 models were introduced in transformers-5.2.0",
+                ),
+            ),
+        ],
+    )
+    def test_train_vlm(self, model_id):
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            max_length=None,  # for VLMs, truncating can remove image tokens, leading to errors
+            per_device_train_batch_size=2,  # VLM training is memory intensive, reduce batch size to avoid OOM
+            report_to="none",
+        )
+        trainer = DPOTrainer(model=model_id, args=training_args, train_dataset=dataset)
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            # LLaVA & LLaVA-Next: vision_feature_layer=-2 leaves the last encoder layer (layers.1) and
+            # post_layernorm (pooler-only path) without gradient by design. Assert they stay frozen — if they
+            # ever start training, the feature-selection plumbing has likely regressed.
+            if model_id in (
+                "trl-internal-testing/tiny-LlavaForConditionalGeneration",
+                "trl-internal-testing/tiny-LlavaNextForConditionalGeneration",
+            ) and ("encoder.layers.1" in n or "post_layernorm" in n):
+                assert torch.equal(param, new_param), f"Param {n} expected frozen by LLaVA design, but changed"
+            else:
+                assert not torch.equal(param, new_param), f"Param {n} is not updated"
+
+    @pytest.mark.parametrize(
+        "model_id",
+        [
+            "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+        ],
+    )
+    @pytest.mark.xfail(
+        parse_version(transformers.__version__) < parse_version("4.57.0"),
+        reason="Mixing text-only and image+text examples is only supported in transformers >= 4.57.0",
+        strict=False,
+    )
+    def test_train_vlm_multi_image(self, model_id):
+        dataset = load_dataset("trl-internal-testing/zen-multi-image", "conversational_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            max_length=None,  # for VLMs, truncating can remove image tokens, leading to errors
+            per_device_train_batch_size=1,  # VLM training is memory intensive, reduce batch size to avoid OOM
+            report_to="none",
+        )
+        trainer = DPOTrainer(
+            model=model_id,
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Param {n} is not updated"
+
+    @pytest.mark.parametrize(
+        "model_id",
+        [
+            "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+        ],
+    )
+    @pytest.mark.parametrize(
+        "dataset_config",
+        ["conversational_preference", "standard_preference"],
+    )
+    def test_train_vlm_text_only_data(self, model_id, dataset_config):
+        dataset = load_dataset("trl-internal-testing/zen", dataset_config, split="train")
+
+        training_args = DPOConfig(output_dir=self.tmp_dir, report_to="none")
+        trainer = DPOTrainer(
+            model=model_id,
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n.startswith("model.visual"):
+                torch.testing.assert_close(param, new_param, rtol=1e-12, atol=1e-12, msg=f"Param {n} is updated")
+            else:
+                assert not torch.equal(param, new_param), f"Param {n} is not updated"
+
+    def test_train_vlm_with_max_length(self):
+        # Regression test for #5283: mm_token_type_ids must be truncated alongside input_ids when max_length is set,
+        # otherwise a shape mismatch crashes the model forward pass.
+        # max_length=37 truncates 1 completion token (total_len=38) while keeping all image tokens (prompt_len=34) safe.
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_preference", split="train")
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            max_length=37,  # total_len=38, prompt_len=34 — truncates completion, not image tokens
+            per_device_train_batch_size=2,
+            report_to="none",
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+            args=training_args,
+            train_dataset=dataset,
+        )
+        trainer.train()
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    def test_train_vlm_keep_end_raises(self):
+        # Regression test for #5285: keep_end with a VLM must raise at init time, not silently corrupt training.
+        # Image tokens live at the start of the sequence (in the prompt); keep_end would drop them.
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_preference", split="train")
+        with pytest.warns(FutureWarning, match="keep_end.*deprecated"):
+            training_args = DPOConfig(
+                output_dir=self.tmp_dir,
+                max_length=32,
+                truncation_mode="keep_end",
+                report_to="none",
+            )
+        with pytest.raises(ValueError, match="truncation_mode='keep_end' is not supported for vision-language models"):
+            DPOTrainer(
+                model="trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+                args=training_args,
+                train_dataset=dataset,
+            )
+
+    def test_vision_dataset_with_text_model_raises(self):
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_preference", split="train")
+        training_args = DPOConfig(output_dir=self.tmp_dir, report_to="none")
+        with pytest.raises(ValueError, match="vision-related.*vision-language model"):
+            DPOTrainer(
+                model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+                args=training_args,
+                train_dataset=dataset,
+            )
+
+    def test_precompute_ref_log_probs_raises_for_vision(self):
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_preference", split="train")
+        training_args = DPOConfig(output_dir=self.tmp_dir, report_to="none", precompute_ref_log_probs=True)
+        with pytest.raises(ValueError, match="precompute_ref_log_probs.*not supported for vision datasets"):
+            DPOTrainer(
+                model="trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+                args=training_args,
+                train_dataset=dataset,
+            )
+
+    @require_liger_kernel
+    def test_train_vlm_liger(self):
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_preference", split="train")
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            max_length=None,  # for VLMs, truncating can remove image tokens, leading to errors
+            per_device_train_batch_size=2,  # VLM training is memory intensive, reduce batch size to avoid OOM
+            use_liger_kernel=True,
+            report_to="none",
+        )
+        trainer = DPOTrainer(
+            model="trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Param {n} is not updated"
+
+
+@pytest.mark.slow
+class TestDPOTrainerSlow(TrlTestCase):
+    # Gemma 3n uses a timm encoder, making it difficult to create a smaller variant for testing.
+    # To ensure coverage, we run tests on the full model but mark them as slow to exclude from default runs.
+    @pytest.mark.skip(reason="Model google/gemma-3n-E2B-it is gated and requires HF token")
+    @require_vision
+    def test_train_vlm_gemma_3n(self):
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_preference", split="train")
+
+        training_args = DPOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            max_length=None,  # for VLMs, truncating can remove image tokens, leading to errors
+            per_device_train_batch_size=1,  # VLM training is memory intensive, reduce batch size to avoid OOM
+            model_init_kwargs={"dtype": "bfloat16"},
+            report_to="none",
+        )
+        trainer = DPOTrainer(model="google/gemma-3n-E2B-it", args=training_args, train_dataset=dataset)
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if "model.audio_tower" in n or "model.embed_audio" in n:
+                # The audio embedding parameters are not updated because this dataset contains no audio data
+                continue
+            assert not torch.equal(param, new_param), f"Param {n} is not updated"

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_model_utils.py

@@ -0,0 +1,34 @@
+# 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 transformers import AutoModelForCausalLM
+
+from trl.models.utils import disable_gradient_checkpointing
+
+
+class TestDisableGradientCheckpointing:
+    def test_when_disabled(self):
+        model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5")
+        assert model.is_gradient_checkpointing is False
+        with disable_gradient_checkpointing(model):
+            assert model.is_gradient_checkpointing is False
+        assert model.is_gradient_checkpointing is False
+
+    def test_when_enabled(self):
+        model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5")
+        model.gradient_checkpointing_enable()
+        assert model.is_gradient_checkpointing is True
+        with disable_gradient_checkpointing(model):
+            assert model.is_gradient_checkpointing is False
+        assert model.is_gradient_checkpointing is True

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_reward_trainer.py

@@ -0,0 +1,868 @@
+# 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 pathlib
+
+import pytest
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+from transformers.utils import is_peft_available
+
+from trl import RewardConfig, RewardTrainer
+from trl.trainer.reward_trainer import DataCollatorForPreference
+
+from .testing_utils import TrlTestCase, require_peft
+
+
+if is_peft_available():
+    from peft import LoraConfig, get_peft_model
+
+
+class TestDataCollatorForPreference(TrlTestCase):
+    def test_basic_padding(self):
+        """Test basic padding functionality without completion masks."""
+        collator = DataCollatorForPreference(pad_token_id=0)
+        examples = [
+            {"chosen_ids": [1, 2, 3], "rejected_ids": [4, 5]},
+            {"chosen_ids": [6, 7], "rejected_ids": [8]},
+        ]
+
+        result = collator(examples)
+
+        torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3], [6, 7, 0], [4, 5, 0], [8, 0, 0]]))
+        torch.testing.assert_close(
+            result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 0], [1, 1, 0], [1, 0, 0]])
+        )
+
+    def test_pad_to_multiple_of(self):
+        """Test padding to multiple of specified value."""
+        collator = DataCollatorForPreference(pad_token_id=0, pad_to_multiple_of=4)
+        examples = [
+            {"chosen_ids": [1, 2, 3], "rejected_ids": [4, 5]},
+            {"chosen_ids": [6, 7], "rejected_ids": [8]},
+        ]
+
+        result = collator(examples)
+
+        torch.testing.assert_close(
+            result["input_ids"], torch.tensor([[1, 2, 3, 0], [6, 7, 0, 0], [4, 5, 0, 0], [8, 0, 0, 0]])
+        )
+        torch.testing.assert_close(
+            result["attention_mask"], torch.tensor([[1, 1, 1, 0], [1, 1, 0, 0], [1, 1, 0, 0], [1, 0, 0, 0]])
+        )
+
+    def test_single_example(self):
+        """Test collator with a single example."""
+        collator = DataCollatorForPreference(pad_token_id=0)
+        examples = [{"chosen_ids": [1, 2, 3], "rejected_ids": [4, 5]}]
+
+        result = collator(examples)
+
+        torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3], [4, 5, 0]]))
+        torch.testing.assert_close(result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 0]]))
+
+    def test_different_pad_token_id(self):
+        """Test with different pad token ID."""
+        collator = DataCollatorForPreference(pad_token_id=999)
+        examples = [
+            {"chosen_ids": [1, 2, 3], "rejected_ids": [4, 5]},
+            {"chosen_ids": [6, 7], "rejected_ids": [8]},
+        ]
+
+        result = collator(examples)
+
+        torch.testing.assert_close(
+            result["input_ids"], torch.tensor([[1, 2, 3], [6, 7, 999], [4, 5, 999], [8, 999, 999]])
+        )
+        torch.testing.assert_close(
+            result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 0], [1, 1, 0], [1, 0, 0]])
+        )
+
+    def test_collate_with_margin(self):
+        collator = DataCollatorForPreference(pad_token_id=0)
+        examples = [
+            {"chosen_ids": [1, 2, 3], "rejected_ids": [4, 5], "margin": 0.1},
+            {"chosen_ids": [6, 7], "rejected_ids": [8], "margin": 0.2},
+        ]
+
+        result = collator(examples)
+
+        torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3], [6, 7, 0], [4, 5, 0], [8, 0, 0]]))
+        torch.testing.assert_close(
+            result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 0], [1, 1, 0], [1, 0, 0]])
+        )
+        torch.testing.assert_close(result["margin"], torch.tensor([0.1, 0.2]))
+
+
+class TestRewardTrainer(TrlTestCase):
+    def test_raises_error_when_model_num_labels_not_one(self):
+        """Test that RewardTrainer raises ValueError when model doesn't have num_labels=1."""
+        model = AutoModelForSequenceClassification.from_pretrained(
+            "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            dtype="float32",
+            # num_labels=2,  # Defaults to 2 num_labels for causal models
+        )
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none")
+        with pytest.raises(ValueError, match=r"reward models require `num_labels=1`"):
+            RewardTrainer(model=model, args=training_args, train_dataset=dataset)
+
+    @pytest.mark.parametrize(
+        "model_id",
+        [
+            "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            "trl-internal-testing/tiny-Qwen3MoeForCausalLM",
+            "trl-internal-testing/tiny-LlamaForCausalLM-3.2",
+        ],
+    )
+    def test_train(self, model_id):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none")
+        trainer = RewardTrainer(model=model_id, args=training_args, train_dataset=dataset)
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_evaluate_with_raw_dataset(self):
+        # `evaluate` should accept the same (unprocessed) dataset types as the trainer, e.g. a held-out test set
+        # passed directly to `evaluate`. See https://github.com/huggingface/trl/issues/6115.
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none")
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset
+        )
+
+        metrics = trainer.evaluate(eval_dataset=dataset)
+        assert metrics["eval_loss"] is not None
+
+    def test_trust_remote_code(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+        model_id = "trl-internal-testing/tiny-RemoteForCausalLM"
+
+        with pytest.raises(ValueError, match="custom code"):
+            RewardTrainer(
+                model=model_id,
+                args=RewardConfig(output_dir=self.tmp_dir, report_to="none"),
+                train_dataset=dataset,
+            )
+
+        trainer = RewardTrainer(
+            model=model_id,
+            args=RewardConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True),
+            train_dataset=dataset,
+        )
+        assert type(trainer.model).__name__ == "RemoteForSequenceClassification"
+
+    @pytest.mark.parametrize(
+        "config_name",
+        [
+            "standard_preference",
+            "conversational_preference",
+            "standard_implicit_prompt_preference",
+            "conversational_implicit_prompt_preference",
+        ],
+    )
+    def test_train_dataset_types(self, config_name):
+        dataset = load_dataset("trl-internal-testing/zen", config_name, split="train")
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none")
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_model(self):
+        model = AutoModelForSequenceClassification.from_pretrained(
+            "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            num_labels=1,  # required for reward models
+            dtype="float32",
+        )
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none")
+        trainer = RewardTrainer(model=model, args=training_args, train_dataset=dataset)
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_from_sequence_classification_model(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none")
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_model_dtype(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        training_args = RewardConfig(
+            output_dir=self.tmp_dir,
+            model_init_kwargs={"dtype": torch.float16},
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            report_to="none",
+        )
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            # For some reasonn model.layers.0.input_layernorm.weight doesn't change in GitHub Actions but does
+            # locally. We ignore this parameter for now
+            if "layernorm" in n:
+                continue
+            new_param = trainer.model.get_parameter(n)
+            # Check the torch dtype
+            assert new_param.dtype == torch.float16
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @require_peft
+    def test_train_dense_with_peft_config(self):
+        model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        model = AutoModelForSequenceClassification.from_pretrained(model_id, dtype="float32")
+        base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()]
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none")
+
+        trainer = RewardTrainer(
+            model=model_id,
+            args=training_args,
+            train_dataset=dataset,
+            peft_config=LoraConfig(),
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the peft params have changed and the base model params have not changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n in base_param_names:  # We expect the base model params to be the same
+                torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.")
+            elif "base_layer" not in n:  # We expect the peft params to be different (except for the base layer)
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @require_peft
+    def test_train_moe_with_peft_config(self):
+        model_id = "trl-internal-testing/tiny-Qwen3MoeForCausalLM"
+        model = AutoModelForSequenceClassification.from_pretrained(model_id, dtype="float32")
+        base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()]
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none")
+
+        trainer = RewardTrainer(
+            model=model_id,
+            args=training_args,
+            train_dataset=dataset,
+            peft_config=LoraConfig(target_modules=["gate_proj", "up_proj", "down_proj", "score"]),
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the peft params have changed and the base model params have not changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n in base_param_names:  # We expect the base model params to be the same
+                torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.")
+            elif "base_layer" not in n:  # We expect the peft params to be different (except for the base layer)
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @require_peft
+    def test_train_peft_model(self):
+        model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        model = AutoModelForSequenceClassification.from_pretrained(
+            model_id,
+            num_labels=1,  # required for reward models
+            dtype="float32",
+        )
+
+        base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()]
+
+        lora_config = LoraConfig()
+        model = get_peft_model(model, lora_config)
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none")
+        trainer = RewardTrainer(model=model, args=training_args, train_dataset=dataset)
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the peft params have changed and the base model params have not changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n in base_param_names:  # We expect the base model params to be the same
+                torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.")
+            elif "base_layer" not in n:  # We expect the peft params to be different (except for the base layer)
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    # In practice, this test is the same as `test_train_dense_with_peft_config`, since gradient checkpointing is
+    # enabled by default in `RewardTrainer`. We keep it as a regression guard: if the default ever changes, we still
+    # explicitly test PEFT + gradient checkpointing, which has caused issues in the past.
+    @require_peft
+    def test_train_with_peft_config_and_gradient_checkpointing(self):
+        model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        model = AutoModelForSequenceClassification.from_pretrained(model_id, dtype="float32")
+        base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()]
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, gradient_checkpointing=True, report_to="none")
+
+        trainer = RewardTrainer(
+            model=model_id,
+            args=training_args,
+            train_dataset=dataset,
+            peft_config=LoraConfig(),
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the peft params have changed and the base model params have not changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n in base_param_names:  # We expect the base model params to be the same
+                torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.")
+            elif "base_layer" not in n:  # We expect the peft params to be different (except for the base layer)
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @pytest.mark.parametrize("use_reentrant", [True, False])
+    @require_peft
+    def test_train_with_peft_config_and_gradient_checkpointing_reentrant(self, use_reentrant):
+        model_id = "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5"
+        model = AutoModelForSequenceClassification.from_pretrained(model_id, dtype="float32")
+        base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()]
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        training_args = RewardConfig(
+            output_dir=self.tmp_dir,
+            gradient_checkpointing=True,
+            gradient_checkpointing_kwargs={"use_reentrant": use_reentrant},
+            report_to="none",
+        )
+
+        trainer = RewardTrainer(
+            model=model_id,
+            args=training_args,
+            train_dataset=dataset,
+            peft_config=LoraConfig(),
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the peft params have changed and the base model params have not changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n in base_param_names:  # We expect the base model params to be the same
+                torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.")
+            elif "base_layer" not in n:  # We expect the peft params to be different (except for the base layer)
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @pytest.mark.parametrize(
+        "chosen_column,rejected_column,expect_deprecation_warning",
+        [
+            ("chosen_ids", "rejected_ids", False),
+            ("chosen_input_ids", "rejected_input_ids", True),
+        ],
+    )
+    def test_train_with_pretokenized_data(self, chosen_column, rejected_column, expect_deprecation_warning):
+        model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        def tokenize_example(example):
+            return {
+                chosen_column: tokenizer(example["chosen"]).input_ids,
+                rejected_column: tokenizer(example["rejected"]).input_ids,
+            }
+
+        # Apply tokenization
+        tokenized_dataset = dataset.map(tokenize_example, remove_columns=["chosen", "rejected"])
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none")
+        if expect_deprecation_warning:
+            with pytest.warns(FutureWarning, match=r"will not be supported in v1"):
+                trainer = RewardTrainer(model=model_id, args=training_args, train_dataset=tokenized_dataset)
+        else:
+            trainer = RewardTrainer(model=model_id, args=training_args, train_dataset=tokenized_dataset)
+
+        assert "chosen_ids" in trainer.train_dataset.column_names
+        assert "rejected_ids" in trainer.train_dataset.column_names
+        assert "chosen_input_ids" not in trainer.train_dataset.column_names
+        assert "rejected_input_ids" not in trainer.train_dataset.column_names
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_iterable_dataset(self):
+        dataset = load_dataset(
+            "trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train", streaming=True
+        )
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, max_steps=3, report_to="none")
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_chat_template_kwargs(self):
+        dataset = load_dataset("trl-internal-testing/zen", "conversational_implicit_prompt_preference", split="train")
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none")
+
+        tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5")
+        # The following template is a simplified version of the Qwen chat template, where an additional argument
+        # `role_capital` is used to control the capitalization of roles.
+        tokenizer.chat_template = '{%- if messages[0]["role"] == "system" -%}    {{ "<|im_start|>" + ("SYSTEM" if role_capital else "system") + "\\n" + messages[0]["content"] + "<|im_end|>\\n" }}{%- else -%}    {{ "<|im_start|>" + ("SYSTEM" if role_capital else "system") + "\\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\\n" }}{%- endif -%}{%- for message in messages -%}    {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) -%}        {{ "<|im_start|>" + (message.role.upper() if role_capital else message.role) + "\\n" + message.content + "<|im_end|>\\n" }}    {%- elif message.role == "assistant" -%}        {{ "<|im_start|>" + ("ASSISTANT" if role_capital else "assistant") }}        {%- if message.content -%}            {{ "\\n" + message.content }}        {%- endif -%}        {{ "<|im_end|>\\n" }}    {%- elif message.role == "tool" -%}        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") -%}            {{ "<|im_start|>" + ("USER" if role_capital else "user") }}        {%- endif -%}        {{ "\\n<tool_response>\\n" + message.content + "\\n</tool_response>" }}        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") -%}            {{ "<|im_end|>\\n" }}        {%- endif -%}    {%- endif -%}{%- endfor -%}{%- if add_generation_prompt -%}    {{ "<|im_start|>" + ("ASSISTANT" if role_capital else "assistant") + "\\n" }}{%- endif -%}'
+
+        dataset = dataset.add_column(
+            "chat_template_kwargs", [{"role_capital": bool(i % 2)} for i in range(len(dataset))]
+        )
+        assert "chat_template_kwargs" in dataset.features
+
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+            processing_class=tokenizer,
+        )
+
+        assert trainer.processing_class.chat_template == tokenizer.chat_template
+
+        for i in range(2):
+            role = "SYSTEM" if i else "system"
+            system_prompt = (
+                f"<|im_start|>{role}\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>"
+            )
+            system_prompt_ids = trainer.processing_class(system_prompt)["input_ids"]
+            assert trainer.train_dataset[i]["chosen_ids"][: len(system_prompt_ids)] == system_prompt_ids
+            assert trainer.train_dataset[i]["rejected_ids"][: len(system_prompt_ids)] == system_prompt_ids
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_set_chat_template_from_model(self):
+        dataset = load_dataset("trl-internal-testing/zen", "conversational_preference", split="train")
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, chat_template_path="Qwen/Qwen3-4B", report_to="none")
+        # trl-internal-testing/tiny-GPTNeoXForCausalLM doesn't have a chat template set by default
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-GPTNeoXForCausalLM",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            # RewardTrainer uses a mean-free loss that cancels uniform shifts in output scores. Since GPT-NeoX models
+            # include a final LayerNorm, its bias consistently receives zero gradient and remains unchanged, so we skip
+            # this parameter.
+            if n == "gpt_neox.final_layer_norm.bias":
+                continue
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_set_chat_template_from_path(self, lazy_shared_datadir):
+        dataset = load_dataset("trl-internal-testing/zen", "conversational_preference", split="train")
+
+        training_args = RewardConfig(
+            output_dir=self.tmp_dir,
+            chat_template_path=str(lazy_shared_datadir / "template.jinja"),
+            report_to="none",
+        )
+        # trl-internal-testing/tiny-GPTNeoXForCausalLM doesn't have a chat template set by default
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-GPTNeoXForCausalLM",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            # RewardTrainer uses a mean-free loss that cancels uniform shifts in output scores. Since GPT-NeoX models
+            # include a final LayerNorm, its bias consistently receives zero gradient and remains unchanged, so we skip
+            # this parameter.
+            if n == "gpt_neox.final_layer_norm.bias":
+                continue
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+        # Check that the template saved in the output directory is the same as the one used for training
+        template_path = pathlib.Path(self.tmp_dir) / "checkpoint-9" / "chat_template.jinja"
+        assert template_path.exists(), f"Chat template not found at {template_path}"
+
+        with open(template_path) as f:
+            template_content = f.read()
+        with open(training_args.chat_template_path) as f:
+            original_template_content = f.read()
+        assert template_content == original_template_content, "Chat template content does not match the original"
+
+    def test_train_toolcall_data(self):
+        dataset = load_dataset("trl-internal-testing/toolcall", "preference", split="train")
+
+        training_args = RewardConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,  # toolcall sequences are longer than standard data, reduce batch size to avoid OOM
+            max_length=512,  # toolcall sequences are longer than standard data, limit length to avoid OOM
+            report_to="none",
+        )
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_toolcall_data_as_json(self):
+        # Tabular backends (Arrow/Parquet) can insert `None` for missing keys in nested structures.
+        # If `tools` is stored as a list of dicts and examples use different dict schemas, nulls may
+        # be introduced and break tool processing. This test ensures we also support `tools` provided
+        # as a list of dicts.
+        dataset = load_dataset("trl-internal-testing/toolcall", "preference", split="train")
+
+        def convert_to_json(example):
+            return {"tools": json.loads(example["tools"])}
+
+        dataset = dataset.map(convert_to_json)
+
+        training_args = RewardConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=2,  # toolcall sequences are longer than standard data, reduce batch size to avoid OOM
+            max_length=512,  # toolcall sequences are longer than standard data, limit length to avoid OOM
+            report_to="none",
+        )
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_eval(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference")
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, eval_strategy="steps", eval_steps=3, report_to="none")
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset["train"],
+            eval_dataset=dataset["test"],
+        )
+
+        trainer.train()
+
+        assert trainer.state.log_history[0]["eval_loss"] is not None
+
+    def test_train_with_multiple_eval_dataset(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference")
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, eval_strategy="steps", eval_steps=3, report_to="none")
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset["train"],
+            eval_dataset={"data1": dataset["test"], "data2": dataset["test"]},
+        )
+        trainer.train()
+
+        assert trainer.state.log_history[-3]["eval_data1_loss"] is not None
+        assert trainer.state.log_history[-2]["eval_data2_loss"] is not None
+
+    def test_train_with_compute_metrics(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference")
+
+        def dummy_compute_metrics(eval_pred):
+            return {"my_metric": 0.123}
+
+        training_args = RewardConfig(
+            output_dir=self.tmp_dir,
+            eval_strategy="steps",
+            eval_steps=3,
+            report_to="none",
+        )
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset["train"],
+            eval_dataset=dataset["test"],
+            compute_metrics=dummy_compute_metrics,
+        )
+
+        trainer.train()
+
+        assert trainer.state.log_history[-2]["eval_my_metric"] == 0.123
+
+    # In practice, this test is the same as `test_train`, since gradient checkpointing is enabled by default in
+    # `RewardTrainer`. We keep it as a regression guard: if the default ever changes, we still explicitly test gradient
+    # checkpointing, which has caused issues in the past.
+    def test_train_with_gradient_checkpointing(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, gradient_checkpointing=True, report_to="none")
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @pytest.mark.parametrize("use_reentrant", [True, False])
+    def test_train_with_gradient_checkpointing_reentrant(self, use_reentrant):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        training_args = RewardConfig(
+            output_dir=self.tmp_dir,
+            gradient_checkpointing=True,
+            gradient_checkpointing_kwargs={"use_reentrant": use_reentrant},
+            report_to="none",
+        )
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_tag_added(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            train_dataset=dataset,
+        )
+
+        for tag in ["reward-trainer", "trl"]:
+            assert tag in trainer.model.model_tags
+
+    @require_peft
+    def test_tag_added_peft(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            train_dataset=dataset,
+            peft_config=LoraConfig(),
+        )
+
+        for tag in ["reward-trainer", "trl"]:
+            assert tag in trainer.model.model_tags
+
+    def test_train_with_margin(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        def add_margin(example):
+            # dummy margin based on the length of the chosen summary
+            return {"margin": len(example["chosen"])}
+
+        dataset = dataset.map(add_margin)
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none")
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_center_rewards_coefficient(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train")
+
+        training_args = RewardConfig(output_dir=self.tmp_dir, center_rewards_coefficient=0.01, report_to="none")
+        trainer = RewardTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_rewards.py

@@ -0,0 +1,399 @@
+# 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 pickle
+import threading
+
+import pytest
+
+from trl.rewards import (
+    accuracy_reward,
+    get_cosine_scaled_reward,
+    get_repetition_penalty_reward,
+    get_soft_overlong_punishment,
+    reasoning_accuracy_reward,
+    think_format_reward,
+)
+
+from .testing_utils import TrlTestCase, require_math_latex
+
+
+class TestThinkFormatReward(TrlTestCase):
+    def test_valid_format(self):
+        completions = [
+            "<think>This is my reasoning.</think>This is my answer.",  # Simple, one-line reasoning
+            "<think>\nThis is my reasoning.\n</think>\nThis is my answer.",  # Multiline reasoning
+            "<think>\nThis is\nmy reasoning.\n</think>\nThis is my answer.",  # Multiline reasoning
+            "<think>\nThis is <some tag> my reasoning.</think>\nThis is my answer.",  # Reasoning including other tags
+            "<think></think>\nThis is my answer.",  # Empty reasoning
+        ]
+        completions = [[{"content": completion}] for completion in completions]
+        expected_rewards = [1.0, 1.0, 1.0, 1.0, 1.0]  # All should be valid
+        rewards = think_format_reward(completions)
+        assert rewards == expected_rewards
+
+    def test_invalid_format(self):
+        completions = [
+            "<think>\nThis is my reasoning.\nThis is my answer.",  # No closing </think>
+            "<think>This is my reasoning.\nThis is my answer.",  # No closing </think>
+            "This is my reasoning. This is my answer.",  # No <think> tags
+            "This is my reasoning.\nThis is my answer.",  # No <think> tags
+            "This is my reasoning.</think>\nThis is my answer.",  # No opening <think>
+            "This is my reasoning.</think>This is my answer.",  # No opening <think>
+            "This<think>is my reasoning.</think>\nThis is my answer.",  # <think> tag in the middle
+            "<think>This is<think>my reasoning.</think></think>This is my answer.",  # Nested <think> tags
+            "<think>This is</think>\nmy\n<think>reasoning.</think>\nThis is my answer.",  # Multiline <think>
+        ]
+        completions = [[{"content": completion}] for completion in completions]
+        expected_rewards = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]  # All should be invalid
+        rewards = think_format_reward(completions)
+        assert rewards == expected_rewards
+
+    def test_mixed_format(self):
+        completions = [
+            "<think>This is my reasoning.</think>This is my answer.",  # Valid
+            "<think>\nThis is my reasoning.\n</think>\nThis is my answer.",  # Valid
+            "<think>This is my reasoning.\nThis is my answer.",  # Invalid
+            "This is my reasoning. This is my answer.",  # Invalid
+        ]
+        completions = [[{"content": completion}] for completion in completions]
+        expected_rewards = [1.0, 1.0, 0.0, 0.0]
+        rewards = think_format_reward(completions)
+        assert rewards == expected_rewards
+
+
+class TestSoftOverlongPunishmentReward:
+    def test_soft_overlong_punishment_short_completion(self):
+        """Test soft overlong punishment reward function with a short completion."""
+        # length 50, with max=100 and soft cache=20, reward should be 0.
+        reward_fn = get_soft_overlong_punishment(max_completion_len=100, soft_punish_cache=20)
+        completion_ids = [[1] * 50]  # 50 <= 80
+        rewards = reward_fn(completion_ids=completion_ids)
+        assert rewards == [0]
+
+    def test_soft_overlong_punishment_long_completion(self):
+        """Test soft overlong punishment reward function with a longer than max completion."""
+        # 110 > 100, reward should be -1.
+        reward_fn = get_soft_overlong_punishment(max_completion_len=100, soft_punish_cache=20)
+        completion_ids = [[1] * 110]
+        rewards = reward_fn(completion_ids)
+        assert rewards == [-1]
+
+    def test_soft_overlong_punishment_intermediate_completion(self):
+        """Test soft overlong punishment reward function for intermediate length completion."""
+        reward_fn = get_soft_overlong_punishment(max_completion_len=100, soft_punish_cache=20)
+        completion_ids = [[1] * 90]  # 90 is between 80 and 100
+        rewards = reward_fn(completion_ids)
+        assert round(abs(rewards[0] - -0.5), 4) == 0
+
+
+class TestRepetitionPenaltyReward:
+    def test_no_repetition_yields_zero(self):
+        """A completion with only unique n-grams gets no penalty."""
+        reward_fn = get_repetition_penalty_reward(ngram_size=2, max_penalty=-1.0)
+        completion_ids = [[1, 2, 3, 4]]
+        assert reward_fn(completion_ids) == [0.0]
+
+    def test_full_repetition_approaches_max_penalty(self):
+        """A fully repetitive completion approaches max_penalty."""
+        reward_fn = get_repetition_penalty_reward(ngram_size=2, max_penalty=-1.0)
+        # [5, 5, 5, 5, 5] -> 4 bigrams, 1 unique -> scaling = 1 - 1/4 = 0.75
+        completion_ids = [[5, 5, 5, 5, 5]]
+        assert reward_fn(completion_ids) == [pytest.approx(-0.75)]
+
+    def test_partial_repetition(self):
+        reward_fn = get_repetition_penalty_reward(ngram_size=2, max_penalty=-1.0)
+        # [1, 2, 1, 2, 1, 2] -> 5 bigrams, 2 unique -> scaling = 1 - 2/5 = 0.6
+        completion_ids = [[1, 2, 1, 2, 1, 2]]
+        assert reward_fn(completion_ids) == [pytest.approx(-0.6)]
+
+    def test_completion_shorter_than_ngram_size_yields_zero(self):
+        reward_fn = get_repetition_penalty_reward(ngram_size=3, max_penalty=-1.0)
+        completion_ids = [[1, 2]]  # 2 tokens < ngram_size
+        assert reward_fn(completion_ids) == [0.0]
+
+    def test_completion_exactly_ngram_size_yields_zero(self):
+        reward_fn = get_repetition_penalty_reward(ngram_size=3, max_penalty=-1.0)
+        completion_ids = [[1, 2, 3]]  # a single, unique n-gram
+        assert reward_fn(completion_ids) == [0.0]
+
+    def test_empty_completion_yields_zero(self):
+        reward_fn = get_repetition_penalty_reward(ngram_size=3, max_penalty=-1.0)
+        completion_ids = [[]]
+        assert reward_fn(completion_ids) == [0.0]
+
+    def test_max_penalty_scales_reward(self):
+        reward_fn = get_repetition_penalty_reward(ngram_size=2, max_penalty=-0.5)
+        # scaling 0.75 * max_penalty -0.5 = -0.375
+        completion_ids = [[5, 5, 5, 5, 5]]
+        assert reward_fn(completion_ids) == [pytest.approx(-0.375)]
+
+    def test_ngram_size_changes_reward(self):
+        completion_ids = [[1, 2, 3, 1, 2, 3]]
+        # bigrams: 5 total, 3 unique -> 1 - 3/5 = 0.4
+        reward_bigram = get_repetition_penalty_reward(ngram_size=2, max_penalty=-1.0)
+        assert reward_bigram(completion_ids) == [pytest.approx(-0.4)]
+        # trigrams: 4 total, 3 unique -> 1 - 3/4 = 0.25
+        reward_trigram = get_repetition_penalty_reward(ngram_size=3, max_penalty=-1.0)
+        assert reward_trigram(completion_ids) == [pytest.approx(-0.25)]
+
+    def test_batch_of_completions(self):
+        reward_fn = get_repetition_penalty_reward(ngram_size=2, max_penalty=-1.0)
+        completion_ids = [
+            [1, 2, 3, 4],  # no repetition
+            [5, 5, 5, 5, 5],  # full repetition
+            [9],  # shorter than ngram_size
+        ]
+        assert reward_fn(completion_ids) == [pytest.approx(0.0), pytest.approx(-0.75), pytest.approx(0.0)]
+
+    def test_positive_max_penalty_raises(self):
+        with pytest.raises(ValueError):
+            get_repetition_penalty_reward(ngram_size=2, max_penalty=0.5)
+
+    def test_extra_kwargs_are_ignored(self):
+        """Trainers pass prompts/completions/etc. as kwargs; the reward must accept and ignore them."""
+        reward_fn = get_repetition_penalty_reward(ngram_size=2, max_penalty=-1.0)
+        completion_ids = [[5, 5, 5, 5, 5]]
+        rewards = reward_fn(completion_ids, prompts=["x"], completions=[[{"content": "5 5 5 5 5"}]])
+        assert rewards == [pytest.approx(-0.75)]
+
+    def test_reward_is_picklable(self):
+        """The reward must survive pickling for the async GRPO rollout worker."""
+        reward_fn = get_repetition_penalty_reward(ngram_size=2, max_penalty=-1.0)
+        unpickled = pickle.loads(pickle.dumps(reward_fn))
+        completion_ids = [[5, 5, 5, 5, 5]]
+        assert unpickled(completion_ids) == [pytest.approx(-0.75)]
+        assert unpickled.__name__ == "repetition_penalty_reward"
+
+
+class TestAccuracyReward:
+    @require_math_latex
+    def test_accuracy_reward_correct_answer(self):
+        """Test accuracy_reward with a correct answer."""
+        completion = [[{"content": r"\boxed{\frac{63}{400}}"}], [{"content": r"\boxed{\frac{63}{400}}"}]]
+        solution = [r"\frac{63}{400}", "63/400"]
+        rewards = accuracy_reward(completion, solution)
+        assert rewards[0] == 1.0
+        assert rewards[1] == 1.0
+
+    @require_math_latex
+    def test_accuracy_reward_wrong_answer(self):
+        """Test accuracy_reward with an incorrect answer."""
+        completion = [[{"content": r"\boxed{\frac{64}{400}}"}]]
+        solution = [r"\frac{63}{400}"]
+        rewards = accuracy_reward(completion, solution)
+        assert rewards[0] == 0.0
+
+    @require_math_latex
+    def test_accuracy_reward_wrong_answer_no_latex(self):
+        """Test accuracy_reward with an incorrect answer and gold solution with no latex."""
+        completion = [[{"content": r"\boxed{3}"}]]
+        solution = ["6"]
+        rewards = accuracy_reward(completion, solution)
+        assert rewards[0] == 0.0
+
+    @require_math_latex
+    def test_accuracy_reward_unparsable_gold(self):
+        """Test accuracy_reward with an unparsable gold solution."""
+        completion = [
+            [{"content": "Answer is forty two."}],
+            [{"content": r"Some other content. \boxed{43}."}],
+        ]
+        solution = [
+            "Answer is forty two.",
+            "Answer is forty three.",
+        ]
+        rewards = accuracy_reward(completion, solution)
+        assert rewards[0] is None
+        assert rewards[1] is None
+
+    @require_math_latex
+    def test_accuracy_reward_in_worker_thread(self):
+        """Test that accuracy_reward works when called from a non-main thread."""
+        completions = [[{"content": r"\boxed{\frac{1}{3}}"}]]
+        solutions = [r"\frac{1}{3}"]
+        results = []
+        exceptions = []
+
+        def target():
+            try:
+                results.extend(accuracy_reward(completions, solutions))
+            except Exception as e:
+                exceptions.append(e)
+
+        t = threading.Thread(target=target)
+        t.start()
+        t.join()
+
+        assert not exceptions, f"accuracy_reward raised in worker thread: {exceptions[0]}"
+        assert results == [1.0]
+
+
+class TestReasoningAccuracyReward:
+    @require_math_latex
+    def test_correct_answer_yields_unit_reward(self):
+        completions = [
+            [{"content": r"<think> Reasoning content </think> \boxed{\frac{63}{400}}"}],
+            [{"content": r"Reasoning content </think> \boxed{\frac{63}{400}}"}],
+        ]
+        solutions = [r"\frac{63}{400}", r"\frac{63}{400}"]
+        rewards = reasoning_accuracy_reward(completions, solutions)
+        assert rewards[0] == 1.0
+        assert rewards[1] == 1.0
+
+    @require_math_latex
+    def test_correct_answer_with_custom_tags_yields_unit_reward(self):
+        completions = [
+            [{"content": r"<REASONING_START> Reasoning content </REASONING_END> \boxed{\frac{63}{400}}"}],
+        ]
+        solutions = [
+            r"\frac{63}{400}",
+        ]
+        rewards = reasoning_accuracy_reward(completions, solutions, reasoning_delimiters=["</REASONING_END>"])
+        assert rewards[0] == 1.0
+
+    @require_math_latex
+    def test_incorrect_answer_yields_zero_reward(self):
+        completion = [[{"content": r"<think> Reasoning content </think> \boxed{\frac{64}{400}}"}]]
+        solution = [r"\frac{63}{400}"]
+        rewards = reasoning_accuracy_reward(completion, solution)
+        assert rewards[0] == 0.0
+
+    @require_math_latex
+    def test_correct_answer_in_reasoning_yields_zero_reward(self):
+        completions = [
+            [{"content": r"<think> My answer is \boxed{42} </think> Some other text."}],
+            [{"content": r"<think> The answer is \boxed{42} </think> Here's a wrong answer: \boxed{43}."}],
+        ]
+        solutions = [r"\boxed{42}", r"\boxed{42}"]
+        rewards = reasoning_accuracy_reward(completions, solutions)
+        assert rewards[0] == 0.0
+        assert rewards[1] == 0.0
+
+    @require_math_latex
+    def test_incomplete_reasoning_yields_zero_reward(self):
+        completions = [
+            [{"content": r"<think> Incomplete reasoning without closing tag"}],
+            [{"content": r"Correct answer \frac{63}{400} but completely missing reasoning content"}],
+        ]
+        solutions = [r"\frac{63}{400}", r"\frac{63}{400}"]
+        rewards = reasoning_accuracy_reward(completions, solutions)
+        assert rewards[0] == 0.0
+        assert rewards[1] == 0.0
+
+    @require_math_latex
+    def test_unparsable_gold_solution_yields_none_reward(self):
+        completions = [
+            [{"content": r"<think> Reasoning content </think> \boxed{42}"}],
+        ]
+        solutions = [
+            "forty two",
+        ]
+        rewards = reasoning_accuracy_reward(completions, solutions)
+        assert rewards[0] is None
+
+
+class TestCosineScaledReward:
+    @require_math_latex
+    def test_correct_shorter_rewarded_more(self):
+        """For correct completions, a shorter one gets a higher reward."""
+        reward_fn = get_cosine_scaled_reward(max_len=100)
+        completions = [[{"content": r"\boxed{\frac{1}{3}}"}], [{"content": r"\boxed{\frac{1}{3}}"}]]
+        solution = [r"\frac{1}{3}", r"\frac{1}{3}"]
+        completion_ids = [[1] * 25, [1] * 75]
+        rewards = reward_fn(completions, solution, completion_ids)
+        assert rewards[0] > rewards[1]
+        assert rewards == [pytest.approx(0.92678, abs=1e-4), pytest.approx(0.57322, abs=1e-4)]
+
+    @require_math_latex
+    def test_wrong_longer_penalized_less(self):
+        """For wrong completions, a longer one is penalized less (closer to zero)."""
+        reward_fn = get_cosine_scaled_reward(max_len=100)
+        completions = [[{"content": r"\boxed{\frac{1}{2}}"}], [{"content": r"\boxed{\frac{1}{2}}"}]]
+        solution = [r"\frac{1}{3}", r"\frac{1}{3}"]
+        completion_ids = [[1] * 25, [1] * 75]
+        rewards = reward_fn(completions, solution, completion_ids)
+        assert rewards[1] > rewards[0]
+        assert rewards == [pytest.approx(-0.92678, abs=1e-4), pytest.approx(-0.57322, abs=1e-4)]
+
+    @require_math_latex
+    def test_midpoint_values(self):
+        """At half of max_len (cosine = 0), correct -> 0.75 and wrong -> -0.75 with default bounds."""
+        reward_fn = 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]
+        rewards = reward_fn(completions, solution, completion_ids)
+        assert rewards == [pytest.approx(0.75), pytest.approx(-0.75)]
+
+    @require_math_latex
+    def test_correct_boundary_values(self):
+        """Correct: shortest -> max_value_correct (1.0), longest -> min_value_correct (0.5)."""
+        reward_fn = get_cosine_scaled_reward(max_len=100)
+        completions = [[{"content": r"\boxed{\frac{1}{3}}"}], [{"content": r"\boxed{\frac{1}{3}}"}]]
+        solution = [r"\frac{1}{3}", r"\frac{1}{3}"]
+        completion_ids = [[], [1] * 100]
+        rewards = reward_fn(completions, solution, completion_ids)
+        assert rewards == [pytest.approx(1.0), pytest.approx(0.5)]
+
+    @require_math_latex
+    def test_wrong_boundary_values(self):
+        """Wrong: shortest -> min_value_wrong (-1.0), longest -> max_value_wrong (-0.5)."""
+        reward_fn = get_cosine_scaled_reward(max_len=100)
+        completions = [[{"content": r"\boxed{\frac{1}{2}}"}], [{"content": r"\boxed{\frac{1}{2}}"}]]
+        solution = [r"\frac{1}{3}", r"\frac{1}{3}"]
+        completion_ids = [[], [1] * 100]
+        rewards = reward_fn(completions, solution, completion_ids)
+        assert rewards == [pytest.approx(-1.0), pytest.approx(-0.5)]
+
+    @require_math_latex
+    def test_length_exceeding_max_len_is_clamped(self):
+        """Completions longer than max_len stay at the long-length bound (no climb back up past max_len)."""
+        reward_fn = 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] * 200, [1] * 200]  # both 2x max_len
+        rewards = reward_fn(completions, solution, completion_ids)
+        # correct -> min_value_correct (0.5), wrong -> max_value_wrong (-0.5); same as at exactly max_len
+        assert rewards == [pytest.approx(0.5), pytest.approx(-0.5)]
+
+    @require_math_latex
+    def test_unparsable_gold_yields_none(self):
+        """An unparseable gold solution is skipped, as in accuracy_reward."""
+        reward_fn = get_cosine_scaled_reward(max_len=100)
+        completions = [[{"content": r"\boxed{42}"}]]
+        solution = ["forty two"]
+        completion_ids = [[1] * 50]
+        rewards = reward_fn(completions, solution, completion_ids)
+        assert rewards == [None]
+
+    @require_math_latex
+    def test_custom_value_bounds(self):
+        reward_fn = get_cosine_scaled_reward(max_len=100, min_value_correct=0.0, max_value_correct=2.0)
+        completions = [[{"content": r"\boxed{\frac{1}{3}}"}]]
+        solution = [r"\frac{1}{3}"]
+        completion_ids = [[1] * 50]  # progress 0.5, cosine 0 -> 0.0 + 0.5 * (2.0 - 0.0) * 1 = 1.0
+        rewards = reward_fn(completions, solution, completion_ids)
+        assert rewards == [pytest.approx(1.0)]
+
+    @require_math_latex
+    def test_reward_is_picklable(self):
+        """The reward must survive pickling for the async GRPO rollout worker."""
+        reward_fn = get_cosine_scaled_reward(max_len=100)
+        unpickled = pickle.loads(pickle.dumps(reward_fn))
+        completions = [[{"content": r"\boxed{\frac{1}{3}}"}]]
+        solution = [r"\frac{1}{3}"]
+        completion_ids = [[1] * 50]
+        assert unpickled(completions, solution, completion_ids) == [pytest.approx(0.75)]
+        assert unpickled.__name__ == "cosine_scaled_reward"

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_rich_progress_callback.py

@@ -0,0 +1,64 @@
+# 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 torch
+import torch.nn as nn
+from datasets import Dataset
+from transformers import Trainer, TrainingArguments
+
+from trl.trainer.callbacks import RichProgressCallback
+
+from .testing_utils import TrlTestCase, require_rich
+
+
+class DummyModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.a = nn.Parameter(torch.tensor(1.0))
+
+    def forward(self, x):
+        return self.a * x
+
+
+@require_rich
+class TestRichProgressCallback(TrlTestCase):
+    def setup_method(self):
+        self.dummy_model = DummyModel()
+        self.dummy_train_dataset = Dataset.from_list([{"x": 1.0, "y": 2.0}] * 5)
+        self.dummy_val_dataset = Dataset.from_list([{"x": 1.0, "y": 2.0}] * 101)
+
+    def test_rich_progress_callback_logging(self):
+        training_args = TrainingArguments(
+            output_dir=self.tmp_dir,
+            per_device_eval_batch_size=2,
+            per_device_train_batch_size=2,
+            num_train_epochs=4,
+            eval_strategy="steps",
+            eval_steps=1,
+            logging_strategy="steps",
+            logging_steps=1,
+            save_strategy="no",
+            report_to="none",
+            disable_tqdm=True,
+        )
+        callbacks = [RichProgressCallback()]
+        trainer = Trainer(
+            model=self.dummy_model,
+            train_dataset=self.dummy_train_dataset,
+            eval_dataset=self.dummy_val_dataset,
+            args=training_args,
+            callbacks=callbacks,
+        )
+
+        trainer.train()

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_rloo_trainer.py

@@ -0,0 +1,1836 @@
+# 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 unittest.mock import patch
+
+import pytest
+import torch
+import transformers
+from datasets import load_dataset
+from packaging.version import Version
+from transformers import (
+    AutoModelForCausalLM,
+    AutoModelForImageTextToText,
+    AutoModelForSequenceClassification,
+    AutoTokenizer,
+)
+from transformers.utils import is_peft_available
+
+from trl import RLOOConfig, RLOOTrainer
+
+from .testing_utils import TrlTestCase, require_peft, require_vision, require_vllm
+
+
+if is_peft_available():
+    from peft import LoraConfig, get_peft_model
+
+
+class TestRLOOTrainer(TrlTestCase):
+    def test_init_minimal(self):
+        # Test that RLOOTrainer can be instantiated with only model, reward_model and train_dataset
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+        RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            train_dataset=dataset,
+        )
+
+    @pytest.mark.parametrize(
+        "model_id",
+        [
+            "trl-internal-testing/tiny-Cohere2ForCausalLM",
+            pytest.param(
+                "trl-internal-testing/tiny-Glm4MoeForCausalLM",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.0.0"),
+                    reason="GLM4 tokenizer requires transformers>=5.0.0",
+                ),
+            ),
+            "trl-internal-testing/tiny-GptOssForCausalLM",
+            "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            "trl-internal-testing/tiny-Qwen3MoeForCausalLM",
+            pytest.param(
+                "trl-internal-testing/tiny-NemotronHForCausalLM-nano",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.7.0"),
+                    reason="Nemotron 3 gradient checkpointing requires transformers>=5.7.0 (see transformers#45625)",
+                ),
+            ),
+        ],
+    )
+    def test_train(self, model_id):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model=model_id,
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # MoE models log the load-balancing auxiliary loss (on by default)
+        if trainer.aux_loss_enabled:
+            assert trainer.state.log_history[-1]["aux_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @pytest.mark.parametrize("config_name", ["standard_prompt_only", "conversational_prompt_only"])
+    def test_train_dataset_format(self, config_name):
+        dataset = load_dataset("trl-internal-testing/zen", config_name, split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_trust_remote_code(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+        model_id = "trl-internal-testing/tiny-RemoteForCausalLM"
+
+        def reward_func(completions, **kwargs):
+            return [0.0] * len(completions)
+
+        with pytest.raises(ValueError, match="custom code"):
+            RLOOTrainer(
+                model=model_id,
+                args=RLOOConfig(output_dir=self.tmp_dir, report_to="none"),
+                reward_funcs=reward_func,
+                train_dataset=dataset,
+            )
+
+        trainer = RLOOTrainer(
+            model=model_id,
+            args=RLOOConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True),
+            reward_funcs=reward_func,
+            train_dataset=dataset,
+        )
+        assert type(trainer.model).__name__ == "RemoteForCausalLM"
+
+    def test_train_with_eval(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            per_device_eval_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            eval_strategy="steps",
+            eval_steps=2,
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset["train"],
+            eval_dataset=dataset["test"],
+        )
+
+        trainer.train()
+
+    def test_train_with_num_generations_eval(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            per_device_eval_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            num_generations_eval=1,
+            eval_strategy="steps",
+            eval_steps=2,
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset["train"],
+            eval_dataset=dataset["test"],
+        )
+
+        trainer.train()
+
+    def test_train_multiple_iterations(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            num_iterations=2,
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @require_peft
+    def test_train_peft_config(self):
+        model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32")
+        base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()]
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model=model,
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+            peft_config=LoraConfig(),
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the peft params have changed and the base model params have not changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n in base_param_names:  # We expect the base model params to be the same
+                torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.")
+            elif "base_layer" not in n:  # We expect the peft params to be different (except for the base layer)
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @require_peft
+    def test_train_peft_model(self):
+        model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32")
+        base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()]
+        lora_config = LoraConfig()
+        model = get_peft_model(model, lora_config)
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model=model,
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the peft params have changed and the base model params have not changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n in base_param_names:  # We expect the base model params to be the same
+                torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.")
+            elif "base_layer" not in n and "ref" not in n:  # and the peft params to be different (except base and ref)
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @require_peft
+    def test_train_moe_peft_model(self):
+        # Regression test for https://github.com/huggingface/trl/issues/5222. PEFT only supports one adapter per model
+        # when the LoRA config uses `target_parameters` (see peft#3340), so no "ref" adapter can be created and the
+        # reference log probs are computed with adapters disabled instead.
+        model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-GptOssForCausalLM", dtype="float32")
+        base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()]
+        lora_config = LoraConfig(target_parameters=["mlp.experts.down_proj", "mlp.experts.gate_up_proj"])
+        model = get_peft_model(model, lora_config)
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model=model,
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        assert "ref" not in trainer.model.peft_config
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the peft params have changed and the base model params have not changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n in base_param_names:  # We expect the base model params to be the same
+                torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.")
+            elif "base_layer" not in n:  # We expect the peft params to be different (except for the base layer)
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    # In practice, this test is the same as `test_train_peft_config`, since gradient checkpointing is enabled by
+    # default in `RLOOTrainer`. We keep it as a regression guard: if the default ever changes, we still explicitly test
+    # PEFT + gradient checkpointing, which has caused issues in the past.
+    @require_peft
+    def test_train_peft_with_gradient_checkpointing(self):
+        model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32")
+        base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()]
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            gradient_checkpointing=True,  # enable gradient checkpointing
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model=model,
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+            peft_config=LoraConfig(),
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the peft params have changed and the base model params have not changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n in base_param_names:  # We expect the base model params to be the same
+                torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.")
+            elif "base_layer" not in n:  # We expect the peft params to be different (except for the base layer)
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_different_reward_model(self):
+        # Use a reward model different from the model: different chat template, tokenization, etc.
+        dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_only", split="train")
+        reward_model_id = "trl-internal-testing/tiny-LlamaForSequenceClassification-3.2"
+        reward_model = AutoModelForSequenceClassification.from_pretrained(reward_model_id)
+        reward_tokenizer = AutoTokenizer.from_pretrained(reward_model_id)
+        # By default, the trainer uses the eos token as the padding token. However, for Llama models, the eos token
+        # appears in the chat template. Using it as a pad token disrupts the reward calculation, as the calculation
+        # considers the score of the last token before the first pad token. To ensure correct reward calculations,
+        # we use a separate pad token instead.
+        reward_tokenizer.pad_token = "<|finetune_right_pad_id|>"
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=reward_model,
+            args=training_args,
+            train_dataset=dataset,
+            reward_processing_classes=reward_tokenizer,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_reward_func_standard(self):
+        # Test if trainer can handle reward function with standard format
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        def reward_func(completions, **kwargs):
+            """Reward function that rewards longer completions."""
+            return [float(len(completion)) for completion in completions]
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=reward_func,
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_reward_func_conversational(self):
+        # Test if trainer can handle reward function with conversational format
+        dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_only", split="train")
+
+        def reward_func(completions, **kwargs):
+            """Reward function that gives higher scores to longer completion content."""
+            completion_contents = [completion[0]["content"] for completion in completions]
+            return [float(len(content)) for content in completion_contents]
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=reward_func,
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_multiple_reward_funcs(self):
+        # Test that RLOOTrainer can be instantiated with multiple reward functions
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        def reward_func1(completions, **kwargs):
+            """Reward function that rewards longer completions."""
+            return [float(len(completion)) for completion in completions]
+
+        def reward_func2(completions, **kwargs):
+            """Reward function that rewards completions with more unique letters."""
+            return [float(len(set(completion))) for completion in completions]
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=[reward_func1, reward_func2],
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_sync_and_async_reward_funcs(self):
+        # Test that RLOOTrainer can be instantiated with multiple reward functions one of which is async
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        def sync_reward_func1(completions, **kwargs):
+            """Reward function that rewards longer completions."""
+            return [float(len(completion)) for completion in completions]
+
+        def sync_reward_func2(completions, **kwargs):
+            return [1 for _ in completions]
+
+        async def async_reward_func(completions, **kwargs):
+            """Async Reward function that rewards completions with more unique letters."""
+            return [float(len(set(completion))) for completion in completions]
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=[sync_reward_func1, sync_reward_func2, async_reward_func],
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_multiple_reward_funcs_with_None_output(self):
+        """Test that a valid math reward function is processed correctly while the code reward function returns None."""
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        def applicable_reward_func(completions, **kwargs):
+            """A reward function that rewards longer completions."""
+            return [float(len(completion)) for completion in completions]
+
+        def non_applicable_reward_func(completions, **kwargs):
+            """A reward function that returns None for all inputs, as it is not applicable to this sample."""
+            return [None] * len(completions)
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=[
+                applicable_reward_func,
+                non_applicable_reward_func,
+            ],  # One applicable, one non applicable
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {
+            n: param.clone() for n, param in trainer.model.named_parameters() if param.requires_grad
+        }
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_multiple_reward_funcs_with_weights(self):
+        """Test that RLOOTrainer can handle multiple reward functions with weights."""
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        def reward_func1(completions, **kwargs):
+            """Reward function that rewards longer completions."""
+            return [float(len(completion)) for completion in completions]
+
+        def reward_func2(completions, **kwargs):
+            """Reward function that rewards completions with more unique letters."""
+            return [float(len(set(completion))) for completion in completions]
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+            reward_weights=[0.7, 0.3],  # weight of reward_func1 and reward_func2 respectively
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=[reward_func1, reward_func2],
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        # Check that training logs contain both reward metrics
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+        assert "rewards/reward_func1/mean" in trainer.state.log_history[-1]
+        assert "rewards/reward_func1/std" in trainer.state.log_history[-1]
+        assert "rewards/reward_func2/mean" in trainer.state.log_history[-1]
+        assert "rewards/reward_func2/std" in trainer.state.log_history[-1]
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_reward_metric_reflects_reward_weights(self):
+        """Test that the logged 'reward' metric uses reward_weights, not an unweighted sum."""
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        def constant_reward_1(completions, **kwargs):
+            return [1.0] * len(completions)
+
+        def constant_reward_0(completions, **kwargs):
+            return [0.0] * len(completions)
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+            reward_weights=[0.7, 0.3],
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=[constant_reward_1, constant_reward_0],
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        trainer.train()
+
+        log = trainer.state.log_history[-1]
+        # With reward_weights=[0.7, 0.3] and rewards [1.0, 0.0]:
+        # weighted reward = 0.7*1.0 + 0.3*0.0 = 0.7
+        # unweighted reward = 1.0 + 0.0 = 1.0
+        assert abs(log["reward"] - 0.7) < 1e-5, (
+            f"Expected logged reward to be ~0.7 (weighted), got {log['reward']}. "
+            "The reward metric should reflect reward_weights."
+        )
+
+    def test_train_multiple_mixed_reward_funcs(self):
+        # Test if the trainer can handle a mix of reward functions and reward models
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        def reward_func(completions, **kwargs):
+            """Reward function that rewards longer completions."""
+            return [float(len(completion)) for completion in completions]
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=[reward_func, "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5"],
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_reward_func_additional_column(self):
+        # Test if trainer can handle reward function that rely on additional columns in the dataset
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        # Add a column to the dataset (dummy example, the column could be anything)
+        some_values = list(range(len(dataset)))
+        dataset = dataset.add_column("some_values", some_values)
+
+        def reward_func(completions, some_values, **kwargs):
+            """Reward function that rewards completions with lengths closer to the values in some_values."""
+            return [
+                float(abs(len(completion) - value)) for completion, value in zip(completions, some_values, strict=True)
+            ]
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=reward_func,
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_sync_ref_model(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            beta=0.1,  # ensure ref model is created so sync can update it
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            sync_ref_model=True,
+            ref_model_sync_steps=2,  # reduce sync steps to ensure a sync happens
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+        assert trainer.ref_model is not None
+        previous_ref_params = {n: param.clone() for n, param in trainer.ref_model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+            new_ref_param = trainer.ref_model.get_parameter(n)
+            assert not torch.equal(previous_ref_params[n], new_ref_param), f"Ref Parameter {n} has not changed."
+
+    def test_train_beta_zero(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            beta=0.0,  # set beta to zero value to test the case where the reference model is not used
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_pad_to_multiple_of(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            pad_to_multiple_of=8,
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @require_peft
+    @require_vllm
+    @pytest.mark.skip(reason="We should add a mock for the vLLM server.")
+    def test_train_vllm_and_peft(self):
+        """Test that training works with vLLM for generation."""
+        model = AutoModelForCausalLM.from_pretrained(
+            "Qwen/Qwen2.5-0.5B-Instruct", dtype="float32"
+        )  # tiny model is too small for vLLM
+        base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()]
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+            use_vllm=True,
+        )
+        lora_config = LoraConfig(
+            target_modules="all-linear",
+            # test with non-default modules as it adds extra keys in state_dict that we need to handle
+            modules_to_save=["embed_tokens", "lm_head"],
+        )
+        trainer = RLOOTrainer(
+            model=model,
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+            peft_config=lora_config,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the peft params have changed and the base model params have not changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n in base_param_names:  # We expect the base model params to be the same
+                torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.")
+            elif "base_layer" not in n and "original_module" not in n:
+                # We expect the peft params to be different (except for the base layer)
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @require_vllm
+    @pytest.mark.skip(reason="We should add a mock for the vLLM server.")
+    def test_train_vllm_structured_outputs(self):
+        """Test that training works with vLLM for generation with structured outputs."""
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+            use_vllm=True,
+            vllm_structured_outputs_regex=r"<reasoning>\n.*\n</reasoning>\n<answer>\n.*\n</answer>",
+        )
+        trainer = RLOOTrainer(
+            model="Qwen/Qwen2.5-0.5B-Instruct",  # tiny model is too small for vLLM
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_additional_generation_kwargs(self):
+        """Test that training works with additional generation kwargs."""
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+            top_p=0.9,
+            top_k=10,
+            min_p=0.01,
+            repetition_penalty=1.1,
+        )
+
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @require_vllm
+    @pytest.mark.skip(reason="We should add a mock for the vLLM server.")
+    def test_train_vllm_with_additional_generation_kwargs(self):
+        """Test that training works with vLLM and additional generation kwargs."""
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+            use_vllm=True,
+            top_p=0.9,
+            top_k=10,
+            min_p=0.01,
+            repetition_penalty=1.1,
+        )
+
+        trainer = RLOOTrainer(
+            model="Qwen/Qwen2.5-0.5B-Instruct",  # tiny model is too small for vLLM
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_normalized_advantages(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            normalize_advantages=True,
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_clipped_rewards(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            reward_clip_range=(-1, 1),
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @patch("transformers.generation.utils.GenerationMixin.generate")
+    def test_train_with_mask_truncated_completions(self, mock_generate):
+        """Test that training works with mask_truncated_completions=True parameter."""
+
+        # We mock the generate method because the model's random weights make it extremely unlikely to produce a
+        # sequence containing the EOS token within the allowed max_completion_length. As a result, all tokens are
+        # masked in the loss, the model doesn't update, and the final check (which verifies the update) fails.
+        def fake_generate(input_ids, **kwargs):
+            # pad_token_id = 151643; eos_token_id = 151645
+            completion_ids = torch.tensor(
+                [
+                    [1, 2, 3, 4, 5, 6, 7, 8],  # this one is truncated
+                    [9, 10, 11, 151645, 151643, 151643, 151643, 151643],  # this one contains eos
+                    [12, 13, 14, 15, 16, 17, 18, 151645],  # particular case, eos is generated just within the limit
+                ],
+                device=input_ids.device,
+            )
+            return torch.cat([input_ids, completion_ids], dim=1)
+
+        mock_generate.side_effect = fake_generate
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            mask_truncated_completions=True,  # Enable masking of truncated completions
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_mask_truncated_completions_all_masked(self):
+        """
+        Test that when all generated completions are truncated (i.e., none contain an EOS token), and
+        mask_truncated_completions=True, the model receives no effective learning signal and therefore does not update
+        its parameters.
+
+        Here, we don't mock the generate method, be we rely on the fact that the model the probability of generating
+        the EOS token is extremely low, so all generated completions are truncated.
+        """
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            mask_truncated_completions=True,  # Enable masking of truncated completions
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert torch.equal(param, new_param), f"Parameter {n} has changed."
+
+    def test_warning_raised_all_rewards_none(self, caplog):
+        """Test that a proper warning is raised when all rewards are None."""
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        def always_none_reward_func(completions, **kwargs):
+            """Reward function that always returns None."""
+            return [None] * len(completions)
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=always_none_reward_func,
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        with caplog.at_level("WARNING", logger="trl.trainer.rloo_trainer"):
+            trainer.train()
+
+        expected_warning = "All reward functions returned None for the following kwargs:"
+        assert expected_warning in caplog.text
+
+    def test_train_num_generations_larger_than_batch_size(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            num_generations=6,  # the number of generations is larger than the batch size, but
+            gradient_accumulation_steps=2,  # gradient accumulation should allow that
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_multiple_dataloader_workers(self):
+        # Pytest/CI often starts background threads before tests run. With Python 3.12, using the default "fork" start
+        # method in a multi-threaded process emits a DeprecationWarning and may deadlock.
+        #
+        # We force "spawn" here to make multiprocessing safe under pytest when DataLoader workers are enabled. This is
+        # test-environment–specific and not required by the training logic itself.
+        #
+        # This means the test does not cover "fork". However, "spawn" is stricter (requires full picklability and clean
+        # state) and avoids fork-after-threads issues that pytest cannot reliably test anyway. Fork-specific behavior,
+        # if needed, should be tested in a clean process outside pytest.
+        torch.multiprocessing.set_start_method("spawn", force=True)
+
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            dataloader_num_workers=2,  # use multiple dataloader workers
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_generation_kwargs(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            # Pass gen kwargs
+            generation_kwargs={"do_sample": True, "top_k": 50, "num_beams": 2, "length_penalty": -0.1},
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_with_reward_func_accessing_trainer_state(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        def reward_func(completions, **kwargs):
+            trainer_state = kwargs.get("trainer_state")
+            assert trainer_state is not None
+            # transformers.TrainerState instance should have a `global_step` property.
+            assert hasattr(trainer_state, "global_step")
+            return [float(len(set(completion))) for completion in completions]
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=reward_func,
+            args=training_args,
+            train_dataset=dataset,
+        )
+        trainer.train()
+
+    def test_train_reward_func_with_log_extra(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        def reward_func(completions, **kwargs):
+            log_extra = kwargs.get("log_extra")
+            assert log_extra is not None
+            log_extra("test_column", [completion[:5] for completion in completions])
+            return [float(len(completion)) for completion in completions]
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+            log_completions=True,
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=reward_func,
+            args=training_args,
+            train_dataset=dataset,
+        )
+        trainer.train()
+        assert "test_column" in trainer._logs["extra"]
+
+    def test_train_reward_func_with_log_metric(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        def reward_func(completions, **kwargs):
+            log_metric = kwargs.get("log_metric")
+            assert log_metric is not None
+            log_metric("custom_accuracy", 0.75)
+            return [float(len(completion)) for completion in completions]
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=reward_func,
+            args=training_args,
+            train_dataset=dataset,
+        )
+        trainer.train()
+        # log_metric appends to _metrics, which gets averaged and merged into log_history
+        logged_keys = {k for entry in trainer.state.log_history for k in entry}
+        assert "custom_accuracy" in logged_keys
+
+    def test_prepare_input_called_with_correct_data(self):
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            gradient_accumulation_steps=3,  # can be anything in this test
+            # steps_per_generation*per_device_train_batch_size=24 is divisible by num_generations=4
+            steps_per_generation=4,
+            num_generations=4,
+            per_device_train_batch_size=6,  # reduce the batch size to reduce memory usage
+            num_iterations=2,
+            shuffle_dataset=False,
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+        # steps_per_generation=4, per_device_train_batch_size=6 and num_generations=4, so we expect a
+        # generation batch of 24 samples (steps_per_generation * per_device_train_batch_size), containing 6
+        # different prompts (steps_per_generation * per_device_train_batch_size // num_generations), each repeated
+        # 4 times (num_generations).
+        expected_first_generation_batch = (
+            [{"prompt": "Beautiful is better than"}] * 4
+            + [{"prompt": "Explicit is"}] * 4
+            + [{"prompt": "Simple is better"}] * 4
+            + [{"prompt": "Complex"}] * 4
+            + [{"prompt": "Flat is better than"}] * 4
+            + [{"prompt": "Sparse is better"}] * 4
+        )
+        expected_second_generation_batch = (
+            [{"prompt": "Readability"}] * 4
+            + [{"prompt": "Special cases aren't special"}] * 4
+            + [{"prompt": "Although practicality beats"}] * 4
+            + [{"prompt": "Errors should never"}] * 4
+            + [{"prompt": "Unless explicitly"}] * 4
+            + [{"prompt": "In the face of ambiguity, refuse"}] * 4
+        )
+
+        with patch.object(RLOOTrainer, "training_step", wraps=trainer.training_step) as mock_prepare:
+            trainer.train()
+            # 3 epochs * 2 iterations * 2 generation batches to cover the dataset * 4 steps_per_generation
+            assert mock_prepare.call_count == 48
+            for i in range(0, 8):  # Generation batch repeated 8 times (steps_per_generation*num_iterations)
+                assert mock_prepare.call_args_list[i].args[1] == expected_first_generation_batch
+            for i in range(8, 16):
+                assert mock_prepare.call_args_list[i].args[1] == expected_second_generation_batch
+
+    def test_train_with_chat_template_kwargs(self):
+        dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_only", split="train")
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=3,  # reduce the batch size to reduce memory usage
+            num_generations=3,  # reduce the number of generations to reduce memory usage
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+            chat_template_kwargs={"enable_thinking": False},
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen3ForCausalLM",
+            reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_mismatched_reward_processing_classes_length(self):
+        """Test that mismatched length between reward_funcs and reward_processing_classes raises error."""
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        # Use two reward models
+        reward_models = [
+            "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            "trl-internal-testing/tiny-Qwen3ForSequenceClassification",
+        ]
+
+        # Create a single processing class (tokenizer)
+        single_processing_class = AutoTokenizer.from_pretrained(
+            "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5"
+        )
+
+        training_args = RLOOConfig(output_dir=self.tmp_dir, report_to="none")
+
+        with pytest.raises(ValueError, match="must match"):
+            RLOOTrainer(
+                model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+                reward_funcs=reward_models,
+                reward_processing_classes=single_processing_class,  # only one, but need two
+                args=training_args,
+                train_dataset=dataset,
+            )
+
+    def test_correct_reward_processing_classes_list(self):
+        """Test that correct list of reward_processing_classes works properly."""
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        # Use two reward models
+        reward_models = [
+            "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+            "trl-internal-testing/tiny-Qwen3ForSequenceClassification",
+        ]
+
+        # Create processing classes
+        processing_class1 = AutoTokenizer.from_pretrained(
+            "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5"
+        )
+        processing_class2 = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen3ForSequenceClassification")
+
+        training_args = RLOOConfig(output_dir=self.tmp_dir, report_to="none")
+
+        # Correct list length should work
+        correct_processing_classes = [processing_class1, processing_class2]
+
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=reward_models,
+            reward_processing_classes=correct_processing_classes,
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        assert len(trainer.reward_processing_classes) == len(reward_models)
+
+    def test_single_reward_model_with_single_processing_class(self):
+        """Test that single reward model with single processing class works."""
+        dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+        # Use single reward model
+        reward_model = "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5"
+
+        # Create a single processing class (tokenizer)
+        single_processing_class = AutoTokenizer.from_pretrained(
+            "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5"
+        )
+
+        training_args = RLOOConfig(output_dir=self.tmp_dir, report_to="none")
+
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+            reward_funcs=reward_model,
+            reward_processing_classes=single_processing_class,  # single object for single reward model
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        assert len(trainer.reward_processing_classes) == 1
+        assert trainer.reward_processing_classes[0] == single_processing_class
+
+
+@require_vision
+class TestRLOOTrainerVLM(TrlTestCase):
+    @pytest.mark.parametrize(
+        "model_id",
+        [
+            "trl-internal-testing/tiny-Gemma3ForConditionalGeneration",
+            pytest.param(
+                "trl-internal-testing/tiny-Gemma4ForConditionalGeneration",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.5.0"),
+                    reason="Gemma4 models were introduced in transformers-5.5.0",
+                ),
+            ),
+            "trl-internal-testing/tiny-LlavaNextForConditionalGeneration",
+            "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+            "trl-internal-testing/tiny-Qwen2VLForConditionalGeneration",
+            pytest.param(
+                "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.2.0"),
+                    reason="Qwen3.5 models were introduced in transformers-5.2.0",
+                ),
+            ),
+            pytest.param(
+                "trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.2.0"),
+                    reason="Qwen3.5 models were introduced in transformers-5.2.0",
+                ),
+            ),
+            # "trl-internal-testing/tiny-SmolVLMForConditionalGeneration", seems not to support bf16 properly
+        ],
+    )
+    def test_train_vlm(self, model_id):
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_only", split="train")
+
+        def reward_func(completions, **kwargs):
+            """Reward function that rewards longer completions."""
+            return [float(len(completion[0]["content"])) for completion in completions]
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=2,  # VLM training is memory intensive, reduce batch size to avoid OOM
+            num_generations=2,  # VLM training is memory intensive, reduce num_generations to avoid OOM
+            # note: num_generations=2 is only suitable for CI testing; production training should use more generations
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model=model_id,
+            reward_funcs=reward_func,
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            # LLaVA & LLaVA-Next: vision_feature_layer=-2 leaves the last encoder layer (layers.1) and
+            # post_layernorm (pooler-only path) without gradient by design. Assert they stay frozen — if they
+            # ever start training, the feature-selection plumbing has likely regressed.
+            if model_id in (
+                "trl-internal-testing/tiny-LlavaForConditionalGeneration",
+                "trl-internal-testing/tiny-LlavaNextForConditionalGeneration",
+            ) and ("encoder.layers.1" in n or "post_layernorm" in n):
+                assert torch.equal(param, new_param), f"Param {n} expected frozen by LLaVA design, but changed"
+            else:
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    def test_train_vlm_with_pad_to_multiple_of(self):
+        # Models like Gemma3 use other forward keyword arguments like token_type_ids that also need to be padded when
+        # using pad_to_multiple_of, so we test that the trainer correctly pads all the necessary inputs in this case.
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_only", split="train")
+
+        def reward_func(completions, **kwargs):
+            """Reward function that rewards longer completions."""
+            return [float(len(completion[0]["content"])) for completion in completions]
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=2,  # VLM training is memory intensive, reduce batch size to avoid OOM
+            num_generations=2,  # VLM training is memory intensive, reduce num_generations to avoid OOM
+            # note: num_generations=2 is only suitable for CI testing; production training should use more generations
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            pad_to_multiple_of=7,
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model="trl-internal-testing/tiny-Gemma3ForConditionalGeneration",
+            reward_funcs=reward_func,
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @pytest.mark.parametrize(
+        "model_id",
+        [
+            "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+        ],
+    )
+    def test_train_vlm_beta_non_zero(self, model_id):
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_only", split="train")
+
+        def reward_func(completions, **kwargs):
+            """Reward function that rewards longer completions."""
+            return [float(len(completion[0]["content"])) for completion in completions]
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            beta=0.1,  # set beta to non-zero value to test the case where the reference model is used
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=2,  # VLM training is memory intensive, reduce batch size to avoid OOM
+            num_generations=2,  # VLM training is memory intensive, reduce num_generations to avoid OOM
+            # note: num_generations=2 is only suitable for CI testing; production training should use more generations
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model=model_id,
+            reward_funcs=reward_func,
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the params have changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @pytest.mark.parametrize(
+        "model_id",
+        [
+            "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+        ],
+    )
+    @require_peft
+    def test_train_vlm_peft(self, model_id):
+        model = AutoModelForImageTextToText.from_pretrained(model_id, dtype="float32")
+        base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()]
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_only", split="train")
+
+        def reward_func(completions, **kwargs):
+            """Reward function that rewards longer completions."""
+            return [float(len(completion[0]["content"])) for completion in completions]
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=2,  # VLM training is memory intensive, reduce batch size to avoid OOM
+            num_generations=2,  # VLM training is memory intensive, reduce num_generations to avoid OOM
+            # note: num_generations=2 is only suitable for CI testing; production training should use more generations
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model=model,
+            reward_funcs=reward_func,
+            args=training_args,
+            train_dataset=dataset,
+            peft_config=LoraConfig(target_modules=["q_proj", "v_proj"]),
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        # Check that the peft params have changed and the base model params have not changed
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            if n in base_param_names:  # We expect the base model params to be the same
+                torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.")
+            elif "base_layer" not in n:  # We expect the peft params to be different (except for the base layer)
+                assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @pytest.mark.parametrize(
+        "model_id",
+        [
+            "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+            "trl-internal-testing/tiny-Gemma3ForConditionalGeneration",
+            pytest.param(
+                "trl-internal-testing/tiny-Gemma4ForConditionalGeneration",
+                marks=pytest.mark.skipif(
+                    Version(transformers.__version__) < Version("5.5.0"),
+                    reason="Gemma4 models were introduced in transformers-5.5.0",
+                ),
+            ),
+        ],
+    )
+    @require_vllm
+    @pytest.mark.skip(reason="We should add a mock for the vLLM server.")
+    def test_train_vlm_and_vllm(self, model_id) -> None:
+        dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_only", split="train")
+
+        def reward_func(completions, **kwargs):
+            """Reward function that rewards longer completions."""
+            return [float(len(completion[0]["content"])) for completion in completions]
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=2,  # VLM training is memory intensive, reduce batch size to avoid OOM
+            num_generations=2,  # VLM training is memory intensive, reduce num_generations to avoid OOM
+            # note: num_generations=2 is only suitable for CI testing; production training should use more generations
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+            use_vllm=True,
+            vllm_mode="server",
+        )
+        trainer = RLOOTrainer(
+            model=model_id,
+            reward_funcs=reward_func,
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."
+
+    @pytest.mark.parametrize(
+        "model_id",
+        [
+            "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration",
+        ],
+    )
+    def test_train_vlm_multi_image(self, model_id):
+        dataset = load_dataset("trl-internal-testing/zen-multi-image", "conversational_prompt_only", split="train")
+
+        def reward_func(completions, **kwargs):
+            """Reward function that rewards longer completions."""
+            return [float(len(completion[0]["content"])) for completion in completions]
+
+        training_args = RLOOConfig(
+            output_dir=self.tmp_dir,
+            learning_rate=0.1,  # use higher lr because gradients are tiny and default lr can stall updates
+            per_device_train_batch_size=2,  # VLM training is memory intensive, reduce batch size to avoid OOM
+            num_generations=2,  # VLM training is memory intensive, reduce num_generations to avoid OOM
+            # note: num_generations=2 is only suitable for CI testing; production training should use more generations
+            max_completion_length=8,  # reduce the completion length to reduce memory usage
+            report_to="none",
+        )
+        trainer = RLOOTrainer(
+            model=model_id,
+            reward_funcs=reward_func,
+            args=training_args,
+            train_dataset=dataset,
+        )
+
+        previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()}
+
+        trainer.train()
+
+        assert trainer.state.log_history[-1]["train_loss"] is not None
+
+        for n, param in previous_trainable_params.items():
+            new_param = trainer.model.get_parameter(n)
+            assert not torch.equal(param, new_param), f"Parameter {n} has not changed."

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_skills.py

@@ -0,0 +1,578 @@
+# 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 pathlib import Path
+
+import pytest
+
+from trl.skills import install_skill, list_agent_names, list_skills, resolve_target_path, uninstall_skill
+from trl.skills.skills import _get_trl_skills_dir
+
+
+class TestGetTrlSkillsDir:
+    """Tests for _get_trl_skills_dir function."""
+
+    def test_returns_path_object(self):
+        """Test that returns a Path object."""
+        skills_dir = _get_trl_skills_dir()
+        assert isinstance(skills_dir, Path)
+
+    def test_directory_exists(self):
+        """Test that the returned directory exists."""
+        skills_dir = _get_trl_skills_dir()
+        assert skills_dir.exists(), f"Skills directory does not exist: {skills_dir}"
+
+    def test_is_directory(self):
+        """Test that the returned path is a directory."""
+        skills_dir = _get_trl_skills_dir()
+        assert skills_dir.is_dir(), f"Skills path is not a directory: {skills_dir}"
+
+    def test_contains_skills_module(self):
+        """Test that the path ends with 'skills' (the module name)."""
+        skills_dir = _get_trl_skills_dir()
+        assert skills_dir.name == "skills"
+
+
+class TestListSkills:
+    """Tests for list_skills function."""
+
+    def test_returns_list(self):
+        """Test that list_skills returns a list."""
+        skills = list_skills()
+        assert isinstance(skills, list)
+
+    def test_contains_trl_training(self):
+        """Test that list_skills includes the trl-training skill."""
+        skills = list_skills()
+        assert "trl-training" in skills
+
+    def test_skills_are_sorted(self):
+        """Test that skills are returned in sorted order."""
+        skills = list_skills()
+        assert skills == sorted(skills)
+
+    def test_with_custom_directory(self, tmp_path):
+        """Test list_skills with a custom directory."""
+        # Create fake skills
+        (tmp_path / "skill1").mkdir()
+        (tmp_path / "skill1" / "SKILL.md").write_text("# Skill 1")
+        (tmp_path / "skill2").mkdir()
+        (tmp_path / "skill2" / "SKILL.md").write_text("# Skill 2")
+        (tmp_path / "not-a-skill").mkdir()  # No SKILL.md
+
+        skills = list_skills(tmp_path)
+        assert skills == ["skill1", "skill2"]
+
+    def test_empty_directory(self, tmp_path):
+        """Test list_skills with an empty directory."""
+        skills = list_skills(tmp_path)
+        assert skills == []
+
+    def test_nonexistent_directory(self, tmp_path):
+        """Test list_skills with a non-existent directory."""
+        nonexistent = tmp_path / "nonexistent"
+        skills = list_skills(nonexistent)
+        assert skills == []
+
+    def test_ignores_files(self, tmp_path):
+        """Test that list_skills ignores files, only returns directories."""
+        (tmp_path / "skill1").mkdir()
+        (tmp_path / "skill1" / "SKILL.md").write_text("# Skill 1")
+        (tmp_path / "not-a-skill.txt").write_text("Not a skill")
+
+        skills = list_skills(tmp_path)
+        assert skills == ["skill1"]
+
+    def test_requires_skill_md(self, tmp_path):
+        """Test that directories without SKILL.md are ignored."""
+        (tmp_path / "has-skill-md").mkdir()
+        (tmp_path / "has-skill-md" / "SKILL.md").write_text("# Valid")
+        (tmp_path / "no-skill-md").mkdir()
+        (tmp_path / "no-skill-md" / "readme.md").write_text("# Invalid")
+
+        skills = list_skills(tmp_path)
+        assert skills == ["has-skill-md"]
+
+
+class TestInstallSkill:
+    """Tests for install_skill function."""
+
+    def test_basic_installation(self, tmp_path):
+        """Test basic skill installation."""
+        target_dir = tmp_path / "target"
+
+        result = install_skill("trl-training", target_dir)
+
+        assert result is True
+        assert (target_dir / "trl-training").exists()
+        assert (target_dir / "trl-training" / "SKILL.md").exists()
+
+    def test_creates_target_directory(self, tmp_path):
+        """Test that install_skill creates the target directory if it doesn't exist."""
+        target_dir = tmp_path / "nested" / "target"
+
+        install_skill("trl-training", target_dir)
+
+        assert target_dir.exists()
+        assert (target_dir / "trl-training").exists()
+
+    def test_skill_not_found(self, tmp_path):
+        """Test that install_skill raises FileNotFoundError for non-existent skill."""
+        target_dir = tmp_path / "target"
+
+        with pytest.raises(FileNotFoundError, match="Skill 'nonexistent' not found"):
+            install_skill("nonexistent", target_dir)
+
+    def test_skill_already_exists_without_force(self, tmp_path):
+        """Test that install_skill raises FileExistsError if skill exists and force=False."""
+        target_dir = tmp_path / "target"
+
+        # Install once
+        install_skill("trl-training", target_dir)
+
+        # Try to install again without force
+        with pytest.raises(FileExistsError, match="already installed"):
+            install_skill("trl-training", target_dir, force=False)
+
+    def test_force_overwrites_existing(self, tmp_path):
+        """Test that install_skill with force=True overwrites existing skill."""
+        target_dir = tmp_path / "target"
+
+        # Install once
+        install_skill("trl-training", target_dir)
+
+        # Modify the installed skill
+        marker_file = target_dir / "trl-training" / "marker.txt"
+        marker_file.write_text("This should be removed")
+
+        # Install again with force
+        result = install_skill("trl-training", target_dir, force=True)
+
+        assert result is True
+        assert (target_dir / "trl-training").exists()
+        assert not marker_file.exists()  # Marker should be gone
+
+    def test_force_overwrites_symlink(self, tmp_path):
+        """Test that install_skill with force=True can overwrite a symlink."""
+        target_dir = tmp_path / "target"
+        target_dir.mkdir()
+
+        # Create a symlink
+        symlink = target_dir / "trl-training"
+        symlink.symlink_to(_get_trl_skills_dir() / "trl-training")
+
+        # Install with force should replace symlink with copy
+        result = install_skill("trl-training", target_dir, force=True)
+
+        assert result is True
+        assert (target_dir / "trl-training").exists()
+        assert not (target_dir / "trl-training").is_symlink()
+
+    def test_skill_not_directory(self, tmp_path):
+        """Test that install_skill raises ValueError if skill is not a directory."""
+        source_dir = tmp_path / "source"
+        source_dir.mkdir()
+        target_dir = tmp_path / "target"
+
+        # Create a file instead of directory
+        (source_dir / "fake-skill").write_text("not a directory")
+
+        with pytest.raises(ValueError, match="is not a directory"):
+            install_skill("fake-skill", target_dir, source=source_dir)
+
+    def test_preserves_directory_structure(self, tmp_path):
+        """Test that install_skill preserves the skill's directory structure."""
+        source_dir = tmp_path / "source"
+        target_dir = tmp_path / "target"
+
+        # Create a skill with subdirectories
+        skill_dir = source_dir / "test-skill"
+        skill_dir.mkdir(parents=True)
+        (skill_dir / "SKILL.md").write_text("# Test")
+        (skill_dir / "subdir").mkdir()
+        (skill_dir / "subdir" / "file.txt").write_text("content")
+
+        install_skill("test-skill", target_dir, source=source_dir)
+
+        assert (target_dir / "test-skill" / "SKILL.md").exists()
+        assert (target_dir / "test-skill" / "subdir" / "file.txt").exists()
+        assert (target_dir / "test-skill" / "subdir" / "file.txt").read_text() == "content"
+
+    def test_install_to_same_directory_fails(self, tmp_path):
+        """Test that installing to the same directory as source is handled correctly."""
+        source_dir = tmp_path / "skills"
+        source_dir.mkdir()
+
+        # Create a skill
+        skill_dir = source_dir / "test-skill"
+        skill_dir.mkdir()
+        (skill_dir / "SKILL.md").write_text("# Test")
+
+        # Try to install to same directory (should fail with exists error)
+        with pytest.raises(FileExistsError):
+            install_skill("test-skill", source_dir, source=source_dir, force=False)
+
+
+class TestUninstallSkill:
+    """Tests for uninstall_skill function."""
+
+    def test_basic_uninstallation(self, tmp_path):
+        """Test basic skill uninstallation."""
+        target_dir = tmp_path / "target"
+
+        # Install first
+        install_skill("trl-training", target_dir)
+        assert (target_dir / "trl-training").exists()
+
+        # Uninstall
+        result = uninstall_skill("trl-training", target_dir)
+
+        assert result is True
+        assert not (target_dir / "trl-training").exists()
+
+    def test_skill_not_installed(self, tmp_path):
+        """Test that uninstall_skill raises FileNotFoundError for non-existent skill."""
+        target_dir = tmp_path / "target"
+        target_dir.mkdir()
+
+        with pytest.raises(FileNotFoundError, match="not installed"):
+            uninstall_skill("nonexistent", target_dir)
+
+    def test_uninstall_from_nonexistent_directory(self, tmp_path):
+        """Test uninstall_skill when target directory doesn't exist."""
+        target_dir = tmp_path / "nonexistent"
+
+        with pytest.raises(FileNotFoundError, match="not installed"):
+            uninstall_skill("trl-training", target_dir)
+
+    def test_uninstall_removes_all_contents(self, tmp_path):
+        """Test that uninstall removes the entire skill directory."""
+        source_dir = tmp_path / "source"
+        target_dir = tmp_path / "target"
+
+        # Create a skill with multiple files
+        skill_dir = source_dir / "test-skill"
+        skill_dir.mkdir(parents=True)
+        (skill_dir / "SKILL.md").write_text("# Test")
+        (skill_dir / "file1.txt").write_text("content1")
+        (skill_dir / "subdir").mkdir()
+        (skill_dir / "subdir" / "file2.txt").write_text("content2")
+
+        # Install and uninstall
+        install_skill("test-skill", target_dir, source=source_dir)
+        uninstall_skill("test-skill", target_dir)
+
+        assert not (target_dir / "test-skill").exists()
+        # Target directory itself should still exist
+        assert target_dir.exists()
+
+    def test_uninstall_doesnt_affect_other_skills(self, tmp_path):
+        """Test that uninstalling one skill doesn't affect others."""
+        source_dir = tmp_path / "source"
+        target_dir = tmp_path / "target"
+
+        # Create two skills
+        for skill_name in ["skill1", "skill2"]:
+            skill_dir = source_dir / skill_name
+            skill_dir.mkdir(parents=True)
+            (skill_dir / "SKILL.md").write_text(f"# {skill_name}")
+
+        # Install both
+        install_skill("skill1", target_dir, source=source_dir)
+        install_skill("skill2", target_dir, source=source_dir)
+
+        # Uninstall one
+        uninstall_skill("skill1", target_dir)
+
+        # Check that only skill1 is removed
+        assert not (target_dir / "skill1").exists()
+        assert (target_dir / "skill2").exists()
+
+
+class TestIntegration:
+    """Integration tests for skills functions."""
+
+    def test_full_workflow(self, tmp_path):
+        """Test complete install -> list -> uninstall workflow."""
+        source_dir = tmp_path / "source"
+        target_dir = tmp_path / "target"
+
+        # Create skills
+        for i in range(3):
+            skill_dir = source_dir / f"skill{i}"
+            skill_dir.mkdir(parents=True)
+            (skill_dir / "SKILL.md").write_text(f"# Skill {i}")
+
+        # List available skills
+        available = list_skills(target=source_dir)
+        assert available == ["skill0", "skill1", "skill2"]
+
+        # Install skills
+        for skill in available:
+            install_skill(skill, target_dir, source=source_dir)
+
+        # List installed skills
+        installed_dirs = [d.name for d in target_dir.iterdir() if d.is_dir()]
+        assert sorted(installed_dirs) == ["skill0", "skill1", "skill2"]
+
+        # Uninstall one skill
+        uninstall_skill("skill1", target_dir)
+
+        # Verify
+        installed_dirs = [d.name for d in target_dir.iterdir() if d.is_dir()]
+        assert sorted(installed_dirs) == ["skill0", "skill2"]
+
+    def test_install_uninstall_cycle(self, tmp_path):
+        """Test that we can install and uninstall the same skill multiple times."""
+        source_dir = tmp_path / "source"
+        target_dir = tmp_path / "target"
+
+        # Create skill
+        skill_dir = source_dir / "test-skill"
+        skill_dir.mkdir(parents=True)
+        (skill_dir / "SKILL.md").write_text("# Test")
+
+        # Install -> Uninstall -> Install -> Uninstall
+        for _ in range(2):
+            install_skill("test-skill", target_dir, source=source_dir)
+            assert (target_dir / "test-skill").exists()
+
+            uninstall_skill("test-skill", target_dir)
+            assert not (target_dir / "test-skill").exists()
+
+    def test_force_reinstall_workflow(self, tmp_path):
+        """Test the workflow of using force to update an installed skill."""
+        source_dir = tmp_path / "source"
+        target_dir = tmp_path / "target"
+
+        # Create initial skill version
+        skill_dir = source_dir / "test-skill"
+        skill_dir.mkdir(parents=True)
+        (skill_dir / "SKILL.md").write_text("# Version 1")
+
+        # Install
+        install_skill("test-skill", target_dir, source=source_dir)
+        assert (target_dir / "test-skill" / "SKILL.md").read_text() == "# Version 1"
+
+        # Update source skill
+        (skill_dir / "SKILL.md").write_text("# Version 2")
+
+        # Force reinstall
+        install_skill("test-skill", target_dir, source=source_dir, force=True)
+        assert (target_dir / "test-skill" / "SKILL.md").read_text() == "# Version 2"
+
+
+class TestEdgeCases:
+    """Tests for edge cases and special scenarios."""
+
+    def test_skill_with_special_characters_in_name(self, tmp_path):
+        """Test handling skills with special characters in names."""
+        source_dir = tmp_path / "source"
+        target_dir = tmp_path / "target"
+
+        # Create skill with hyphens and underscores (common in skill names)
+        skill_name = "test-skill_v2"
+        skill_dir = source_dir / skill_name
+        skill_dir.mkdir(parents=True)
+        (skill_dir / "SKILL.md").write_text("# Test")
+
+        # Should work fine
+        install_skill(skill_name, target_dir, source=source_dir)
+        assert (target_dir / skill_name).exists()
+
+        uninstall_skill(skill_name, target_dir)
+        assert not (target_dir / skill_name).exists()
+
+    def test_empty_skill_directory(self, tmp_path):
+        """Test installing a skill with only SKILL.md (no other files)."""
+        source_dir = tmp_path / "source"
+        target_dir = tmp_path / "target"
+
+        skill_dir = source_dir / "minimal-skill"
+        skill_dir.mkdir(parents=True)
+        (skill_dir / "SKILL.md").write_text("# Minimal")
+
+        install_skill("minimal-skill", target_dir, source=source_dir)
+
+        assert (target_dir / "minimal-skill" / "SKILL.md").exists()
+        # Should only contain SKILL.md
+        files = list((target_dir / "minimal-skill").iterdir())
+        assert len(files) == 1
+        assert files[0].name == "SKILL.md"
+
+    def test_skill_with_hidden_files(self, tmp_path):
+        """Test that hidden files are preserved during installation."""
+        source_dir = tmp_path / "source"
+        target_dir = tmp_path / "target"
+
+        skill_dir = source_dir / "test-skill"
+        skill_dir.mkdir(parents=True)
+        (skill_dir / "SKILL.md").write_text("# Test")
+        (skill_dir / ".hidden").write_text("hidden content")
+
+        install_skill("test-skill", target_dir, source=source_dir)
+
+        assert (target_dir / "test-skill" / ".hidden").exists()
+        assert (target_dir / "test-skill" / ".hidden").read_text() == "hidden content"
+
+    def test_list_skills_with_symlinks(self, tmp_path):
+        """Test that list_skills handles symlinked skill directories."""
+        source_dir = tmp_path / "source"
+        skills_dir = tmp_path / "skills"
+        skills_dir.mkdir()
+
+        # Create a real skill
+        skill_dir = source_dir / "real-skill"
+        skill_dir.mkdir(parents=True)
+        (skill_dir / "SKILL.md").write_text("# Real")
+
+        # Create symlink to it
+        (skills_dir / "linked-skill").symlink_to(skill_dir)
+
+        # list_skills should include symlinked skills if they have SKILL.md
+        skills = list_skills(target=skills_dir)
+        assert "linked-skill" in skills
+
+
+class TestListAgentNames:
+    """Tests for list_agent_names function."""
+
+    def test_returns_list(self):
+        """Test that list_agent_names returns a list."""
+        agents = list_agent_names()
+        assert isinstance(agents, list)
+
+    def test_contains_expected_agents(self):
+        """Test that list includes expected agent names."""
+        agents = list_agent_names()
+        assert "agents" in agents
+        assert "claude" in agents
+
+
+class TestResolveTargetPath:
+    """Tests for resolve_target_path function."""
+
+    def test_resolve_agent_name_project_scope(self):
+        """Test resolving agent name with project scope."""
+        path = resolve_target_path("claude", "project")
+        assert path == Path("./.claude/skills").expanduser().resolve()
+
+    def test_resolve_agent_name_global_scope(self):
+        """Test resolving agent name with global scope."""
+        path = resolve_target_path("claude", "global")
+        assert path == Path("~/.claude/skills").expanduser().resolve()
+
+    def test_resolve_custom_path_string(self):
+        """Test resolving custom path as string."""
+        path = resolve_target_path("/custom/path", "project")
+        assert path == Path("/custom/path").resolve()
+
+    def test_resolve_custom_path_object(self):
+        """Test resolving Path object."""
+        custom = Path("/custom/path")
+        path = resolve_target_path(custom, "project")
+        assert path == Path("/custom/path").resolve()
+
+    def test_resolve_path_with_tilde(self):
+        """Test that tilde expansion works."""
+        path = resolve_target_path("~/my/skills", "project")
+        assert path == Path("~/my/skills").expanduser().resolve()
+        assert "~" not in str(path)
+
+    def test_all_predefined_agents(self):
+        """Test that all predefined agents can be resolved."""
+        for agent in list_agent_names():
+            for scope in ["project", "global"]:
+                path = resolve_target_path(agent, scope)
+                assert isinstance(path, Path)
+                assert path.is_absolute()
+
+    def test_invalid_scope_for_predefined_agent(self):
+        """Test invalid scope raises ValueError for predefined agents."""
+        with pytest.raises(ValueError, match="Invalid scope"):
+            resolve_target_path("claude", "invalid")
+
+
+class TestHighLevelAPI:
+    """Tests for the new high-level API (target/scope instead of Path)."""
+
+    def test_list_skills_with_target_string(self, tmp_path):
+        """Test list_skills with target as string (custom path)."""
+        # Create skills in target
+        (tmp_path / "skill1").mkdir()
+        (tmp_path / "skill1" / "SKILL.md").write_text("# Skill 1")
+
+        skills = list_skills(target=str(tmp_path), scope="project")
+        assert skills == ["skill1"]
+
+    def test_list_skills_with_target_path(self, tmp_path):
+        """Test list_skills with target as Path object."""
+        (tmp_path / "skill1").mkdir()
+        (tmp_path / "skill1" / "SKILL.md").write_text("# Skill 1")
+
+        skills = list_skills(target=tmp_path, scope="project")
+        assert skills == ["skill1"]
+
+    def test_list_skills_without_target(self):
+        """Test list_skills without target lists TRL's built-in skills."""
+        skills = list_skills()
+        assert isinstance(skills, list)
+        assert "trl-training" in skills
+
+    def test_install_skill_with_target_string(self, tmp_path):
+        """Test install_skill with target as string."""
+        result = install_skill("trl-training", target=str(tmp_path), scope="project")
+        assert result is True
+        assert (tmp_path / "trl-training").exists()
+
+    def test_install_skill_with_target_path(self, tmp_path):
+        """Test install_skill with target as Path object."""
+        result = install_skill("trl-training", target=tmp_path, scope="project")
+        assert result is True
+        assert (tmp_path / "trl-training").exists()
+
+    def test_install_skill_with_force(self, tmp_path):
+        """Test install_skill with force parameter."""
+        install_skill("trl-training", target=tmp_path)
+        # Install again with force
+        result = install_skill("trl-training", target=tmp_path, force=True)
+        assert result is True
+
+    def test_uninstall_skill_with_target_string(self, tmp_path):
+        """Test uninstall_skill with target as string."""
+        install_skill("trl-training", target=tmp_path)
+        result = uninstall_skill("trl-training", target=str(tmp_path), scope="project")
+        assert result is True
+        assert not (tmp_path / "trl-training").exists()
+
+    def test_uninstall_skill_with_target_path(self, tmp_path):
+        """Test uninstall_skill with target as Path object."""
+        install_skill("trl-training", target=tmp_path)
+        result = uninstall_skill("trl-training", target=tmp_path, scope="project")
+        assert result is True
+        assert not (tmp_path / "trl-training").exists()
+
+    def test_install_with_custom_source(self, tmp_path):
+        """Test install_skill with custom source parameter."""
+        source_dir = tmp_path / "source"
+        target_dir = tmp_path / "target"
+
+        # Create custom skill
+        skill_dir = source_dir / "custom-skill"
+        skill_dir.mkdir(parents=True)
+        (skill_dir / "SKILL.md").write_text("# Custom")
+
+        result = install_skill("custom-skill", target=target_dir, source=source_dir)
+        assert result is True
+        assert (target_dir / "custom-skill").exists()

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_skills_cli.py

@@ -0,0 +1,288 @@
+# 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 pytest
+
+from trl.skills import install_skill
+from trl.skills.cli import add_skills_subcommands, cmd_install, cmd_list, cmd_uninstall
+
+
+class TestCLICommands:
+    """Tests for CLI command handlers."""
+
+    def test_cmd_list_without_target(self, capsys):
+        """Test cmd_list without target (lists TRL skills)."""
+        args = argparse.Namespace(target=None, scope="project")
+
+        result = cmd_list(args)
+
+        captured = capsys.readouterr()
+        assert result == 0
+        assert "TRL (available for installation)" in captured.out
+        assert "trl-training" in captured.out
+        assert "Use 'trl skills install" in captured.out
+
+    def test_cmd_list_with_target(self, tmp_path, capsys):
+        """Test cmd_list with target (lists installed skills)."""
+        # Install a skill
+        install_skill("trl-training", target=tmp_path)
+
+        args = argparse.Namespace(target=str(tmp_path), scope="project")
+        result = cmd_list(args)
+
+        captured = capsys.readouterr()
+        assert result == 0
+        assert "trl-training" in captured.out
+        assert str(tmp_path) in captured.out
+
+    def test_cmd_list_empty_target(self, tmp_path, capsys):
+        """Test cmd_list with empty target directory."""
+        args = argparse.Namespace(target=str(tmp_path), scope="project")
+
+        result = cmd_list(args)
+
+        captured = capsys.readouterr()
+        assert result == 0
+        assert "No skills installed" in captured.out
+
+    def test_cmd_install_single_skill(self, tmp_path, capsys):
+        """Test cmd_install with single skill."""
+        args = argparse.Namespace(skill="trl-training", all=False, target=str(tmp_path), scope="project", force=False)
+
+        result = cmd_install(args)
+
+        captured = capsys.readouterr()
+        assert result == 0
+        assert "✓" in captured.out
+        assert "1/1 skills installed" in captured.out
+        assert (tmp_path / "trl-training").exists()
+
+    def test_cmd_install_all_skills(self, tmp_path, capsys):
+        """Test cmd_install with --all flag."""
+        args = argparse.Namespace(skill=None, all=True, target=str(tmp_path), scope="project", force=False)
+
+        result = cmd_install(args)
+
+        captured = capsys.readouterr()
+        assert result == 0
+        assert "✓" in captured.out
+        assert "installed successfully" in captured.out
+        assert (tmp_path / "trl-training").exists()
+
+    def test_cmd_install_no_skill_or_all(self, capsys):
+        """Test cmd_install without skill name or --all flag."""
+        args = argparse.Namespace(skill=None, all=False, target="/tmp/test", scope="project", force=False)
+
+        result = cmd_install(args)
+
+        captured = capsys.readouterr()
+        assert result == 1
+        assert "Error: Either provide a skill name or use --all" in captured.out
+
+    def test_cmd_install_both_skill_and_all(self, capsys):
+        """Test cmd_install with both skill name and --all (error)."""
+        args = argparse.Namespace(skill="trl-training", all=True, target="/tmp/test", scope="project", force=False)
+
+        result = cmd_install(args)
+
+        captured = capsys.readouterr()
+        assert result == 1
+        assert "Cannot specify both" in captured.out
+
+    def test_cmd_install_nonexistent_skill(self, tmp_path, capsys):
+        """Test cmd_install with non-existent skill."""
+        args = argparse.Namespace(skill="nonexistent", all=False, target=str(tmp_path), scope="project", force=False)
+
+        result = cmd_install(args)
+
+        captured = capsys.readouterr()
+        assert result == 1
+        assert "✗" in captured.out
+        assert "0/1 skills installed" in captured.out
+
+    def test_cmd_install_already_exists(self, tmp_path, capsys):
+        """Test cmd_install when skill already exists without force."""
+        # Install once
+        install_skill("trl-training", target=tmp_path)
+
+        args = argparse.Namespace(skill="trl-training", all=False, target=str(tmp_path), scope="project", force=False)
+
+        result = cmd_install(args)
+
+        captured = capsys.readouterr()
+        assert result == 1
+        assert "✗" in captured.out
+        assert "Use --force to overwrite" in captured.out
+
+    def test_cmd_install_with_force(self, tmp_path, capsys):
+        """Test cmd_install with --force to overwrite."""
+        # Install once
+        install_skill("trl-training", target=tmp_path)
+
+        args = argparse.Namespace(skill="trl-training", all=False, target=str(tmp_path), scope="project", force=True)
+
+        result = cmd_install(args)
+
+        captured = capsys.readouterr()
+        assert result == 0
+        assert "✓" in captured.out
+        assert "1/1 skills installed" in captured.out
+
+    def test_cmd_uninstall_success(self, tmp_path, capsys):
+        """Test cmd_uninstall with installed skill."""
+        # Install first
+        install_skill("trl-training", target=tmp_path)
+
+        args = argparse.Namespace(skill="trl-training", target=str(tmp_path), scope="project")
+
+        result = cmd_uninstall(args)
+
+        captured = capsys.readouterr()
+        assert result == 0
+        assert "✓" in captured.out
+        assert "has been removed" in captured.out
+        assert not (tmp_path / "trl-training").exists()
+
+    def test_cmd_uninstall_not_installed(self, tmp_path, capsys):
+        """Test cmd_uninstall when skill is not installed."""
+        args = argparse.Namespace(skill="nonexistent", target=str(tmp_path), scope="project")
+
+        result = cmd_uninstall(args)
+
+        captured = capsys.readouterr()
+        assert result == 1
+        assert "✗" in captured.out
+        assert "Error:" in captured.out
+
+    def test_cmd_install_creates_target_directory(self, tmp_path, capsys):
+        """Test cmd_install creates target directory if it doesn't exist."""
+        # Custom path that doesn't exist yet
+        target_path = tmp_path / "new_directory"
+        assert not target_path.exists()
+
+        args = argparse.Namespace(
+            skill="trl-training", all=False, target=str(target_path), scope="project", force=False
+        )
+
+        result = cmd_install(args)
+
+        captured = capsys.readouterr()
+        assert result == 0
+        assert "✓" in captured.out
+        assert target_path.exists()
+
+    def test_cmd_uninstall_invalid_target(self, capsys):
+        """Test cmd_uninstall with non-existent path."""
+        args = argparse.Namespace(skill="trl-training", target="/nonexistent/invalid/path", scope="project")
+
+        result = cmd_uninstall(args)
+
+        captured = capsys.readouterr()
+        assert result == 1
+        assert "✗" in captured.out
+
+
+class TestCLIArgumentParsing:
+    """Tests for CLI argument parsing setup."""
+
+    def test_add_skills_subcommands_creates_parsers(self):
+        """Test that add_skills_subcommands creates the expected subparsers."""
+        parser = argparse.ArgumentParser()
+        subparsers = parser.add_subparsers(dest="command")
+
+        add_skills_subcommands(subparsers)
+
+        # Test that we can parse expected commands
+        args = parser.parse_args(["list"])
+        assert args.command == "list"
+        assert hasattr(args, "func")
+
+        args = parser.parse_args(["install", "trl-training", "--target", "claude"])
+        assert args.command == "install"
+        assert args.skill == "trl-training"
+        assert args.target == "claude"
+
+        args = parser.parse_args(["uninstall", "trl-training", "--target", "claude"])
+        assert args.command == "uninstall"
+        assert args.skill == "trl-training"
+
+    def test_list_command_optional_target(self):
+        """Test that list command has optional target."""
+        parser = argparse.ArgumentParser()
+        subparsers = parser.add_subparsers(dest="command")
+        add_skills_subcommands(subparsers)
+
+        # Should work without target
+        args = parser.parse_args(["list"])
+        assert args.target is None
+
+        # Should work with target
+        args = parser.parse_args(["list", "--target", "claude"])
+        assert args.target == "claude"
+
+    def test_default_target_is_agents(self):
+        """Test that default target is 'agents'."""
+        parser = argparse.ArgumentParser()
+        subparsers = parser.add_subparsers(dest="command")
+        add_skills_subcommands(subparsers)
+
+        args = parser.parse_args(["install", "trl-training"])
+        assert args.target == "agents"
+
+    def test_scope_choices(self):
+        """Test that scope parameter accepts valid choices."""
+        parser = argparse.ArgumentParser()
+        subparsers = parser.add_subparsers(dest="command")
+        add_skills_subcommands(subparsers)
+
+        # Valid scopes
+        args = parser.parse_args(["install", "trl-training", "--target", "claude", "--scope", "project"])
+        assert args.scope == "project"
+
+        args = parser.parse_args(["install", "trl-training", "--target", "claude", "--scope", "global"])
+        assert args.scope == "global"
+
+        # Invalid scope should fail
+        with pytest.raises(SystemExit):
+            parser.parse_args(["install", "trl-training", "--target", "claude", "--scope", "invalid"])
+
+    def test_install_all_flag(self):
+        """Test install --all flag."""
+        parser = argparse.ArgumentParser()
+        subparsers = parser.add_subparsers(dest="command")
+        add_skills_subcommands(subparsers)
+
+        args = parser.parse_args(["install", "--all", "--target", "claude"])
+        assert args.all is True
+        assert args.skill is None
+
+    def test_install_force_flag(self):
+        """Test install --force flag."""
+        parser = argparse.ArgumentParser()
+        subparsers = parser.add_subparsers(dest="command")
+        add_skills_subcommands(subparsers)
+
+        args = parser.parse_args(["install", "trl-training", "--target", "claude", "--force"])
+        assert args.force is True
+
+    def test_default_scope_is_project(self):
+        """Test that default scope is 'project'."""
+        parser = argparse.ArgumentParser()
+        subparsers = parser.add_subparsers(dest="command")
+        add_skills_subcommands(subparsers)
+
+        args = parser.parse_args(["install", "trl-training", "--target", "claude"])
+        assert args.scope == "project"

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_utils.py

@@ -0,0 +1,1380 @@
+# 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 copy
+import textwrap
+from io import StringIO
+from unittest.mock import patch
+
+import pytest
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import transformers
+from packaging.version import Version
+from transformers import AutoConfig, AutoModelForCausalLM
+from transformers.testing_utils import torch_device
+from transformers.utils import is_peft_available
+
+from trl import ModelConfig
+from trl.trainer.utils import (
+    RepeatSampler,
+    _ChunkedLogProbFunction,
+    adjusted_mfu,
+    compute_flops_per_token,
+    compute_mfu,
+    entropy_from_logits,
+    flush_left,
+    generate_model_card,
+    get_peft_config,
+    hash_module,
+    nanstd,
+    pad,
+    patch_chunked_lm_head,
+    print_prompt_completions_sample,
+    selective_log_softmax,
+    shuffle_sequence_dict,
+    split_pixel_values_by_grid,
+    split_tensor_dict,
+    unsplit_pixel_values_by_grid,
+    use_adapter,
+)
+
+from .testing_utils import TrlTestCase, require_peft, require_rich, require_torch_accelerator
+
+
+if is_peft_available():
+    from peft import AutoPeftModelForCausalLM, LoraConfig
+
+
+@require_peft
+class TestUseAdapter(TrlTestCase):
+    def test_disables_on_none(self):
+        model = AutoPeftModelForCausalLM.from_pretrained(
+            "trl-internal-testing/tiny-PeftModel", adapter_name="my_adapter"
+        )
+        input_ids = torch.tensor([[1, 2, 3], [4, 5, 6]])
+        with model.disable_adapter():
+            expected = model(input_ids).logits
+
+        with use_adapter(model, None):
+            output = model(input_ids).logits
+
+        assert torch.equal(output, expected)
+
+    def test_restores_previous_adapter(self):
+        model = AutoPeftModelForCausalLM.from_pretrained(
+            "trl-internal-testing/tiny-PeftModel", adapter_name="my_adapter"
+        )
+        input_ids = torch.tensor([[1, 2, 3], [4, 5, 6]])
+        expected = model(input_ids).logits
+        with use_adapter(model, "my_adapter"):
+            pass
+        output = model(input_ids).logits
+        assert torch.equal(output, expected)
+
+        with use_adapter(model, None):
+            pass
+        output = model(input_ids).logits
+        assert torch.equal(output, expected)
+
+    def test_with_multiple_adapters(self):
+        model = AutoPeftModelForCausalLM.from_pretrained(
+            "trl-internal-testing/tiny-PeftModel", adapter_name="my_adapter_1"
+        )
+        model.load_adapter("trl-internal-testing/tiny-PeftModel-2", "my_adapter_2")
+        input_ids = torch.tensor([[1, 2, 3], [4, 5, 6]])
+
+        model.set_adapter("my_adapter_1")  # should be a no-op, but let's keep it for clarity
+        expected_1 = model(input_ids).logits
+        model.set_adapter("my_adapter_2")
+        expected_2 = model(input_ids).logits
+
+        with use_adapter(model, "my_adapter_1"):
+            output_1 = model(input_ids).logits
+
+        with use_adapter(model, "my_adapter_2"):
+            output_2 = model(input_ids).logits
+
+        assert torch.equal(output_1, expected_1)
+        assert torch.equal(output_2, expected_2)
+
+
+class TestPad(TrlTestCase):
+    def test_pad_1_dim_left(self):
+        x = torch.tensor([1, 2, 3])
+        y = torch.tensor([4, 5])
+        output = pad((x, y), padding_value=0, padding_side="left")
+        expected = torch.tensor([[1, 2, 3], [0, 4, 5]])
+        assert torch.equal(output, expected)
+
+    def test_pad_1_dim_right(self):
+        x = torch.tensor([1, 2, 3])
+        y = torch.tensor([4, 5])
+        output = pad((x, y), padding_value=0, padding_side="right")
+        expected = torch.tensor([[1, 2, 3], [4, 5, 0]])
+        assert torch.equal(output, expected)
+
+    def test_pad_2_dim_left(self):
+        x = torch.tensor([[1, 2], [3, 4]])
+        y = torch.tensor([[5, 6]])
+        output = pad((x, y), padding_value=0, padding_side="left")
+        expected = torch.tensor(
+            [
+                [[1, 2], [3, 4]],
+                [[0, 0], [5, 6]],
+            ]
+        )
+        assert torch.equal(output, expected)
+
+    def test_pad_2_dim_right(self):
+        x = torch.tensor([[1, 2], [3, 4]])
+        y = torch.tensor([[5, 6]])
+        output = pad((x, y), padding_value=0, padding_side="right")
+        expected = torch.tensor(
+            [
+                [[1, 2], [3, 4]],
+                [[5, 6], [0, 0]],
+            ]
+        )
+        assert torch.equal(output, expected)
+
+    def test_pad_2_dim_right_multidim(self):
+        x = torch.tensor([[1, 2], [3, 4]])
+        y = torch.tensor([[5]])
+        output = pad((x, y), padding_value=0, padding_side="right")
+        expected = torch.tensor(
+            [
+                [[1, 2], [3, 4]],
+                [[5, 0], [0, 0]],
+            ]
+        )
+        assert torch.equal(output, expected)
+
+    def test_pad_to_multiple_of_1(self):
+        x = torch.tensor([1, 2, 3])
+        y = torch.tensor([4, 5])
+        # Max length is 3, pad to multiple of 4
+        output = pad((x, y), padding_value=0, padding_side="right", pad_to_multiple_of=4)
+        expected = torch.tensor([[1, 2, 3, 0], [4, 5, 0, 0]])
+        assert torch.equal(output, expected)
+
+    def test_pad_to_multiple_of_2(self):
+        x = torch.tensor([1, 2, 3, 4, 5])
+        y = torch.tensor([6, 7, 8])
+        # Max length is 3, pad to multiple of 4
+        output = pad((x, y), padding_value=0, padding_side="right", pad_to_multiple_of=4)
+        expected = torch.tensor([[1, 2, 3, 4, 5, 0, 0, 0], [6, 7, 8, 0, 0, 0, 0, 0]])
+        assert torch.equal(output, expected)
+
+    def test_pad_to_multiple_of_side_left(self):
+        x = torch.tensor([1, 2, 3, 4, 5])
+        y = torch.tensor([6, 7, 8])
+        # Max length is 3, pad to multiple of 4
+        output = pad((x, y), padding_value=0, padding_side="left", pad_to_multiple_of=4)
+        expected = torch.tensor([[0, 0, 0, 1, 2, 3, 4, 5], [0, 0, 0, 0, 0, 6, 7, 8]])
+        assert torch.equal(output, expected)
+
+    def test_pad_to_multiple_of_no_extra_padding(self):
+        x = torch.tensor([1, 2, 3, 4])
+        y = torch.tensor([5, 6, 7, 8])
+        # Already multiple of 4
+        output = pad((x, y), padding_value=0, padding_side="left", pad_to_multiple_of=4)
+        expected = torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]])
+        assert torch.equal(output, expected)
+
+
+class TestHashModule(TrlTestCase):
+    def test_hash_module_deterministic_across_order(self):
+        class ModAB(torch.nn.Module):
+            def __init__(self, a: torch.Tensor, b: torch.Tensor):
+                super().__init__()
+                self.a = torch.nn.Parameter(a)
+                self.b = torch.nn.Parameter(b)
+
+        class ModBA(torch.nn.Module):
+            def __init__(self, a: torch.Tensor, b: torch.Tensor):
+                super().__init__()
+                self.b = torch.nn.Parameter(b)
+                self.a = torch.nn.Parameter(a)
+
+        a = torch.tensor([[1.0, 2.0]])
+        b = torch.tensor([3.0])
+        assert hash_module(ModAB(a, b)) == hash_module(ModBA(a, b))
+
+    def test_hash_module_changes_with_value(self):
+        class Mod(torch.nn.Module):
+            def __init__(self, value: float):
+                super().__init__()
+                self.weight = torch.nn.Parameter(torch.tensor([value, 2.0]))
+
+        assert hash_module(Mod(1.0)) != hash_module(Mod(1.5))
+
+    def test_hash_module_includes_dtype(self):
+        class Mod(torch.nn.Module):
+            def __init__(self, dtype: torch.dtype):
+                super().__init__()
+                self.weight = torch.nn.Parameter(torch.tensor([1.0, 2.0], dtype=dtype))
+
+        assert hash_module(Mod(torch.float32)) != hash_module(Mod(torch.float16))
+
+    def test_hash_module_tiny_model_twice(self):
+        model_id = "trl-internal-testing/tiny-GptOssForCausalLM"
+        model_a = AutoModelForCausalLM.from_pretrained(model_id)
+        model_b = AutoModelForCausalLM.from_pretrained(model_id)
+        assert hash_module(model_a) == hash_module(model_b)
+
+    def test_hash_module_tiny_model_change_layer(self):
+        model_id = "trl-internal-testing/tiny-GptOssForCausalLM"
+        model = AutoModelForCausalLM.from_pretrained(model_id)
+        h1 = hash_module(model)
+        with torch.no_grad():
+            model.lm_head.weight.add_(0.01)
+        h2 = hash_module(model)
+        assert h1 != h2
+
+
+@require_peft
+class TestGetPEFTConfig(TrlTestCase):
+    def test_create_peft_config_use_peft_false(self):
+        """Test that when use_peft is False, the function returns None."""
+        model_args = ModelConfig(use_peft=False)
+        peft_config = get_peft_config(model_args)
+        assert peft_config is None
+
+    def test_create_peft_config_use_peft_true(self):
+        """Test that when use_peft is True, the function returns a LoraConfig object."""
+        # Provide non-default values to the model config for testing
+        peft_kwargs = {
+            "lora_r": 8,
+            "lora_alpha": 16,
+            "lora_dropout": 0.1,
+            "lora_task_type": "SEQ_CLS",
+            "use_rslora": True,
+            "lora_target_modules": ["up_proj", "down_proj"],
+            "lora_modules_to_save": ["up_proj"],
+        }
+        model_args = ModelConfig(use_peft=True, **peft_kwargs)
+        peft_config = get_peft_config(model_args)
+        assert isinstance(peft_config, LoraConfig)
+        for arg, value in peft_kwargs.items():
+            # Test that lists of modules are converted to sets
+            if arg == "lora_target_modules":
+                value = set(value)
+            # Rename the argument to match the LoraConfig attribute name
+            if arg in ["lora_r", "lora_task_type", "lora_target_modules", "lora_modules_to_save"]:
+                arg = arg[len("lora_") :] if arg.startswith("lora_") else arg
+
+            assert getattr(peft_config, arg) == value
+
+
+class TestNanStd(TrlTestCase):
+    def test_nanstd_ignores_nans(self):
+        x = torch.tensor([1.0, 2.0, 3.0, float("nan")])
+        result = nanstd(x)
+        torch.testing.assert_close(result, torch.tensor(1.0))
+
+    def test_nanstd_dim_and_keepdim(self):
+        x = torch.tensor([[1.0, float("nan")], [3.0, 5.0]])
+        result = nanstd(x, dim=1, keepdim=True)
+        assert torch.isnan(result[0, 0])
+        torch.testing.assert_close(result[1, 0], torch.tensor(1.4142135), rtol=1e-5, atol=1e-6)
+
+    def test_nanstd_all_nan(self):
+        x = torch.tensor([float("nan"), float("nan")])
+        result = nanstd(x)
+        assert torch.isnan(result)
+
+
+class TestGenerateModelCard(TrlTestCase):
+    def test_full(self):
+        model_card = generate_model_card(
+            base_model="username/my_base_model",
+            model_name="my_model",
+            hub_model_id="username/my_hub_model",
+            dataset_name="username/my_dataset",
+            tags=["trl", "trainer-tag"],
+            wandb_url="https://wandb.ai/username/project_id/runs/abcd1234",
+            trackio_url="https://huggingface.co/spaces/username/space_id",
+            comet_url="https://www.comet.com/username/project_id/experiment_id",
+            trainer_name="My Trainer",
+            trainer_citation="@article{my_trainer, ...}",
+            paper_title="My Paper",
+            paper_id="1234.56789",
+        )
+        card_text = str(model_card)
+        assert "[username/my_base_model](https://huggingface.co/username/my_base_model)" in card_text
+        assert "my_model" in card_text
+        assert 'pipeline("text-generation", model="username/my_hub_model", device="cuda")' in card_text
+        assert "datasets: username/my_dataset" in card_text
+        assert "](https://wandb.ai/username/project_id/runs/abcd1234)" in card_text
+        assert "](https://huggingface.co/spaces/username/space_id)" in card_text
+        assert "](https://www.comet.com/username/project_id/experiment_id" in card_text
+        assert "My Trainer" in card_text
+        assert "```bibtex\n@article{my_trainer, ...}\n```" in card_text
+        assert "[My Paper](https://huggingface.co/papers/1234.56789)" in card_text
+
+    def test_val_none(self):
+        model_card = generate_model_card(
+            base_model=None,
+            model_name="my_model",
+            hub_model_id="username/my_hub_model",
+            dataset_name=None,
+            tags=[],
+            wandb_url=None,
+            trackio_url=None,
+            comet_url=None,
+            trainer_name="My Trainer",
+            trainer_citation=None,
+            paper_title=None,
+            paper_id=None,
+        )
+        card_text = str(model_card)
+        assert "my_model" in card_text
+        assert 'pipeline("text-generation", model="username/my_hub_model", device="cuda")' in card_text
+        assert "My Trainer" in card_text
+
+
+class TestFlushLeft(TrlTestCase):
+    def test_basic_case(self):
+        mask = torch.tensor([[0, 0, 1, 1, 1], [0, 1, 1, 0, 0]])
+        tensor1 = torch.tensor([[0, 0, 2, 3, 4], [0, 5, 6, 0, 0]])
+        tensor2 = torch.tensor([[0, 0, 7, 8, 9], [0, 10, 11, 0, 0]])
+        new_mask, new_tensor1, new_tensor2 = flush_left(mask, tensor1, tensor2)
+
+        expected_mask = torch.tensor([[1, 1, 1], [1, 1, 0]])
+        expected_tensor1 = torch.tensor([[2, 3, 4], [5, 6, 0]])
+        expected_tensor2 = torch.tensor([[7, 8, 9], [10, 11, 0]])
+
+        assert torch.equal(new_mask, expected_mask)
+        assert torch.equal(new_tensor1, expected_tensor1)
+        assert torch.equal(new_tensor2, expected_tensor2)
+
+    def test_single_row(self):
+        mask = torch.tensor([[0, 0, 1, 1]])
+        tensor1 = torch.tensor([[0, 0, 2, 3]])
+        new_mask, new_tensor1 = flush_left(mask, tensor1)
+
+        expected_mask = torch.tensor([[1, 1]])
+        expected_tensor1 = torch.tensor([[2, 3]])
+
+        assert torch.equal(new_mask, expected_mask)
+        assert torch.equal(new_tensor1, expected_tensor1)
+
+    def test_no_shift_needed(self):
+        mask = torch.tensor([[1, 1, 0, 0], [1, 0, 0, 0]])
+        tensor1 = torch.tensor([[5, 6, 0, 0], [7, 0, 0, 0]])
+        new_mask, new_tensor1 = flush_left(mask, tensor1)
+
+        expected_mask = torch.tensor([[1, 1], [1, 0]])
+        expected_tensor1 = torch.tensor([[5, 6], [7, 0]])
+
+        assert torch.equal(new_mask, expected_mask)
+        assert torch.equal(new_tensor1, expected_tensor1)
+
+    def test_no_tensors(self):
+        mask = torch.tensor([[0, 0, 1, 1, 1], [0, 1, 1, 0, 0]])
+        new_mask = flush_left(mask)
+        expected_mask = torch.tensor([[1, 1, 1], [1, 1, 0]])
+        assert torch.equal(new_mask, expected_mask)
+
+
+class TestRepeatRandomSampler(TrlTestCase):
+    def test_sampler(self):
+        dataset = ["a", "b", "c", "d", "e", "f", "g"]
+        sampler = RepeatSampler(dataset, mini_repeat_count=2)
+        # Should output something like [4, 4, 3, 3, 0, 0, 1, 1, 2, 2, 6, 6, 5, 5]
+        sampled = list(sampler)
+        # Check that the length is doubled
+        assert len(sampled) == 2 * len(dataset)
+        # Check that all indexes are present
+        assert set(sampled) == set(range(len(dataset)))
+        # Check that each element is repeated twice
+        assert all(sampled[i] == sampled[i + 1] for i in range(0, len(sampled), 2))
+
+    def test_sampler_no_shuffle(self):
+        dataset = ["a", "b", "c", "d", "e", "f", "g"]
+        sampler = RepeatSampler(dataset, mini_repeat_count=2, shuffle=False)
+        sampled = list(sampler)
+        expected = [0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6]
+        assert sampled == expected
+
+    def test_sampler_no_repeat(self):
+        dataset = ["a", "b", "c", "d", "e", "f", "g"]
+        sampler = RepeatSampler(dataset, mini_repeat_count=1)
+        # Should output something like [4, 3, 0, 1, 2, 6, 5]
+        sampled = list(sampler)
+        # Check that the length is the same
+        assert len(sampled) == len(dataset)
+        # Check that all indexes are present
+        assert set(sampled) == set(range(len(dataset)))
+
+    def test_sampler_with_batch_size(self):
+        dataset = ["a", "b", "c", "d", "e", "f", "g", "h"]
+        sampler = RepeatSampler(dataset, mini_repeat_count=1, batch_size=2, repeat_count=2)
+        # Should output something like [4, 3, 4, 3, 0, 1, 0, 1, 2, 6, 2, 6, 5, 7, 5, 7]
+        sampled = list(sampler)
+        # Check that the length is doubled
+        assert len(sampled) == 2 * len(dataset)
+        # Check that all indexes are present
+        assert set(sampled) == set(range(len(dataset)))
+        # Check that each element is repeated as expected
+        assert all(sampled[i : i + 1] == sampled[i + 2 : i + 3] for i in range(0, len(sampled), 4))
+
+    def test_sampler_with_batch_size_and_drop(self):
+        dataset = ["a", "b", "c", "d", "e", "f", "g"]
+        sampler = RepeatSampler(dataset, mini_repeat_count=1, batch_size=2, repeat_count=2)
+        # Should output something like [4, 3, 4, 3, 0, 1, 0, 1, 2, 6, 2, 6]
+        sampled = list(sampler)
+        # Check that the length is doubled
+        assert len(sampled) == 2 * (
+            len(dataset) - 1
+        )  # one element is dropped, because it's not enough to form a batch
+        assert len(sampler) == len(sampled)  # the length should be the same as the sampled length
+        # Check that the sampled indexes are a subset of the dataset indexes
+        assert set(sampled).issubset(set(range(len(dataset))))
+        # Check that each element is repeated as expected
+        assert all(sampled[i : i + 1] == sampled[i + 2 : i + 3] for i in range(0, len(sampled), 4))
+
+    def test_sampler_with_mini_repeat_count_and_batch_size_1(self):
+        dataset = ["a", "b", "c", "d", "e", "f", "g"]
+        sampler = RepeatSampler(dataset, mini_repeat_count=2, batch_size=3, repeat_count=2)
+        # Should output something like [4, 4, 3, 3, 0, 0, 4, 4, 3, 3, 0, 0,
+        #                               1, 1, 2, 2, 6, 6, 1, 1, 2, 2, 6, 6]
+        sampled = list(sampler)
+        # Check that the length is quadrupled
+        assert len(sampled) == 4 * (len(dataset) - 1)  # 1 element is dropped, because it's not enough to form a batch
+        assert len(sampler) == len(sampled)  # the length should be the same as the sampled length
+        # Check that the sampled indexes are a subset of the dataset indexes
+        assert set(sampled).issubset(set(range(len(dataset))))
+        # Check that each element is repeated as expected
+        assert all(sampled[i] == sampled[i + 1] for i in range(0, len(sampled), 2))
+        # Check that the batch is repeated as expected
+        assert sampled[0:6] == sampled[6:12]
+        assert sampled[12:18] == sampled[18:24]
+
+    def test_sampler_with_mini_repeat_count_and_batch_size_2(self):
+        dataset = ["a", "b", "c", "d", "e", "f", "g"]
+        sampler = RepeatSampler(dataset, mini_repeat_count=3, batch_size=2, repeat_count=2)
+        # Should output something like [4, 4, 4, 3, 3, 3, 4, 4, 4, 3, 3, 3,
+        #                               0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,
+        #                               2, 2, 2, 6, 6, 6, 2, 2, 2, 6, 6, 6]
+        sampled = list(sampler)
+        # Check that the length is sextupled
+        assert len(sampled) == 6 * (len(dataset) - 1)  # 1 element is dropped, because it's not enough to form a batch
+        assert len(sampler) == len(sampled)  # the length should be the same as the sampled length
+        # Check that the sampled indexes are a subset of the dataset indexes
+        assert set(sampled).issubset(set(range(len(dataset))))
+        # Check that each element is repeated as expected
+        assert all(sampled[i] == sampled[i + 1] == sampled[i + 2] for i in range(0, len(sampled), 3))
+        # Check that the batch is repeated as expected
+        assert sampled[0:6] == sampled[6:12]
+        assert sampled[12:18] == sampled[18:24]
+        assert sampled[24:30] == sampled[30:36]
+
+    def test_sampler_with_mini_repeat_count_and_batch_size_3(self):
+        dataset = ["a", "b", "c", "d", "e", "f", "g"]
+        sampler = RepeatSampler(dataset, mini_repeat_count=2, batch_size=2, repeat_count=3)
+        # Should output something like [4, 4, 3, 3, 4, 4, 3, 3, 4, 4, 3, 3,
+        #                               0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1,
+        #                               2, 2, 6, 6, 2, 2, 6, 6, 2, 2, 6, 6]
+        sampled = list(sampler)
+        # Check that the length is sextupled
+        assert len(sampled) == 6 * (len(dataset) - 1)  # 1 element is dropped, because it's not enough to form a batch
+        # Check that the sampled indexes are a subset of the dataset indexes
+        assert set(sampled).issubset(set(range(len(dataset))))
+        # Check that each element is repeated as expected
+        assert all(sampled[i] == sampled[i + 1] for i in range(0, len(sampled), 2))
+        # Check that the batch is repeated as expected
+        assert sampled[0:4] == sampled[4:8] == sampled[8:12]
+        assert sampled[12:16] == sampled[16:20] == sampled[20:24]
+        assert sampled[24:28] == sampled[28:32] == sampled[32:36]
+
+
+class TestEntropyFromLogits(TrlTestCase):
+    @pytest.mark.parametrize("shape", [(768,), (32, 768), (8, 16, 768), (2, 4, 8, 768)])
+    @pytest.mark.parametrize("chunk_size", [1, 16])
+    @pytest.mark.parametrize("dtype", [torch.float64, torch.float32, torch.float16, torch.bfloat16])
+    def test_entropy_from_logits_2_dims(self, dtype, chunk_size, shape):
+        logits = torch.randn(*shape, dtype=dtype)
+        if dtype in (torch.float64, torch.float32):
+            p = logits.softmax(-1)
+            entropy = -torch.sum(p * p.log(), dim=-1)
+        else:
+            logps = logits.log_softmax(dim=-1)
+            entropy = -(torch.exp(logps) * logps).sum(-1)
+        predicted_entropy = entropy_from_logits(logits, chunk_size=chunk_size)
+        torch.testing.assert_close(predicted_entropy, entropy, rtol=1e-5, atol=1e-5)
+
+
+@require_rich
+class TestPrintPromptCompletionsSample(TrlTestCase):
+    @patch("sys.stdout", new_callable=StringIO)
+    def test_print_output(self, mock_stdout):
+        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]
+        step = 42
+
+        print_prompt_completions_sample(prompts, completions, rewards, advantages, step)
+
+        output = mock_stdout.getvalue()
+
+        # docstyle-ignore
+        expected_output = textwrap.dedent("""\
+        ╭──────────────────────────── Step 42 ─────────────────────────────╮
+        │ ┏━━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━┓ │
+        │ ┃ Prompt     ┃ Completion   ┃ Correctness ┃ Format ┃ Advantage ┃ │
+        │ ┡━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━┩ │
+        │ │ The sky is │  blue.       │        0.12 │   0.79 │      0.99 │ │
+        │ ├────────────┼──────────────┼─────────────┼────────┼───────────┤ │
+        │ │ The sun is │  in the sky. │        0.46 │   0.10 │      0.65 │ │
+        │ └────────────┴──────────────┴─────────────┴────────┴───────────┘ │
+        ╰──────────────────────────────────────────────────────────────────╯
+        """)
+
+        assert output == expected_output
+
+    @patch("sys.stdout", new_callable=StringIO)
+    def test_extra_columns(self, mock_stdout):
+        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"]}
+        step = 42
+
+        print_prompt_completions_sample(prompts, completions, rewards, advantages, step, extra=extra)
+
+        output = mock_stdout.getvalue()
+
+        # docstyle-ignore
+        expected_output = textwrap.dedent("""\
+        ╭────────────────────────────────── 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 │ │
+        │ └────────────┴──────────────┴─────────────┴────────┴───────────┴───────────┘ │
+        ╰──────────────────────────────────────────────────────────────────────────────╯
+        """)
+
+        assert output == expected_output
+
+    @patch("sys.stdout", new_callable=StringIO)
+    def test_num_samples(self, mock_stdout):
+        prompts = ["A", "B"]
+        completions = ["1", "2"]
+        rewards = {"Score": [0.1, 0.2]}
+        advantages = [0.3, 0.4]
+        step = 10
+
+        print_prompt_completions_sample(prompts, completions, rewards, advantages, step, num_samples=1)
+        output = mock_stdout.getvalue()
+
+        # docstyle-ignore
+        possible_outputs = [
+            textwrap.dedent("""\
+            ╭────────────────── Step 10 ──────────────────╮
+            │ ┏━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━┓ │
+            │ ┃ Prompt ┃ Completion ┃ Score ┃ Advantage ┃ │
+            │ ┡━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━┩ │
+            │ │ A      │ 1          │  0.10 │      0.30 │ │
+            │ └────────┴────────────┴───────┴───────────┘ │
+            ╰─────────────────────────────────────────────╯
+                """),
+            # docstyle-ignore
+            textwrap.dedent("""\
+            ╭────────────────── Step 10 ──────────────────╮
+            │ ┏━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━┓ │
+            │ ┃ Prompt ┃ Completion ┃ Score ┃ Advantage ┃ │
+            │ ┡━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━┩ │
+            │ │ B      │ 2          │  0.20 │      0.40 │ │
+            │ └────────┴────────────┴───────┴───────────┘ │
+            ╰─────────────────────────────────────────────╯
+                """),
+        ]
+        assert output in possible_outputs
+
+    @patch("sys.stdout", new_callable=StringIO)
+    def test_print_messages(self, mock_stdout):
+        prompts = [
+            [
+                {"role": "system", "content": "You are an helpful assistant."},
+                {"role": "user", "content": "What color is the sky?"},
+            ],
+            [
+                {"role": "system", "content": "You are an helpful assistant."},
+                {"role": "user", "content": "Where is the sun?"},
+            ],
+        ]
+        completions = [
+            [{"role": "assistant", "content": "It is blue."}],
+            [{"role": "assistant", "content": "In the sky."}],
+        ]
+        rewards = {"Correctness": [0.123, 0.456], "Format": [0.789, 0.101]}
+        advantages = [0.987, 0.654]
+        step = 42
+
+        print_prompt_completions_sample(prompts, completions, rewards, advantages, step)
+
+        output = mock_stdout.getvalue()
+
+        # docstyle-ignore
+        expected_output = textwrap.dedent("""\
+        ╭────────────────────────────────── Step 42 ───────────────────────────────────╮
+        │ ┏━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━┓ │
+        │ ┃ Prompt                  ┃ Completion  ┃ Correctness ┃ Format ┃ Advantage ┃ │
+        │ ┡━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━┩ │
+        │ │ SYSTEM                  │ ASSISTANT   │        0.12 │   0.79 │      0.99 │ │
+        │ │ You are an helpful      │ It is blue. │             │        │           │ │
+        │ │ assistant.              │             │             │        │           │ │
+        │ │                         │             │             │        │           │ │
+        │ │ USER                    │             │             │        │           │ │
+        │ │ What color is the sky?  │             │             │        │           │ │
+        │ ├─────────────────────────┼─────────────┼─────────────┼────────┼───────────┤ │
+        │ │ SYSTEM                  │ ASSISTANT   │        0.46 │   0.10 │      0.65 │ │
+        │ │ You are an helpful      │ In the sky. │             │        │           │ │
+        │ │ assistant.              │             │             │        │           │ │
+        │ │                         │             │             │        │           │ │
+        │ │ USER                    │             │             │        │           │ │
+        │ │ Where is the sun?       │             │             │        │           │ │
+        │ └─────────────────────────┴─────────────┴─────────────┴────────┴───────────┘ │
+        ╰──────────────────────────────────────────────────────────────────────────────╯
+        """)
+
+        assert output == expected_output
+
+    @patch("sys.stdout", new_callable=StringIO)
+    def test_print_messages_with_tools(self, mock_stdout):
+        prompts = [
+            [{"role": "user", "content": "What is the temperature in Paris?"}],
+            [{"role": "user", "content": "What is the weather in London?"}],
+        ]
+        completions = [
+            [{"role": "tool", "name": "get_temperature", "args": {"location": "Paris"}}],
+            [{"role": "tool", "name": "get_weather", "args": {"location": "London"}}],
+        ]
+        rewards = {"Correctness": [0.123, 0.456], "Format": [0.789, 0.101]}
+        advantages = [0.987, 0.654]
+        step = 42
+
+        print_prompt_completions_sample(prompts, completions, rewards, advantages, step)
+
+        output = mock_stdout.getvalue()
+
+        # docstyle-ignore
+        expected_output = textwrap.dedent("""\
+        ╭────────────────────────────────── Step 42 ───────────────────────────────────╮
+        │ ┏━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━┓ │
+        │ ┃ Prompt            ┃ Completion        ┃ Correctness ┃ Format ┃ Advantage ┃ │
+        │ ┡━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━┩ │
+        │ │ USER              │ TOOL              │        0.12 │   0.79 │      0.99 │ │
+        │ │ What is the       │ get_temperature(… │             │        │           │ │
+        │ │ temperature in    │ 'Paris'})         │             │        │           │ │
+        │ │ Paris?            │                   │             │        │           │ │
+        │ ├───────────────────┼───────────────────┼─────────────┼────────┼───────────┤ │
+        │ │ USER              │ TOOL              │        0.46 │   0.10 │      0.65 │ │
+        │ │ What is the       │ get_weather({'lo… │             │        │           │ │
+        │ │ weather in        │ 'London'})        │             │        │           │ │
+        │ │ London?           │                   │             │        │           │ │
+        │ └───────────────────┴───────────────────┴─────────────┴────────┴───────────┘ │
+        ╰──────────────────────────────────────────────────────────────────────────────╯
+        """)
+
+        assert output == expected_output
+
+    @patch("sys.stdout", new_callable=StringIO)
+    def test_print_messages_with_reasoning_content(self, mock_stdout):
+        prompts = [[{"role": "user", "content": "What color is the sky?"}]]
+        completions = [[{"role": "assistant", "reasoning_content": "I think it is blue.", "content": "It is blue."}]]
+        rewards = {"Score": [0.5]}
+        advantages = [0.9]
+        step = 1
+
+        print_prompt_completions_sample(prompts, completions, rewards, advantages, step)
+
+        output = mock_stdout.getvalue()
+
+        # docstyle-ignore
+        expected_output = textwrap.dedent("""\
+        ╭─────────────────────────────── Step 1 ───────────────────────────────╮
+        │ ┏━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━┓ │
+        │ ┃ Prompt                 ┃ Completion          ┃ Score ┃ Advantage ┃ │
+        │ ┡━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━┩ │
+        │ │ USER                   │ ASSISTANT           │  0.50 │      0.90 │ │
+        │ │ What color is the sky? │ I think it is blue. │       │           │ │
+        │ │                        │ It is blue.         │       │           │ │
+        │ └────────────────────────┴─────────────────────┴───────┴───────────┘ │
+        ╰──────────────────────────────────────────────────────────────────────╯
+        """)
+
+        assert output == expected_output
+
+    @patch("sys.stdout", new_callable=StringIO)
+    def test_print_messages_with_thinking(self, mock_stdout):
+        prompts = [[{"role": "user", "content": "What color is the sky?"}]]
+        completions = [[{"role": "assistant", "thinking": "I think it is blue.", "content": "It is blue."}]]
+        rewards = {"Score": [0.5]}
+        advantages = [0.9]
+        step = 1
+
+        print_prompt_completions_sample(prompts, completions, rewards, advantages, step)
+
+        output = mock_stdout.getvalue()
+
+        # docstyle-ignore
+        expected_output = textwrap.dedent("""\
+        ╭─────────────────────────────── Step 1 ───────────────────────────────╮
+        │ ┏━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━┓ │
+        │ ┃ Prompt                 ┃ Completion          ┃ Score ┃ Advantage ┃ │
+        │ ┡━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━┩ │
+        │ │ USER                   │ ASSISTANT           │  0.50 │      0.90 │ │
+        │ │ What color is the sky? │ I think it is blue. │       │           │ │
+        │ │                        │ It is blue.         │       │           │ │
+        │ └────��───────────────────┴─────────────────────┴───────┴───────────┘ │
+        ╰──────────────────────────────────────────────────────────────────────╯
+        """)
+
+        assert output == expected_output
+
+
+class TestSelectiveLogSoftmax(TrlTestCase):
+    @pytest.mark.parametrize("dtype", [torch.float64, torch.float32, torch.float16, torch.bfloat16])
+    def test_selective_log_softmax(self, dtype):
+        """Test selective_log_softmax with logits of different dtypes"""
+        vocab_size = 1024
+        batch_size = 4
+        seq_len = 32
+
+        input_ids = torch.randint(low=0, high=vocab_size, size=(batch_size, seq_len))
+        logits = torch.randn(batch_size, seq_len, vocab_size, dtype=dtype)
+
+        expected_output = torch.gather(logits.log_softmax(-1), dim=-1, index=input_ids.unsqueeze(-1)).squeeze(-1)
+        actual_output = selective_log_softmax(logits, input_ids)
+
+        if dtype in [torch.float16, torch.bfloat16]:
+            # half-precision dtypes fall back to an exact method
+            assert torch.equal(actual_output, expected_output)
+        else:
+            torch.testing.assert_close(actual_output, expected_output, rtol=1e-5, atol=1e-5)
+
+    @pytest.mark.parametrize("dtype", [torch.float64, torch.float32, torch.float16, torch.bfloat16])
+    @pytest.mark.parametrize("k", [1, 8])
+    def test_selective_log_softmax_multi_index(self, dtype, k):
+        """Test selective_log_softmax with logits of different dtypes and index widths"""
+        vocab_size = 1024
+        batch_size = 4
+        seq_len = 32
+
+        index = torch.randint(low=0, high=vocab_size, size=(batch_size, seq_len, k))
+        logits = torch.randn(batch_size, seq_len, vocab_size, dtype=dtype)
+
+        expected_output = torch.gather(logits.log_softmax(-1), dim=-1, index=index)
+        actual_output = selective_log_softmax(logits, index)
+
+        assert actual_output.shape == (batch_size, seq_len, k)
+        if dtype in [torch.float16, torch.bfloat16]:
+            # half-precision dtypes fall back to an exact method
+            assert torch.equal(actual_output, expected_output)
+        else:
+            torch.testing.assert_close(actual_output, expected_output, rtol=1e-5, atol=1e-5)
+
+
+class TestShuffleSequenceDict(TrlTestCase):
+    def test_shuffle_preserves_shape(self):
+        x = torch.arange(6).reshape(3, 2)
+        y = torch.arange(3).reshape(3, 1)
+        tensor_dict = {"x": x.clone(), "y": y.clone()}
+
+        shuffled = shuffle_sequence_dict(tensor_dict)
+
+        assert shuffled["x"].shape == x.shape
+        assert shuffled["y"].shape == y.shape
+
+    def test_shuffle_consistent_across_tensors(self):
+        # Use known patterns to check alignment
+        x = torch.tensor([[10, 11], [20, 21], [30, 31]])
+        y = torch.tensor([[1], [2], [3]])
+        tensor_dict = {"x": x.clone(), "y": y.clone()}
+
+        shuffled = shuffle_sequence_dict(tensor_dict)
+
+        # Build a reverse map from shuffled x rows to y values
+        for i in range(3):
+            x_row = shuffled["x"][i]
+            y_val = shuffled["y"][i].item()
+
+            if torch.equal(x_row, torch.tensor([10, 11])):
+                assert y_val == 1
+            elif torch.equal(x_row, torch.tensor([20, 21])):
+                assert y_val == 2
+            elif torch.equal(x_row, torch.tensor([30, 31])):
+                assert y_val == 3
+            else:
+                pytest.fail("Unexpected x row in shuffled output.")
+
+    def test_none_tensor_remains_none(self):
+        x = torch.arange(6).reshape(3, 2)
+        tensor_dict = {"x": x.clone(), "y": None}
+
+        shuffled = shuffle_sequence_dict(tensor_dict)
+
+        assert shuffled["y"] is None
+        assert shuffled["x"].shape == x.shape
+
+    def test_shuffle_with_list(self):
+        x = torch.tensor([[10, 11], [20, 21], [30, 31]])
+        y = ["a", "b", "c"]
+
+        sequence_dict = {"x": x.clone(), "y": y}
+
+        shuffled = shuffle_sequence_dict(sequence_dict)
+
+        # Check that the list y is shuffled in the same order as x
+        for i in range(3):
+            x_row = shuffled["x"][i]
+            y_val = shuffled["y"][i]
+
+            if torch.equal(x_row, torch.tensor([10, 11])):
+                assert y_val == "a"
+            elif torch.equal(x_row, torch.tensor([20, 21])):
+                assert y_val == "b"
+            elif torch.equal(x_row, torch.tensor([30, 31])):
+                assert y_val == "c"
+            else:
+                pytest.fail("Unexpected x row in shuffled output.")
+
+
+class TestSplitTensorDict(TrlTestCase):
+    def test_split_equal_chunks(self):
+        x = torch.arange(12).reshape(6, 2)
+        y = torch.arange(6).reshape(6, 1)
+        tensor_dict = {"x": x, "y": y}
+
+        result = split_tensor_dict(tensor_dict, 3)
+
+        expected_x_chunks = torch.chunk(x, 3, dim=0)
+        expected_y_chunks = torch.chunk(y, 3, dim=0)
+        assert len(result) == 3
+        for i in range(3):
+            assert torch.equal(result[i]["x"], expected_x_chunks[i])
+            assert torch.equal(result[i]["y"], expected_y_chunks[i])
+
+    def test_with_none_tensor(self):
+        x = torch.arange(12).reshape(6, 2)
+        tensor_dict = {"x": x, "y": None}
+
+        result = split_tensor_dict(tensor_dict, 2)
+
+        expected_x_chunks = torch.chunk(x, 2, dim=0)
+        assert len(result) == 2
+        for i in range(2):
+            assert torch.equal(result[i]["x"], expected_x_chunks[i])
+            assert result[i]["y"] is None
+
+    def test_with_scalar(self):
+        x = torch.arange(12).reshape(6, 2)
+        tensor_dict = {"x": x, "y": torch.tensor(1)}
+
+        result = split_tensor_dict(tensor_dict, 2)
+
+        expected_x_chunks = torch.chunk(x, 2, dim=0)
+        assert len(result) == 2
+        for i in range(2):
+            assert torch.equal(result[i]["x"], expected_x_chunks[i])
+            assert torch.equal(result[i]["y"], torch.tensor(1))
+
+
+class TestSplitPixelValuesByGrid(TrlTestCase):
+    def test_split_correctly_0(self):
+        batch = {
+            "image_grid_thw": torch.tensor([[1, 2, 2], [1, 2, 2]]),
+            "num_images": [1, 1],
+            "pixel_values": torch.arange(8 * 3).reshape(8, 3),  # Shape: [8, 3]
+        }
+        result = split_pixel_values_by_grid(batch)
+        assert isinstance(result["pixel_values"], list)
+        assert len(result["pixel_values"]) == 2
+        assert torch.equal(result["pixel_values"][0], batch["pixel_values"][:4])
+        assert torch.equal(result["pixel_values"][1], batch["pixel_values"][4:])
+        assert isinstance(result["image_grid_thw"], list)
+        assert len(result["image_grid_thw"]) == 2
+        assert torch.equal(result["image_grid_thw"][0], torch.tensor([[1, 2, 2]]))
+        assert torch.equal(result["image_grid_thw"][1], torch.tensor([[1, 2, 2]]))
+
+    def test_split_correctly_1(self):
+        batch = {
+            "image_grid_thw": torch.tensor([[1, 2, 2], [1, 2, 4]]),
+            "num_images": [1, 1],
+            "pixel_values": torch.arange(12 * 3).reshape(12, 3),  # Shape: [12, 3]
+        }
+        result = split_pixel_values_by_grid(batch)
+        assert isinstance(result["pixel_values"], list)
+        assert len(result["pixel_values"]) == 2
+        assert torch.equal(result["pixel_values"][0], batch["pixel_values"][:4])
+        assert torch.equal(result["pixel_values"][1], batch["pixel_values"][4:12])
+        assert isinstance(result["image_grid_thw"], list)
+        assert len(result["image_grid_thw"]) == 2
+        assert torch.equal(result["image_grid_thw"][0], torch.tensor([[1, 2, 2]]))
+        assert torch.equal(result["image_grid_thw"][1], torch.tensor([[1, 2, 4]]))
+
+    def test_missing_keys(self):
+        batch = {"pixel_values": torch.tensor([1.0])}
+        result = split_pixel_values_by_grid(batch)
+        assert result == batch
+
+    def test_mismatched_length(self):
+        batch = {
+            "image_grid_thw": torch.tensor([[1, 1, 2], [1, 2, 1]]),  # Total = 8
+            "num_images": [1, 1],
+            "pixel_values": torch.randn(3, 5),  # Only 3 rows
+        }
+        with pytest.raises(ValueError):
+            split_pixel_values_by_grid(batch)
+
+    def test_multi_images(self):
+        batch = {
+            "image_grid_thw": torch.tensor([[1, 1, 2], [1, 2, 2], [1, 2, 1]]),  # Total = 8
+            "num_images": [1, 2],
+            "pixel_values": torch.arange(8 * 3).reshape(8, 3),  # Shape: [8, 3]
+        }
+        result = split_pixel_values_by_grid(batch)
+        assert isinstance(result["pixel_values"], list)
+        assert len(result["pixel_values"]) == 2
+        assert torch.equal(result["pixel_values"][0], batch["pixel_values"][:2])
+        assert torch.equal(result["pixel_values"][1], batch["pixel_values"][2:])
+        assert isinstance(result["image_grid_thw"], list)
+        assert len(result["image_grid_thw"]) == 2
+        assert torch.equal(result["image_grid_thw"][0], torch.tensor([[1, 1, 2]]))
+        assert torch.equal(result["image_grid_thw"][1], torch.tensor([[1, 2, 2], [1, 2, 1]]))
+
+    def test_split_by_image_position_ids(self):
+        # Gemma-style: no image_grid_thw, split by num_images using image_position_ids
+        batch = {
+            "num_images": [1, 2],
+            "pixel_values": torch.arange(3 * 4).reshape(3, 4),
+            "image_position_ids": torch.tensor([[0, 1], [2, 3], [4, 5]]),
+        }
+        result = split_pixel_values_by_grid(batch)
+        assert isinstance(result["pixel_values"], list)
+        assert len(result["pixel_values"]) == 2
+        assert torch.equal(result["pixel_values"][0], batch["pixel_values"][:1])
+        assert torch.equal(result["pixel_values"][1], batch["pixel_values"][1:])
+        assert isinstance(result["image_position_ids"], list)
+        assert len(result["image_position_ids"]) == 2
+        assert torch.equal(result["image_position_ids"][0], batch["image_position_ids"][:1])
+        assert torch.equal(result["image_position_ids"][1], batch["image_position_ids"][1:])
+
+
+class TestUnsplitPixelValuesByGrid(TrlTestCase):
+    def test_unsplit_correctly(self):
+        pixel_values = [torch.randn(4, 5), torch.randn(2, 5)]
+        pixel_values_merged = torch.cat(pixel_values, dim=0)
+        image_grid_thw = [torch.tensor([[1, 2, 2]]), torch.tensor([[1, 2, 1]])]
+        image_grid_thw_merged = torch.cat(image_grid_thw, dim=0)
+        batch = {"pixel_values": pixel_values, "image_grid_thw": image_grid_thw, "other_key": torch.tensor([1])}
+        result = unsplit_pixel_values_by_grid(batch)
+        assert isinstance(result["pixel_values"], torch.Tensor)
+        torch.testing.assert_close(result["pixel_values"], pixel_values_merged)
+        assert isinstance(result["image_grid_thw"], torch.Tensor)
+        assert torch.equal(result["image_grid_thw"], image_grid_thw_merged)
+        assert "other_key" in result
+
+    def test_unsplit_image_position_ids(self):
+        image_position_ids = [torch.tensor([[0, 1]]), torch.tensor([[2, 3], [4, 5]])]
+        image_position_ids_merged = torch.cat(image_position_ids, dim=0)
+        pixel_values = [torch.randn(1, 4), torch.randn(2, 4)]
+        batch = {"pixel_values": pixel_values, "image_position_ids": image_position_ids}
+        result = unsplit_pixel_values_by_grid(batch)
+        assert isinstance(result["image_position_ids"], torch.Tensor)
+        assert torch.equal(result["image_position_ids"], image_position_ids_merged)
+
+    def test_no_op_if_not_list(self):
+        original = torch.randn(5, 3)
+        batch = {"pixel_values": original}
+        result = unsplit_pixel_values_by_grid(batch)
+        assert torch.equal(result["pixel_values"], original)
+
+
+class TestChunkedLogProbFunction:
+    N, H, V = 64, 32, 128
+    CHUNK_SIZE = 32
+
+    def _reference_logprobs_and_entropy(self, hidden, weight, labels, temperature):
+        logits = (hidden @ weight.t()).to(torch.float32) / temperature  # [N, V]
+        log_p = F.log_softmax(logits, dim=-1)
+        logprobs = log_p.gather(-1, labels.unsqueeze(-1)).squeeze(-1)
+        p = torch.softmax(logits, dim=-1)
+        entropy = -(p * log_p).sum(dim=-1)
+        return logprobs, entropy
+
+    @pytest.mark.parametrize("temperature", [1.0, 0.7])
+    def test_forward(self, temperature):
+        torch.manual_seed(42)
+        hidden = torch.randn(self.N, self.H)
+        weight = torch.randn(self.V, self.H)
+        labels = torch.randint(0, self.V, (self.N,))
+
+        logprobs_chunked, entropy_chunked = _ChunkedLogProbFunction.apply(
+            hidden, weight, labels, temperature, self.CHUNK_SIZE
+        )
+        logprobs_ref, entropy_ref = self._reference_logprobs_and_entropy(hidden, weight, labels, temperature)
+
+        torch.testing.assert_close(logprobs_chunked, logprobs_ref, atol=1e-5, rtol=1e-5)
+        torch.testing.assert_close(entropy_chunked, entropy_ref, atol=1e-5, rtol=1e-5)
+
+    @pytest.mark.parametrize("temperature", [1.0, 0.7])
+    def test_backward(self, temperature):
+        torch.manual_seed(42)
+        hidden = torch.randn(self.N, self.H, requires_grad=True)
+        weight = torch.randn(self.V, self.H, requires_grad=True)
+        labels = torch.randint(0, self.V, (self.N,))
+
+        # Chunked backward
+        logprobs_chunked, _ = _ChunkedLogProbFunction.apply(hidden, weight, labels, temperature, self.CHUNK_SIZE)
+        logprobs_chunked.sum().backward()
+        grad_hidden_chunked = hidden.grad.clone()
+        grad_weight_chunked = weight.grad.clone()
+
+        hidden.grad = None
+        weight.grad = None
+
+        # Reference backward
+        logprobs_ref, _ = self._reference_logprobs_and_entropy(hidden, weight, labels, temperature)
+        logprobs_ref.sum().backward()
+
+        torch.testing.assert_close(grad_hidden_chunked, hidden.grad, atol=1e-5, rtol=1e-5)
+        torch.testing.assert_close(grad_weight_chunked, weight.grad, atol=1e-5, rtol=1e-5)
+
+    @pytest.mark.parametrize("temperature", [1.0, 0.7])
+    def test_backward_bfloat16(self, temperature):
+        torch.manual_seed(42)
+        hidden = torch.randn(self.N, self.H, dtype=torch.bfloat16, requires_grad=True)
+        weight = torch.randn(self.V, self.H, dtype=torch.bfloat16, requires_grad=True)
+        labels = torch.randint(0, self.V, (self.N,))
+
+        # Chunked backward
+        logprobs_chunked, _ = _ChunkedLogProbFunction.apply(hidden, weight, labels, temperature, self.CHUNK_SIZE)
+        logprobs_chunked.sum().backward()
+        grad_hidden_chunked = hidden.grad.clone()
+        grad_weight_chunked = weight.grad.clone()
+
+        hidden.grad = None
+        weight.grad = None
+
+        # Reference backward
+        logprobs_ref, _ = self._reference_logprobs_and_entropy(hidden, weight, labels, temperature)
+        logprobs_ref.sum().backward()
+
+        torch.testing.assert_close(grad_hidden_chunked, hidden.grad, atol=1e-2, rtol=1e-2)
+        torch.testing.assert_close(grad_weight_chunked, weight.grad, atol=1e-2, rtol=1e-2)
+
+
+class _FakeTransformerModel(nn.Module):
+    """Minimal stand-in for a transformer body: returns random hidden states of the right shape."""
+
+    def __init__(self, hidden_size):
+        super().__init__()
+        self.hidden_size = hidden_size
+        self._hidden = None
+
+    def forward(self, input_ids, attention_mask=None, use_cache=False, **kwargs):
+        b, s = input_ids.shape
+        if self._hidden is None or self._hidden.shape[:2] != (b, s):
+            torch.manual_seed(123)
+            self._hidden = torch.randn(b, s, self.hidden_size, requires_grad=True)
+        return type("Out", (), {"last_hidden_state": self._hidden})()
+
+
+class _FakeCausalLM(nn.Module):
+    """Minimal CausalLM with .model and .lm_head, enough for patch_chunked_lm_head."""
+
+    def __init__(self, hidden_size, vocab_size):
+        super().__init__()
+        self.config = type("Config", (), {})()
+        self.model = _FakeTransformerModel(hidden_size)
+        self.lm_head = nn.Linear(hidden_size, vocab_size, bias=False)
+
+    def forward(self, input_ids, attention_mask=None, labels=None, **kwargs):
+        raise NotImplementedError("should be monkey-patched")
+
+
+_CHUNKED_LM_HEAD_MODEL_IDS = [
+    "trl-internal-testing/tiny-CohereForCausalLM",
+    "trl-internal-testing/tiny-Cohere2ForCausalLM",
+    pytest.param(
+        "trl-internal-testing/tiny-DeepseekV3ForCausalLM",
+        marks=pytest.mark.skipif(
+            Version(transformers.__version__) < Version("5.0.0"),
+            reason="DeepseekV3 SDPA attention is broken in transformers < 5.0.0",
+        ),
+    ),
+    pytest.param(
+        "trl-internal-testing/tiny-DeepseekV3ForCausalLM-0528",
+        marks=pytest.mark.skipif(
+            Version(transformers.__version__) < Version("5.0.0"),
+            reason="DeepseekV3 SDPA attention is broken in transformers < 5.0.0",
+        ),
+    ),
+    "trl-internal-testing/tiny-Gemma2ForCausalLM",
+    "trl-internal-testing/tiny-GemmaForCausalLM",
+    "trl-internal-testing/tiny-Glm4MoeForCausalLM",
+    "trl-internal-testing/tiny-GptOssForCausalLM",
+    "trl-internal-testing/tiny-LlamaForCausalLM-3.1",
+    "trl-internal-testing/tiny-LlamaForCausalLM-3.2",
+    "trl-internal-testing/tiny-LlamaForCausalLM-3",
+    "trl-internal-testing/tiny-MistralForCausalLM-0.1",
+    "trl-internal-testing/tiny-MistralForCausalLM-0.2",
+    pytest.param(
+        "trl-internal-testing/tiny-NemotronHForCausalLM-nano",
+        marks=pytest.mark.skipif(
+            Version(transformers.__version__) < Version("5.3.0"),
+            reason="Nemotron 3 was introduced in transformers>=5.3.0",
+        ),
+    ),
+    pytest.param(
+        "trl-internal-testing/tiny-Olmo3ForCausalLM",
+        marks=pytest.mark.skipif(
+            Version(transformers.__version__) < Version("4.57.0"),
+            reason="Olmo 3 was introduced in transformers>=4.57.0",
+        ),
+    ),
+    "trl-internal-testing/tiny-Phi3ForCausalLM-3",
+    "trl-internal-testing/tiny-Phi3ForCausalLM-3.5",
+    "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+    "trl-internal-testing/tiny-Qwen3ForCausalLM",
+    "trl-internal-testing/tiny-Qwen3ForCausalLM-Instruct-2507",
+]
+
+
+@require_torch_accelerator
+class TestPatchChunkedLMHead:
+    B, S = 4, 16  # batch size, sequence length (including prompt + completion)
+    H, V = 32, 128
+    CHUNK_SIZE = 32
+
+    def _build_model_and_inputs(self, temperature=1.0):
+        torch.manual_seed(42)
+        model = _FakeCausalLM(self.H, self.V)
+        patch_chunked_lm_head(model, self.CHUNK_SIZE, temperature)
+
+        input_ids = torch.randint(0, self.V, (self.B, self.S))
+        attention_mask = torch.ones(self.B, self.S, dtype=torch.long)
+        # First half of each sequence is prompt (0), second half is completion (1)
+        completion_mask = torch.zeros(self.B, self.S, dtype=torch.float32)
+        completion_mask[:, self.S // 2 :] = 1.0
+        return model, input_ids, attention_mask, completion_mask
+
+    @pytest.mark.parametrize("temperature", [1.0, 0.7])
+    def test_dummy_model_chunked_forward_with_completion_mask(self, temperature):
+        """Masked forward matches unmasked forward at completion positions and is zero at prompt positions."""
+        model, input_ids, attention_mask, completion_mask = self._build_model_and_inputs(temperature)
+
+        # Run WITHOUT completion_mask (baseline — computes all positions)
+        out_full = model(input_ids=input_ids, attention_mask=attention_mask, labels=input_ids)
+
+        # Reset hidden state cache so both runs use the same hidden states
+        model.model._hidden = None
+
+        # Run WITH completion_mask
+        out_masked = model(
+            input_ids=input_ids, attention_mask=attention_mask, labels=input_ids, completion_mask=completion_mask
+        )
+
+        # shifted completion_mask (matching the shift in _chunked_forward)
+        shifted_mask = completion_mask[:, 1:].bool()
+
+        # At completion positions, values should match
+        torch.testing.assert_close(
+            out_masked["log_probs"][shifted_mask],
+            out_full["log_probs"][shifted_mask],
+            atol=1e-5,
+            rtol=1e-5,
+        )
+        torch.testing.assert_close(
+            out_masked["entropy"][shifted_mask],
+            out_full["entropy"][shifted_mask],
+            atol=1e-5,
+            rtol=1e-5,
+        )
+
+        # At prompt positions, values should be zero
+        prompt_mask = ~shifted_mask
+        assert (out_masked["log_probs"][prompt_mask] == 0).all()
+        assert (out_masked["entropy"][prompt_mask] == 0).all()
+
+    @pytest.mark.parametrize("temperature", [1.0, 0.7])
+    def test_dummy_model_chunked_forward_completion_mask_backward(self, temperature):
+        model, input_ids, attention_mask, completion_mask = self._build_model_and_inputs(temperature)
+
+        # Full forward + backward (mask applied after, as the trainer does)
+        out_full = model(input_ids=input_ids, attention_mask=attention_mask, labels=input_ids)
+        shifted_mask = completion_mask[:, 1:]
+        loss_full = (out_full["log_probs"] * shifted_mask).sum()
+        loss_full.backward()
+        grad_weight_full = model.lm_head.weight.grad.clone()
+
+        model.lm_head.weight.grad = None
+        model.model._hidden = None
+
+        # Masked forward + backward
+        out_masked = model(
+            input_ids=input_ids, attention_mask=attention_mask, labels=input_ids, completion_mask=completion_mask
+        )
+        loss_masked = (out_masked["log_probs"] * shifted_mask).sum()
+        loss_masked.backward()
+        grad_weight_masked = model.lm_head.weight.grad.clone()
+
+        torch.testing.assert_close(grad_weight_masked, grad_weight_full, atol=1e-5, rtol=1e-5)
+
+    @pytest.mark.parametrize("model_id", _CHUNKED_LM_HEAD_MODEL_IDS)
+    @pytest.mark.parametrize("temperature", [1.0, 0.7])
+    def test_forward(self, model_id, temperature):
+        model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.bfloat16).to(torch_device)
+        model.eval()
+
+        B, S, chunk_size = 2, 8, 32
+        torch.manual_seed(42)
+        input_ids = torch.randint(0, model.config.vocab_size, (B, S), device=torch_device)
+        labels = input_ids.clone()
+
+        # Reference: standard forward → shifted logits → logprobs & entropy
+        with torch.no_grad():
+            ref_logits = model(input_ids=input_ids).logits[:, :-1, :].float() / temperature
+        shifted_labels = labels[:, 1:]
+        ref_log_p = F.log_softmax(ref_logits, dim=-1)
+        ref_logprobs = ref_log_p.gather(-1, shifted_labels.unsqueeze(-1)).squeeze(-1)
+        ref_p = ref_logits.softmax(dim=-1)
+        ref_entropy = -(ref_p * ref_log_p).sum(dim=-1)
+
+        # Chunked forward
+        patch_chunked_lm_head(model, chunk_size, temperature)
+        with torch.no_grad():
+            out = model(input_ids=input_ids, labels=labels)
+
+        torch.testing.assert_close(out["log_probs"], ref_logprobs, atol=5e-3, rtol=5e-3)
+        torch.testing.assert_close(out["entropy"], ref_entropy, atol=5e-3, rtol=5e-3)
+
+    @pytest.mark.parametrize("model_id", _CHUNKED_LM_HEAD_MODEL_IDS)
+    @pytest.mark.parametrize("temperature", [1.0, 0.7])
+    def test_backward(self, model_id, temperature):
+        model_ref = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.bfloat16).to(torch_device)
+        model_chunked = copy.deepcopy(model_ref)
+
+        B, S, chunk_size = 2, 8, 32
+        torch.manual_seed(42)
+        input_ids = torch.randint(0, model_ref.config.vocab_size, (B, S), device=torch_device)
+        labels = input_ids.clone()
+        shifted_labels = labels[:, 1:]
+
+        # Reference backward: standard logits → logprobs → backward
+        ref_logits = model_ref(input_ids=input_ids).logits[:, :-1, :].float() / temperature
+        ref_log_p = F.log_softmax(ref_logits, dim=-1)
+        ref_logprobs = ref_log_p.gather(-1, shifted_labels.unsqueeze(-1)).squeeze(-1)
+        ref_logprobs.sum().backward()
+        ref_grad = model_ref.lm_head.weight.grad.clone()
+
+        # Chunked backward
+        patch_chunked_lm_head(model_chunked, chunk_size, temperature)
+        out = model_chunked(input_ids=input_ids, labels=labels)
+        out["log_probs"].sum().backward()
+        chunked_grad = model_chunked.lm_head.weight.grad.clone()
+
+        torch.testing.assert_close(chunked_grad, ref_grad, atol=5e-2, rtol=5e-2)
+
+
+class TestComputeFlopsPerToken(TrlTestCase):
+    DENSE_MODEL_ID = "trl-internal-testing/tiny-Qwen3ForCausalLM"
+    MOE_MODEL_ID = "trl-internal-testing/tiny-Qwen3MoeForCausalLM"
+
+    def test_seq_scaling_linear(self):
+        # Attention-score FLOPs per token scale linearly with seq_len; everything else
+        # is seq-len-independent. Doubling seq_len should double the seq-dependent delta,
+        # which differences cancel out from. `F(32k) - F(16k) == 2 * (F(16k) - F(8k))`.
+        cfg = AutoConfig.from_pretrained(self.DENSE_MODEL_ID)
+        f_8k = compute_flops_per_token(cfg, 8192)
+        f_16k = compute_flops_per_token(cfg, 16384)
+        f_32k = compute_flops_per_token(cfg, 32768)
+        assert f_32k - f_16k == 2 * (f_16k - f_8k)
+
+    def test_tied_vs_untied_lm_head(self):
+        # Untied lm_head adds `2 * V * h` forward FLOPs, ×3 for fwd+bwd.
+        cfg = AutoConfig.from_pretrained(self.DENSE_MODEL_ID)
+        cfg.tie_word_embeddings = True
+        f_tied = compute_flops_per_token(cfg, 16384)
+        cfg.tie_word_embeddings = False
+        f_untied = compute_flops_per_token(cfg, 16384)
+        expected_delta = 3 * 2 * cfg.vocab_size * cfg.hidden_size
+        assert f_untied - f_tied == expected_delta
+
+    def test_moe_active_vs_total_experts(self):
+        # Doubling `num_experts_per_tok` (active experts) changes FLOPs by exactly the
+        # routed-experts contribution: `num_experts_per_tok × 3 matmuls × 2 × h × moe_intermediate`
+        # per MoE layer, ×3 for fwd+bwd. Holding `num_local_experts` constant pins the
+        # router term so the delta is purely the active-expert math.
+        cfg = AutoConfig.from_pretrained(self.MOE_MODEL_ID)
+        cfg.num_experts_per_tok = 1
+        f_lo = compute_flops_per_token(cfg, 16384)
+        cfg.num_experts_per_tok = 2
+        f_hi = compute_flops_per_token(cfg, 16384)
+        moe_layers = sum(1 for i in range(cfg.num_hidden_layers) if i % cfg.decoder_sparse_step == 0)
+        per_expert_per_layer = 2 * 3 * cfg.hidden_size * cfg.moe_intermediate_size
+        expected_delta = 3 * moe_layers * (2 - 1) * per_expert_per_layer
+        assert f_hi - f_lo == expected_delta
+
+
+class TestComputeMfu(TrlTestCase):
+    def test_perfect_utilization(self):
+        # If aggregate TPS is exactly `peak * world_size / flops_per_token`, MFU is 100%.
+        flops = 100e9
+        peak = 989.5e12
+        world_size = 8
+        tps = peak * world_size / flops
+        assert compute_mfu(flops, tps, world_size, peak_flops_per_device=peak) == pytest.approx(100.0)
+
+
+class TestAdjustedMfu(TrlTestCase):
+    MOE_MODEL_ID = "trl-internal-testing/tiny-Qwen3MoeForCausalLM"
+
+    def test_consistent_with_formula(self):
+        # `adjusted_mfu(mfu, cfg, seq_len) == mfu * (full - half_attn) / full`, with
+        # `full = compute_flops_per_token(cfg, seq_len)` and
+        # `half_attn = L * 3 * 2 * n_heads * head_dim * seq_len`. Cross-check the two helpers.
+        cfg = AutoConfig.from_pretrained(self.MOE_MODEL_ID)
+        seq_len = 16384
+        flops_full = compute_flops_per_token(cfg, seq_len)
+        half_attn = cfg.num_hidden_layers * 3 * 2 * cfg.num_attention_heads * cfg.head_dim * seq_len
+        expected = 100.0 * (flops_full - half_attn) / flops_full
+        assert adjusted_mfu(100.0, cfg, seq_len) == pytest.approx(expected)
+
+    def test_proportional_to_input(self):
+        # The correction is purely multiplicative in `mfu`. `adjusted_mfu(2*x, ...)` should
+        # equal `2 * adjusted_mfu(x, ...)`.
+        cfg = AutoConfig.from_pretrained(self.MOE_MODEL_ID)
+        a = adjusted_mfu(50.0, cfg, 16384)
+        b = adjusted_mfu(100.0, cfg, 16384)
+        assert b == pytest.approx(2 * a)
+
+    def test_decreases_with_seq_len(self):
+        # Longer sequences → attention takes a larger share of total compute → causal
+        # correction subtracts a larger absolute amount → factor strictly decreases.
+        cfg = AutoConfig.from_pretrained(self.MOE_MODEL_ID)
+        f_short = adjusted_mfu(100.0, cfg, 4096)
+        f_med = adjusted_mfu(100.0, cfg, 16384)
+        f_long = adjusted_mfu(100.0, cfg, 65536)
+        assert f_short > f_med > f_long

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_vllm_client_server.py

@@ -0,0 +1,1036 @@
+# 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 subprocess
+from types import SimpleNamespace
+
+import pytest
+from packaging.version import Version
+from transformers import AutoModelForCausalLM, AutoProcessor, AutoTokenizer
+from transformers.testing_utils import torch_device
+
+from trl.generation.vllm_client import VLLMClient
+from trl.generation.vllm_generation import extract_logprobs
+from trl.import_utils import is_vllm_available
+from trl.scripts.vllm_serve import chunk_list
+
+from .testing_utils import (
+    TrlTestCase,
+    kill_process,
+    require_3_accelerators,
+    require_torch_multi_accelerator,
+    require_vision,
+    require_vllm,
+)
+
+
+if is_vllm_available():
+    import vllm
+    from vllm import LLM, SamplingParams
+
+    _is_vllm_ge_014 = Version(vllm.__version__) >= Version("0.14.0")
+else:
+    _is_vllm_ge_014 = False
+
+
+class TestChunkList(TrlTestCase):
+    def test_even_split(self):
+        assert chunk_list([1, 2, 3, 4, 5, 6], 2) == [[1, 2, 3], [4, 5, 6]]
+
+    def test_uneven_split(self):
+        assert chunk_list([1, 2, 3, 4, 5, 6], 4) == [[1, 2], [3, 4], [5], [6]]
+
+    def test_more_chunks_than_elements(self):
+        assert chunk_list([1, 2, 3, 4, 5, 6], 8) == [[1], [2], [3], [4], [5], [6], [], []]
+
+    def test_n_equals_len(self):
+        assert chunk_list([1, 2, 3], 3) == [[1], [2], [3]]
+
+    def test_n_is_1(self):
+        assert chunk_list([1, 2, 3], 1) == [[1, 2, 3]]
+
+    def test_single_element_list(self):
+        assert chunk_list([42], 2) == [[42], []]
+
+    def test_any_dtype(self):
+        assert chunk_list([1, "two", 3.0, {"four": 4}, ["f", "i", "v", "e"]], 2) == [
+            [1, "two", 3.0],
+            [{"four": 4}, ["f", "i", "v", "e"]],
+        ]
+
+
+class TestExtractLogprobs(TrlTestCase):
+    def test_extract_logprobs_sorts_by_rank_and_replaces_nan(self):
+        all_outputs = [
+            SimpleNamespace(
+                outputs=[
+                    SimpleNamespace(
+                        logprobs=[
+                            {
+                                11: SimpleNamespace(rank=1, logprob=-0.2),
+                                99: SimpleNamespace(rank=0, logprob=-0.1),
+                                42: SimpleNamespace(rank=2, logprob=float("nan")),
+                            },
+                            {
+                                5: SimpleNamespace(rank=0, logprob=-1.1),
+                            },
+                        ]
+                    )
+                ]
+            ),
+            SimpleNamespace(
+                outputs=[
+                    SimpleNamespace(
+                        logprobs=[
+                            {
+                                3: SimpleNamespace(rank=1, logprob=-0.5),
+                                7: SimpleNamespace(rank=0, logprob=-0.4),
+                            }
+                        ]
+                    )
+                ]
+            ),
+        ]
+
+        all_logprobs, all_token_ids = extract_logprobs(all_outputs)
+
+        assert all_token_ids == [
+            [[99, 11, 42], [5]],
+            [[7, 3]],
+        ]
+        assert all_logprobs == [
+            [[-0.1, -0.2, None], [-1.1]],
+            [[-0.4, -0.5]],
+        ]
+
+    def test_extract_logprobs_returns_none_token_ids_when_logprobs_missing(self):
+        all_outputs = [SimpleNamespace(outputs=[SimpleNamespace(logprobs=None)])]
+
+        all_logprobs, all_token_ids = extract_logprobs(all_outputs)
+
+        assert all_logprobs is None
+        assert all_token_ids is None
+
+
+@pytest.mark.slow
+@require_torch_multi_accelerator
+@require_vllm
+class TestVLLMClientServer(TrlTestCase):
+    model_id = "Qwen/Qwen2.5-1.5B"
+
+    @classmethod
+    def setup_class(cls):
+        # We want the server to run on accelerator 1, so we set VISIBLE_DEVICES to "1"
+        env = os.environ.copy()
+        VISIBLE_DEVICES = "ZE_AFFINITY_MASK" if torch_device == "xpu" else "CUDA_VISIBLE_DEVICES"
+        env[VISIBLE_DEVICES] = "1"  # Restrict to accelerator 1
+
+        # Start the server process
+        cls.server_process = subprocess.Popen(
+            ["trl", "vllm-serve", "--model", cls.model_id], stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env
+        )
+
+        # Initialize the client
+        cls.client = VLLMClient(connection_timeout=240, host="localhost")
+        cls.client.init_communicator()
+
+    def test_generate(self):
+        prompts = ["Hello, AI!", "Tell me a joke"]
+        outputs = self.client.generate(prompts)
+        prompt_ids = outputs["prompt_ids"]
+        completion_ids = outputs["completion_ids"]
+
+        # Check that the outputs are lists
+        assert isinstance(prompt_ids, list)
+        assert isinstance(completion_ids, list)
+
+        # Check that the number of sequences are equal to the number of prompts
+        assert len(prompt_ids) == len(prompts)
+        assert len(completion_ids) == len(prompts)
+
+        # Check that the sequences are lists of integers
+        for seq in prompt_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+        for seq in completion_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+
+    def test_generate_with_logprobs_none(self):
+        outputs = self.client.generate(["Hello, AI!"], logprobs=None)
+
+        assert isinstance(outputs["prompt_ids"], list)
+        assert isinstance(outputs["completion_ids"], list)
+        assert outputs["logprobs"] is None
+        assert outputs["logprob_token_ids"] is None
+
+    def test_chat(self):
+        messages = [[{"role": "user", "content": "Hello, AI!"}], [{"role": "user", "content": "Tell me a joke"}]]
+        outputs = self.client.chat(messages)
+        prompt_ids = outputs["prompt_ids"]
+        completion_ids = outputs["completion_ids"]
+
+        # Check that the outputs are lists
+        assert isinstance(prompt_ids, list)
+        assert isinstance(completion_ids, list)
+
+        # Check that the number of sequences are equal to the number of messages
+        assert len(prompt_ids) == len(messages)
+        assert len(completion_ids) == len(messages)
+
+        # Check that the sequences are lists of integers
+        for seq in prompt_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+        for seq in completion_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+
+    def test_chat_with_logprobs_none(self):
+        outputs = self.client.chat([[{"role": "user", "content": "Hello, AI!"}]], logprobs=None)
+
+        assert isinstance(outputs["prompt_ids"], list)
+        assert isinstance(outputs["completion_ids"], list)
+        assert outputs["logprobs"] is None
+        assert outputs["logprob_token_ids"] is None
+
+    def test_chat_with_tools(self):
+        def multiply(a: int, b: int) -> int:
+            """
+            Multiplies two integers.
+
+            Args:
+                a: The first integer.
+                b: The second integer.
+
+            Returns:
+                The product of the two integers.
+            """
+            return a * b
+
+        messages = [[{"role": "user", "content": "What is 3 multiplied by 4?"}]]
+        outputs = self.client.chat(messages, tools=[multiply])
+
+        # Decode prompt and check that "Multiplies two integers." is in the prompt.
+        tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+        decoded_prompt = tokenizer.decode(outputs["prompt_ids"][0])
+        assert "Multiplies two integers." in decoded_prompt
+
+    def test_generate_with_token_ids(self):
+        tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+        prompts = ["Hello, AI!", "Tell me a joke"]
+        prompt_token_ids = tokenizer(prompts)["input_ids"]
+        outputs = self.client.generate(prompt_token_ids)
+        prompt_ids = outputs["prompt_ids"]
+        completion_ids = outputs["completion_ids"]
+
+        # Check that the outputs are lists
+        assert isinstance(prompt_ids, list)
+        assert isinstance(completion_ids, list)
+
+        # Check that the number of sequences are equal to the number of prompts
+        assert len(prompt_ids) == len(prompts)
+        assert len(completion_ids) == len(prompts)
+
+        # Check that prompt_ids match the input token IDs
+        assert prompt_ids == prompt_token_ids
+
+        # Check that the sequences are lists of integers
+        for seq in prompt_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+        for seq in completion_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+
+    def test_generate_with_params(self):
+        prompts = ["Hello, AI!", "Tell me a joke"]
+        completion_ids = self.client.generate(prompts, n=2, repetition_penalty=0.9, temperature=0.8, max_tokens=32)[
+            "completion_ids"
+        ]
+
+        # Check that the output is a list
+        assert isinstance(completion_ids, list)
+
+        # Check that the number of generated sequences is 2 times the number of prompts
+        assert len(completion_ids) == 2 * len(prompts)
+
+        # Check that the generated sequences are lists of integers
+        for seq in completion_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+
+        # Check that the length of the generated sequences is less than or equal to 32
+        for seq in completion_ids:
+            assert len(seq) <= 32
+
+    def test_update_model_params(self):
+        model = AutoModelForCausalLM.from_pretrained(self.model_id, device_map=torch_device)
+        self.client.update_model_params(model)
+
+    def test_reset_prefix_cache(self):
+        # Test resetting the prefix cache
+        self.client.reset_prefix_cache()
+
+    @pytest.mark.xfail(reason="Importing `bitsandbytes` causes issues, see vllm-project/vllm#32793")
+    def test_logprobs_match_with_non_default_sampling(self):
+        prompts = ["Hello, AI!", "Tell me a joke"]
+        # Use non-default sampling parameters (especially temperature) to ensure vLLM applies logprob processing. With
+        # default sampling, raw and processed logprobs are identical, so mismatches would not be detected.
+        temperature = 0.7
+        repetition_penalty = 1.05
+        top_p = 0.9
+        max_tokens = 8
+        seed = 1234
+        num_logprobs = 5
+
+        server_outputs = self.client.generate(
+            prompts,
+            temperature=temperature,
+            repetition_penalty=repetition_penalty,
+            top_p=top_p,
+            max_tokens=max_tokens,
+            logprobs=num_logprobs,
+            generation_kwargs={"seed": seed},
+        )
+        os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+        llm = LLM(
+            model=self.model_id,
+            tensor_parallel_size=1,
+            gpu_memory_utilization=0.2,
+            max_model_len=128,
+            logprobs_mode="processed_logprobs",
+        )
+
+        sampling_params = SamplingParams(
+            temperature=temperature,
+            repetition_penalty=repetition_penalty,
+            top_p=top_p,
+            max_tokens=max_tokens,
+            logprobs=num_logprobs,
+            seed=seed,
+        )
+        colocate_outputs = llm.generate(prompts, sampling_params=sampling_params, use_tqdm=False)
+        colocate_prompt_ids = [output.prompt_token_ids for output in colocate_outputs]
+        colocate_completion_ids = [
+            list(output.token_ids) for outputs in colocate_outputs for output in outputs.outputs
+        ]
+        colocate_logprobs, colocate_logprob_token_ids = extract_logprobs(colocate_outputs)
+
+        # Generation correctness: prompt and completion IDs match between server and colocate
+        assert server_outputs["prompt_ids"] == colocate_prompt_ids
+        assert server_outputs["completion_ids"] == colocate_completion_ids
+
+        server_logprobs = server_outputs["logprobs"]
+        server_logprob_token_ids = server_outputs["logprob_token_ids"]
+
+        # Shape: both should be (num_sequences, seq_len, num_logprobs) with multiple logprobs per token
+        assert len(server_logprobs) == len(prompts)
+        assert len(server_logprob_token_ids) == len(prompts)
+        for seq_lps in server_logprobs:
+            for token_lps in seq_lps:
+                assert len(token_lps) > 1, "Expected multiple logprobs per token when logprobs > 0"
+
+        # Value correctness: server extraction matches colocate extraction via extract_logprobs
+        assert server_logprob_token_ids == colocate_logprob_token_ids
+        for server_seq, colocate_seq in zip(server_logprobs, colocate_logprobs, strict=True):
+            assert len(server_seq) == len(colocate_seq)
+            for server_token_lps, colocate_token_lps in zip(server_seq, colocate_seq, strict=True):
+                assert server_token_lps == pytest.approx(colocate_token_lps, rel=1e-6, abs=1e-6)
+
+        # Ordering: logprobs at each position should be sorted descending
+        for seq_lps in server_logprobs:
+            for token_lps in seq_lps:
+                assert token_lps == sorted(token_lps, reverse=True), "Logprobs should be sorted descending"
+
+        # Sampled token presence: the actual completion token should appear in the logprob token IDs
+        for seq_idx, (completion_seq, token_ids_seq) in enumerate(
+            zip(server_outputs["completion_ids"], server_logprob_token_ids, strict=True)
+        ):
+            for pos, (sampled_id, lp_ids) in enumerate(zip(completion_seq, token_ids_seq, strict=True)):
+                assert sampled_id in lp_ids, (
+                    f"Sampled token {sampled_id} not found in logprob token IDs {lp_ids} "
+                    f"at sequence {seq_idx}, position {pos}"
+                )
+
+    @classmethod
+    def teardown_class(cls):
+        # Close the client
+        cls.client.close_communicator()
+
+        # vLLM x pytest (or Popen) seems not to handle process termination well. To avoid zombie processes, we need to
+        # kill the server process and its children explicitly.
+        kill_process(cls.server_process)
+
+
+# Same as above but using base_url to instantiate the client.
+@pytest.mark.slow
+@require_torch_multi_accelerator
+@require_vllm
+class TestVLLMClientServerBaseURL(TrlTestCase):
+    model_id = "Qwen/Qwen2.5-1.5B"
+
+    @classmethod
+    def setup_class(cls):
+        # We want the server to run on accelerator 1, so we set VISIBLE_DEVICES to "1"
+        env = os.environ.copy()
+        VISIBLE_DEVICES = "ZE_AFFINITY_MASK" if torch_device == "xpu" else "CUDA_VISIBLE_DEVICES"
+        env[VISIBLE_DEVICES] = "1"  # Restrict to accelerator 1
+
+        # Start the server process
+        cls.server_process = subprocess.Popen(
+            ["trl", "vllm-serve", "--model", cls.model_id], stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env
+        )
+
+        # Initialize the client
+        cls.client = VLLMClient(base_url="http://localhost:8000", connection_timeout=240)
+        cls.client.init_communicator()
+
+    def test_generate(self):
+        prompts = ["Hello, AI!", "Tell me a joke"]
+        outputs = self.client.generate(prompts)
+        prompt_ids = outputs["prompt_ids"]
+        completion_ids = outputs["completion_ids"]
+
+        # Check that the outputs are lists
+        assert isinstance(prompt_ids, list)
+        assert isinstance(completion_ids, list)
+
+        # Check that the number of sequences are equal to the number of prompts
+        assert len(prompt_ids) == len(prompts)
+        assert len(completion_ids) == len(prompts)
+
+        # Check that the sequences are lists of integers
+        for seq in prompt_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+        for seq in completion_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+
+    def test_generate_with_logprobs_none(self):
+        outputs = self.client.generate(["Hello, AI!"], logprobs=None)
+
+        assert isinstance(outputs["prompt_ids"], list)
+        assert isinstance(outputs["completion_ids"], list)
+        assert outputs["logprobs"] is None
+        assert outputs["logprob_token_ids"] is None
+
+    def test_chat(self):
+        messages = [[{"role": "user", "content": "Hello, AI!"}], [{"role": "user", "content": "Tell me a joke"}]]
+        outputs = self.client.chat(messages)
+        prompt_ids = outputs["prompt_ids"]
+        completion_ids = outputs["completion_ids"]
+
+        # Check that the outputs are lists
+        assert isinstance(prompt_ids, list)
+        assert isinstance(completion_ids, list)
+
+        # Check that the number of sequences are equal to the number of messages
+        assert len(prompt_ids) == len(messages)
+        assert len(completion_ids) == len(messages)
+
+        # Check that the sequences are lists of integers
+        for seq in prompt_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+        for seq in completion_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+
+    def test_chat_with_logprobs_none(self):
+        outputs = self.client.chat([[{"role": "user", "content": "Hello, AI!"}]], logprobs=None)
+
+        assert isinstance(outputs["prompt_ids"], list)
+        assert isinstance(outputs["completion_ids"], list)
+        assert outputs["logprobs"] is None
+        assert outputs["logprob_token_ids"] is None
+
+    def test_chat_with_tools(self):
+        def multiply(a: int, b: int) -> int:
+            """
+            Multiplies two integers.
+
+            Args:
+                a: The first integer.
+                b: The second integer.
+
+            Returns:
+                The product of the two integers.
+            """
+            return a * b
+
+        messages = [[{"role": "user", "content": "What is 3 multiplied by 4?"}]]
+        outputs = self.client.chat(messages, tools=[multiply])
+
+        # Decode prompt and check that "Multiplies two integers." is in the prompt.
+        tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+        decoded_prompt = tokenizer.decode(outputs["prompt_ids"][0])
+        assert "Multiplies two integers." in decoded_prompt
+
+    def test_generate_with_token_ids(self):
+        tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+        prompts = ["Hello, AI!", "Tell me a joke"]
+        prompt_token_ids = tokenizer(prompts)["input_ids"]
+        outputs = self.client.generate(prompt_token_ids)
+        prompt_ids = outputs["prompt_ids"]
+        completion_ids = outputs["completion_ids"]
+
+        # Check that the outputs are lists
+        assert isinstance(prompt_ids, list)
+        assert isinstance(completion_ids, list)
+
+        # Check that the number of sequences are equal to the number of prompts
+        assert len(prompt_ids) == len(prompts)
+        assert len(completion_ids) == len(prompts)
+
+        # Check that prompt_ids match the input token IDs
+        assert prompt_ids == prompt_token_ids
+
+        # Check that the sequences are lists of integers
+        for seq in prompt_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+        for seq in completion_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+
+    def test_generate_with_params(self):
+        prompts = ["Hello, AI!", "Tell me a joke"]
+        completion_ids = self.client.generate(prompts, n=2, repetition_penalty=0.9, temperature=0.8, max_tokens=32)[
+            "completion_ids"
+        ]
+
+        # Check that the output is a list
+        assert isinstance(completion_ids, list)
+
+        # Check that the number of generated sequences is 2 times the number of prompts
+        assert len(completion_ids) == 2 * len(prompts)
+
+        # Check that the generated sequences are lists of integers
+        for seq in completion_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+
+        # Check that the length of the generated sequences is less than or equal to 32
+        for seq in completion_ids:
+            assert len(seq) <= 32
+
+    def test_update_model_params(self):
+        model = AutoModelForCausalLM.from_pretrained(self.model_id, device_map=torch_device)
+        self.client.update_model_params(model)
+
+    def test_reset_prefix_cache(self):
+        # Test resetting the prefix cache
+        self.client.reset_prefix_cache()
+
+    @classmethod
+    def teardown_class(cls):
+        # Close the client
+        cls.client.close_communicator()
+
+        # vLLM x pytest (or Popen) seems not to handle process termination well. To avoid zombie processes, we need to
+        # kill the server process and its children explicitly.
+        kill_process(cls.server_process)
+
+
+@pytest.mark.slow
+@require_3_accelerators
+@require_vllm
+class TestVLLMClientServerTP(TrlTestCase):
+    model_id = "Qwen/Qwen2.5-1.5B"
+
+    @classmethod
+    def setup_class(cls):
+        # We want the server to run on accelerator 1 and 2, so we set VISIBLE_DEVICES to "1,2"
+        env = os.environ.copy()
+        VISIBLE_DEVICES = "ZE_AFFINITY_MASK" if torch_device == "xpu" else "CUDA_VISIBLE_DEVICES"
+        env[VISIBLE_DEVICES] = "1,2"  # Restrict to accelerator 1 and 2
+
+        # Start the server process
+        cls.server_process = subprocess.Popen(
+            ["trl", "vllm-serve", "--model", cls.model_id, "--tensor_parallel_size", "2"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=env,
+        )
+
+        # Initialize the client
+        cls.client = VLLMClient(connection_timeout=240, host="localhost")
+        cls.client.init_communicator()
+
+    def test_generate(self):
+        prompts = ["Hello, AI!", "Tell me a joke"]
+        outputs = self.client.generate(prompts)
+        prompt_ids = outputs["prompt_ids"]
+        completion_ids = outputs["completion_ids"]
+
+        # Check that the outputs are lists
+        assert isinstance(prompt_ids, list)
+        assert isinstance(completion_ids, list)
+
+        # Check that the number of sequences are equal to the number of prompts
+        assert len(prompt_ids) == len(prompts)
+        assert len(completion_ids) == len(prompts)
+
+        # Check that the sequences are lists of integers
+        for seq in prompt_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+        for seq in completion_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+
+    def test_generate_with_logprobs_none(self):
+        outputs = self.client.generate(["Hello, AI!"], logprobs=None)
+
+        assert isinstance(outputs["prompt_ids"], list)
+        assert isinstance(outputs["completion_ids"], list)
+        assert outputs["logprobs"] is None
+        assert outputs["logprob_token_ids"] is None
+
+    def test_chat(self):
+        messages = [[{"role": "user", "content": "Hello, AI!"}], [{"role": "user", "content": "Tell me a joke"}]]
+        outputs = self.client.chat(messages)
+        prompt_ids = outputs["prompt_ids"]
+        completion_ids = outputs["completion_ids"]
+
+        # Check that the outputs are lists
+        assert isinstance(prompt_ids, list)
+        assert isinstance(completion_ids, list)
+
+        # Check that the number of sequences are equal to the number of messages
+        assert len(prompt_ids) == len(messages)
+        assert len(completion_ids) == len(messages)
+
+        # Check that the sequences are lists of integers
+        for seq in prompt_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+        for seq in completion_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+
+    def test_chat_with_logprobs_none(self):
+        outputs = self.client.chat([[{"role": "user", "content": "Hello, AI!"}]], logprobs=None)
+
+        assert isinstance(outputs["prompt_ids"], list)
+        assert isinstance(outputs["completion_ids"], list)
+        assert outputs["logprobs"] is None
+        assert outputs["logprob_token_ids"] is None
+
+    def test_chat_with_tools(self):
+        def multiply(a: int, b: int) -> int:
+            """
+            Multiplies two integers.
+
+            Args:
+                a: The first integer.
+                b: The second integer.
+
+            Returns:
+                The product of the two integers.
+            """
+            return a * b
+
+        messages = [[{"role": "user", "content": "What is 3 multiplied by 4?"}]]
+        outputs = self.client.chat(messages, tools=[multiply])
+
+        # Decode prompt and check that "Multiplies two integers." is in the prompt.
+        tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+        decoded_prompt = tokenizer.decode(outputs["prompt_ids"][0])
+        assert "Multiplies two integers." in decoded_prompt
+
+    def test_generate_with_token_ids(self):
+        tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+        prompts = ["Hello, AI!", "Tell me a joke"]
+        prompt_token_ids = tokenizer(prompts)["input_ids"]
+        outputs = self.client.generate(prompt_token_ids)
+        prompt_ids = outputs["prompt_ids"]
+        completion_ids = outputs["completion_ids"]
+
+        # Check that the outputs are lists
+        assert isinstance(prompt_ids, list)
+        assert isinstance(completion_ids, list)
+
+        # Check that the number of sequences are equal to the number of prompts
+        assert len(prompt_ids) == len(prompts)
+        assert len(completion_ids) == len(prompts)
+
+        # Check that prompt_ids match the input token IDs
+        assert prompt_ids == prompt_token_ids
+
+        # Check that the sequences are lists of integers
+        for seq in prompt_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+        for seq in completion_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+
+    def test_generate_with_params(self):
+        prompts = ["Hello, AI!", "Tell me a joke"]
+        completion_ids = self.client.generate(prompts, n=2, repetition_penalty=0.9, temperature=0.8, max_tokens=32)[
+            "completion_ids"
+        ]
+
+        # Check that the output is a list
+        assert isinstance(completion_ids, list)
+
+        # Check that the number of generated sequences is 2 times the number of prompts
+        assert len(completion_ids) == 2 * len(prompts)
+
+        # Check that the generated sequences are lists of integers
+        for seq in completion_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+
+        # Check that the length of the generated sequences is less than or equal to 32
+        for seq in completion_ids:
+            assert len(seq) <= 32
+
+    def test_update_model_params(self):
+        model = AutoModelForCausalLM.from_pretrained(self.model_id, device_map=torch_device)
+        self.client.update_model_params(model)
+
+    def test_reset_prefix_cache(self):
+        # Test resetting the prefix cache
+        self.client.reset_prefix_cache()
+
+    @classmethod
+    def teardown_class(cls):
+        # Close the client
+        cls.client.close_communicator()
+
+        # vLLM x pytest (or Popen) seems not to handle process termination well. To avoid zombie processes, we need to
+        # kill the server process and its children explicitly.
+        kill_process(cls.server_process)
+
+
+@pytest.mark.slow
+@pytest.mark.skipif(
+    _is_vllm_ge_014,
+    reason="Skipping DP server test for vLLM>=0.14.0 (PR vllm#30739: DP for non-MoE/dense models no longer supported).",
+)
+@require_3_accelerators
+@require_vllm
+class TestVLLMClientServerDP(TrlTestCase):
+    model_id = "Qwen/Qwen2.5-1.5B"
+
+    @classmethod
+    def setup_class(cls):
+        # We want the server to run on accelerator 1 and 2, so we set VISIBLE_DEVICES to "1,2"
+        env = os.environ.copy()
+        VISIBLE_DEVICES = "ZE_AFFINITY_MASK" if torch_device == "xpu" else "CUDA_VISIBLE_DEVICES"
+        env[VISIBLE_DEVICES] = "1,2"  # Restrict to accelerator 1 and 2
+
+        # Start the server process
+        cls.server_process = subprocess.Popen(
+            ["trl", "vllm-serve", "--model", cls.model_id, "--data_parallel_size", "2"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=env,
+        )
+
+        # Initialize the client
+        cls.client = VLLMClient(connection_timeout=240, host="localhost")
+        cls.client.init_communicator()
+
+    def test_generate(self):
+        prompts = ["Hello, AI!", "Tell me a joke"]
+        outputs = self.client.generate(prompts)
+        prompt_ids = outputs["prompt_ids"]
+        completion_ids = outputs["completion_ids"]
+
+        # Check that the outputs are lists
+        assert isinstance(prompt_ids, list)
+        assert isinstance(completion_ids, list)
+
+        # Check that the number of sequences are equal to the number of prompts
+        assert len(prompt_ids) == len(prompts)
+        assert len(completion_ids) == len(prompts)
+
+        # Check that the sequences are lists of integers
+        for seq in prompt_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+        for seq in completion_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+
+    def test_generate_with_logprobs_none(self):
+        outputs = self.client.generate(["Hello, AI!"], logprobs=None)
+
+        assert isinstance(outputs["prompt_ids"], list)
+        assert isinstance(outputs["completion_ids"], list)
+        assert outputs["logprobs"] is None
+        assert outputs["logprob_token_ids"] is None
+
+    def test_chat(self):
+        messages = [[{"role": "user", "content": "Hello, AI!"}], [{"role": "user", "content": "Tell me a joke"}]]
+        outputs = self.client.chat(messages)
+        prompt_ids = outputs["prompt_ids"]
+        completion_ids = outputs["completion_ids"]
+
+        # Check that the outputs are lists
+        assert isinstance(prompt_ids, list)
+        assert isinstance(completion_ids, list)
+
+        # Check that the number of sequences are equal to the number of messages
+        assert len(prompt_ids) == len(messages)
+        assert len(completion_ids) == len(messages)
+
+        # Check that the sequences are lists of integers
+        for seq in prompt_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+        for seq in completion_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+
+    def test_chat_with_logprobs_none(self):
+        outputs = self.client.chat([[{"role": "user", "content": "Hello, AI!"}]], logprobs=None)
+
+        assert isinstance(outputs["prompt_ids"], list)
+        assert isinstance(outputs["completion_ids"], list)
+        assert outputs["logprobs"] is None
+        assert outputs["logprob_token_ids"] is None
+
+    def test_chat_with_tools(self):
+        def multiply(a: int, b: int) -> int:
+            """
+            Multiplies two integers.
+
+            Args:
+                a: The first integer.
+                b: The second integer.
+
+            Returns:
+                The product of the two integers.
+            """
+            return a * b
+
+        messages = [[{"role": "user", "content": "What is 3 multiplied by 4?"}]]
+        outputs = self.client.chat(messages, tools=[multiply])
+
+        # Decode prompt and check that "Multiplies two integers." is in the prompt.
+        tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+        decoded_prompt = tokenizer.decode(outputs["prompt_ids"][0])
+        assert "Multiplies two integers." in decoded_prompt
+
+    def test_generate_with_token_ids(self):
+        tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+        prompts = ["Hello, AI!", "Tell me a joke"]
+        prompt_token_ids = tokenizer(prompts)["input_ids"]
+        outputs = self.client.generate(prompt_token_ids)
+        prompt_ids = outputs["prompt_ids"]
+        completion_ids = outputs["completion_ids"]
+
+        # Check that the outputs are lists
+        assert isinstance(prompt_ids, list)
+        assert isinstance(completion_ids, list)
+
+        # Check that the number of sequences are equal to the number of prompts
+        assert len(prompt_ids) == len(prompts)
+        assert len(completion_ids) == len(prompts)
+
+        # Check that prompt_ids match the input token IDs
+        assert prompt_ids == prompt_token_ids
+
+        # Check that the sequences are lists of integers
+        for seq in prompt_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+        for seq in completion_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+
+    def test_generate_with_params(self):
+        prompts = ["Hello, AI!", "Tell me a joke"]
+        completion_ids = self.client.generate(prompts, n=2, repetition_penalty=0.9, temperature=0.8, max_tokens=32)[
+            "completion_ids"
+        ]
+
+        # Check that the output is a list
+        assert isinstance(completion_ids, list)
+
+        # Check that the number of generated sequences is 2 times the number of prompts
+        assert len(completion_ids) == 2 * len(prompts)
+
+        # Check that the generated sequences are lists of integers
+        for seq in completion_ids:
+            assert all(isinstance(tok, int) for tok in seq)
+
+        # Check that the length of the generated sequences is less than or equal to 32
+        for seq in completion_ids:
+            assert len(seq) <= 32
+
+    def test_update_model_params(self):
+        model = AutoModelForCausalLM.from_pretrained(self.model_id, device_map=torch_device)
+        self.client.update_model_params(model)
+
+    def test_reset_prefix_cache(self):
+        # Test resetting the prefix cache
+        self.client.reset_prefix_cache()
+
+    @classmethod
+    def teardown_class(cls):
+        # Close the client
+        cls.client.close_communicator()
+
+        # vLLM x pytest (or Popen) seems not to handle process termination well. To avoid zombie processes, we need to
+        # kill the server process and its children explicitly.
+        kill_process(cls.server_process)
+
+
+@pytest.mark.slow
+@require_torch_multi_accelerator
+@require_vllm
+class TestVLLMClientServerDeviceParameter(TrlTestCase):
+    """Test the device parameter functionality in init_communicator."""
+
+    model_id = "Qwen/Qwen2.5-1.5B"
+
+    @classmethod
+    def setup_class(cls):
+        # We want the server to run on accelerator 1, so we set VISIBLE_DEVICES to "1"
+        env = os.environ.copy()
+        VISIBLE_DEVICES = "ZE_AFFINITY_MASK" if torch_device == "xpu" else "CUDA_VISIBLE_DEVICES"
+        env[VISIBLE_DEVICES] = "1"  # Restrict to accelerator 1
+
+        # Start the server process
+        cls.server_process = subprocess.Popen(
+            ["trl", "vllm-serve", "--model", cls.model_id], stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env
+        )
+
+    def test_init_communicator_with_device_int(self):
+        """Test init_communicator with integer device parameter."""
+        client = VLLMClient(connection_timeout=240, host="localhost")
+        client.init_communicator(device=0)  # Explicitly specify device 0
+
+        # Test basic functionality
+        prompts = ["Hello, AI!"]
+        outputs = client.generate(prompts)
+        prompt_ids = outputs["prompt_ids"]
+        completion_ids = outputs["completion_ids"]
+        assert isinstance(prompt_ids, list)
+        assert len(prompt_ids) == len(prompts)
+        assert isinstance(completion_ids, list)
+        assert len(completion_ids) == len(prompts)
+
+        client.close_communicator()
+
+    def test_init_communicator_with_device_string(self):
+        """Test init_communicator with string device parameter."""
+        client = VLLMClient(connection_timeout=240, host="localhost")
+        client.init_communicator(device=0)  # Explicitly specify device as string
+
+        # Test basic functionality
+        prompts = ["Hello, AI!"]
+        outputs = client.generate(prompts)["completion_ids"]
+        assert isinstance(outputs, list)
+        assert len(outputs) == len(prompts)
+
+        client.close_communicator()
+
+    def test_init_communicator_with_torch_device(self):
+        """Test init_communicator with torch.device object."""
+        import torch
+
+        client = VLLMClient(connection_timeout=240, host="localhost")
+        device = torch.device(0)
+        client.init_communicator(device=device)  # Explicitly specify torch.device object
+
+        # Test basic functionality
+        prompts = ["Hello, AI!"]
+        outputs = client.generate(prompts)["completion_ids"]
+        assert isinstance(outputs, list)
+        assert len(outputs) == len(prompts)
+
+        client.close_communicator()
+
+    @classmethod
+    def teardown_class(cls):
+        # vLLM x pytest (or Popen) seems not to handle process termination well. To avoid zombie processes, we need to
+        # kill the server process and its children explicitly.
+        kill_process(cls.server_process)
+
+
+@pytest.mark.slow
+@require_vllm
+@require_vision
+class TestVLLMClientServerVLM(TrlTestCase):
+    model_id = "Qwen/Qwen2.5-VL-3B-Instruct"
+
+    @classmethod
+    def setup_class(cls):
+        # Start the server process
+        cls.server_process = subprocess.Popen(
+            ["trl", "vllm-serve", "--model", cls.model_id], stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+
+        # Initialize the client (no communicator needed for generation-only tests)
+        cls.client = VLLMClient(connection_timeout=240, host="localhost")
+
+    def test_generate_with_token_ids_and_image(self):
+        from PIL import Image
+
+        processor = AutoProcessor.from_pretrained(self.model_id)
+        image1 = Image.new("RGB", (64, 64), color="red")
+        image2 = Image.new("RGB", (64, 64), color="blue")
+        image3 = Image.new("RGB", (64, 64), color="green")
+        messages = [
+            [
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "image", "image": image1},
+                        {"type": "image", "image": image2},
+                        {"type": "text", "text": "What are the differences between these two images?"},
+                    ],
+                }
+            ],
+            [
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "image", "image": image3},
+                        {"type": "text", "text": "What is the color of this image?"},
+                    ],
+                }
+            ],
+        ]
+        prompt_token_ids = processor.apply_chat_template(
+            conversation=messages, tokenize=True, add_generation_prompt=True
+        )
+        outputs = self.client.generate(prompt_token_ids, images=[[image1, image2], [image3]], max_tokens=64)
+        prompt_ids = outputs["prompt_ids"]
+        completion_ids = outputs["completion_ids"]
+
+        assert len(prompt_ids) == 2
+        assert len(completion_ids) == 2
+        assert all(isinstance(tok, int) for tok in prompt_ids[0])
+        assert all(isinstance(tok, int) for tok in completion_ids[0])
+
+    def test_generate_with_token_ids_mixed_images(self):
+        """Test a batch where one prompt has an image and the other does not."""
+        from PIL import Image
+
+        processor = AutoProcessor.from_pretrained(self.model_id)
+        image = Image.new("RGB", (64, 64), color="red")
+        messages = [
+            [
+                {
+                    "role": "user",
+                    "content": [{"type": "image", "image": image}, {"type": "text", "text": "Describe this image."}],
+                }
+            ],
+            [
+                {
+                    "role": "user",
+                    "content": [{"type": "text", "text": "What is 1+1?"}],
+                }
+            ],
+        ]
+        prompt_token_ids = processor.apply_chat_template(
+            conversation=messages, tokenize=True, add_generation_prompt=True
+        )
+        outputs = self.client.generate(prompt_token_ids, images=[[image], None], max_tokens=64)
+        prompt_ids = outputs["prompt_ids"]
+        completion_ids = outputs["completion_ids"]
+
+        assert len(prompt_ids) == 2
+        assert len(completion_ids) == 2
+        assert all(isinstance(tok, int) for tok in prompt_ids[0])
+        assert all(isinstance(tok, int) for tok in prompt_ids[1])
+        assert all(isinstance(tok, int) for tok in completion_ids[0])
+        assert all(isinstance(tok, int) for tok in completion_ids[1])
+
+    @classmethod
+    def teardown_class(cls):
+        kill_process(cls.server_process)

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/testing_constants.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.
+
+CI_HUB_USER = "__DUMMY_TRANSFORMERS_USER__"
+CI_HUB_USER_FULL_NAME = "Dummy User"
+
+CI_HUB_ENDPOINT = "https://hub-ci.huggingface.co"

tasks/tasksmith-b71e9e0a47b6/tests/source/tests/testing_utils.py

@@ -0,0 +1,150 @@
+# 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 signal
+import warnings
+from collections.abc import Callable
+
+import psutil
+import pytest
+import torch
+from transformers import is_bitsandbytes_available, is_comet_available, is_sklearn_available, is_wandb_available
+from transformers.testing_utils import backend_device_count, torch_device
+from transformers.utils import (
+    is_kernels_available,
+    is_peft_available,
+    is_rich_available,
+    is_torch_available,
+    is_vision_available,
+)
+
+from trl.import_utils import (
+    is_harbor_available,
+    is_jmespath_available,
+    is_joblib_available,
+    is_liger_kernel_available,
+    is_math_verify_available,
+    is_mergekit_available,
+    is_openreward_available,
+    is_vllm_available,
+)
+
+
+require_bitsandbytes = pytest.mark.skipif(not is_bitsandbytes_available(), reason="test requires bitsandbytes")
+require_comet = pytest.mark.skipif(not is_comet_available(), reason="test requires comet_ml")
+require_harbor = pytest.mark.skipif(not is_harbor_available(), reason="test requires harbor")
+require_jmespath = pytest.mark.skipif(not is_jmespath_available(), reason="test requires jmespath")
+require_kernels = pytest.mark.skipif(not is_kernels_available(), reason="test requires kernels")
+require_liger_kernel = pytest.mark.skipif(not is_liger_kernel_available(), reason="test requires liger-kernel")
+require_math_latex = pytest.mark.skipif(not is_math_verify_available(), reason="test requires math_verify")
+require_mergekit = pytest.mark.skipif(not is_mergekit_available(), reason="test requires mergekit")
+require_openreward = pytest.mark.skipif(not is_openreward_available(), reason="test requires openreward")
+require_peft = pytest.mark.skipif(not is_peft_available(), reason="test requires peft")
+require_rich = pytest.mark.skipif(not is_rich_available(), reason="test requires rich")
+require_sklearn = pytest.mark.skipif(
+    not (is_sklearn_available() and is_joblib_available()), reason="test requires sklearn"
+)
+require_torch_accelerator = pytest.mark.skipif(
+    torch_device is None or torch_device == "cpu", reason="test requires accelerator"
+)
+require_torch_multi_accelerator = pytest.mark.skipif(
+    not is_torch_available() or backend_device_count(torch_device) <= 1, reason="test requires multiple accelerators"
+)
+require_vision = pytest.mark.skipif(not is_vision_available(), reason="test requires vision")
+require_vllm = pytest.mark.skipif(not is_vllm_available(), reason="test requires vllm")
+require_wandb = pytest.mark.skipif(not is_wandb_available(), reason="test requires wandb")
+require_no_wandb = pytest.mark.skipif(is_wandb_available(), reason="test requires no wandb")
+require_3_accelerators = pytest.mark.skipif(
+    not (getattr(torch, torch_device, torch.cuda).device_count() >= 3),
+    reason=f"test requires at least 3 {torch_device}s",
+)
+
+
+def is_bitsandbytes_multi_backend_available() -> bool:
+    if is_bitsandbytes_available():
+        import bitsandbytes as bnb
+
+        return "multi_backend" in getattr(bnb, "features", set())
+    return False
+
+
+# Function ported from transformers.testing_utils before transformers#41283
+require_torch_gpu_if_bnb_not_multi_backend_enabled = pytest.mark.skipif(
+    not is_bitsandbytes_multi_backend_available() and not torch_device == "cuda",
+    reason="test requires bitsandbytes multi-backend enabled or 'cuda' torch device",
+)
+
+
+def is_ampere_or_newer(device_index=0):
+    if not torch.cuda.is_available():
+        return False
+
+    # "Ampere" is an NVIDIA architecture; an AMD (ROCm) GPU is never Ampere. On ROCm,
+    # torch.cuda.get_device_capability returns the gfx version, which would spuriously compare >= (8, 0).
+    if torch.version.hip is not None:
+        return False
+
+    major, minor = torch.cuda.get_device_capability(device_index)
+    # Ampere starts at compute capability 8.0 (e.g., A100 = 8.0, RTX 30xx = 8.6)
+    return (major, minor) >= (8, 0)
+
+
+class TrlTestCase:
+    @pytest.fixture(autouse=True)
+    def set_tmp_dir(self, tmp_path):
+        self.tmp_dir = str(tmp_path)
+
+
+def ignore_warnings(message: str = None, category: type[Warning] = Warning) -> Callable:
+    """
+    Decorator to ignore warnings with a specific message and/or category.
+
+    Args:
+        message (`str`, *optional*):
+            Regex pattern for the warning message to ignore. If `None`, all messages are ignored.
+        category (`type[Warning]`, *optional*, defaults to `Warning`):
+            Warning class to ignore. Defaults to `Warning`, which ignores all warnings.
+    """
+
+    def decorator(test_func):
+        @functools.wraps(test_func)
+        def wrapper(*args, **kwargs):
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore", message=message, category=category)
+                return test_func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def kill_process(process):
+    parent = psutil.Process(process.pid)
+    children = parent.children(recursive=True)
+    for child in children:
+        try:
+            child.send_signal(signal.SIGTERM)
+            child.wait(timeout=5)
+        except psutil.TimeoutExpired:
+            child.kill()
+        except psutil.NoSuchProcess:
+            pass
+    try:
+        process.terminate()
+        process.wait(timeout=5)
+    except psutil.TimeoutExpired:
+        process.kill()
+    except psutil.NoSuchProcess:
+        pass

tasks/tasksmith-b71e9e0a47b6/tests/source/trl/__init__.py

@@ -0,0 +1,132 @@
+# 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 importlib.metadata import PackageNotFoundError, version
+from typing import TYPE_CHECKING
+
+from . import _compat
+from ._lazy_module import _LazyModule
+
+
+try:
+    __version__ = version("trl")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+_import_structure = {
+    "chat_template_utils": [
+        "add_response_schema",
+        "clone_chat_template",
+        "get_training_chat_template",
+        "supports_tool_calling",
+    ],
+    "data_utils": [
+        "apply_chat_template",
+        "extract_prompt",
+        "is_conversational",
+        "is_conversational_from_value",
+        "maybe_apply_chat_template",
+        "maybe_convert_to_chatml",
+        "maybe_extract_prompt",
+        "maybe_unpair_preference_dataset",
+        "pack_dataset",
+        "prepare_multimodal_messages",
+        "prepare_multimodal_messages_vllm",
+        "unpair_preference_dataset",
+    ],
+    "models": ["create_reference_model"],
+    "scripts": ["DatasetMixtureConfig", "ScriptArguments", "TrlParser", "get_dataset", "init_zero_verbose"],
+    "trainer": [
+        "BEMACallback",
+        "DPOConfig",
+        "DPOTrainer",
+        "GRPOConfig",
+        "GRPOTrainer",
+        "KTOConfig",
+        "KTOTrainer",
+        "LogCompletionsCallback",
+        "ModelConfig",
+        "RewardConfig",
+        "RewardTrainer",
+        "RichProgressCallback",
+        "RLOOConfig",
+        "RLOOTrainer",
+        "SFTConfig",
+        "SFTTrainer",
+        "SyncRefModelCallback",
+        "WeaveCallback",
+        "get_kbit_device_map",
+        "get_peft_config",
+        "get_quantization_config",
+    ],
+}
+
+if TYPE_CHECKING:
+    from .chat_template_utils import (
+        add_response_schema,
+        clone_chat_template,
+        get_training_chat_template,
+        supports_tool_calling,
+    )
+    from .data_utils import (
+        apply_chat_template,
+        extract_prompt,
+        is_conversational,
+        is_conversational_from_value,
+        maybe_apply_chat_template,
+        maybe_convert_to_chatml,
+        maybe_extract_prompt,
+        maybe_unpair_preference_dataset,
+        pack_dataset,
+        prepare_multimodal_messages,
+        prepare_multimodal_messages_vllm,
+        unpair_preference_dataset,
+    )
+    from .models import create_reference_model
+    from .scripts import DatasetMixtureConfig, ScriptArguments, TrlParser, get_dataset, init_zero_verbose
+    from .trainer import (
+        BEMACallback,
+        DPOConfig,
+        DPOTrainer,
+        GRPOConfig,
+        GRPOTrainer,
+        KTOConfig,
+        KTOTrainer,
+        LogCompletionsCallback,
+        ModelConfig,
+        RewardConfig,
+        RewardTrainer,
+        RichProgressCallback,
+        RLOOConfig,
+        RLOOTrainer,
+        SFTConfig,
+        SFTTrainer,
+        SyncRefModelCallback,
+        WeaveCallback,
+        get_kbit_device_map,
+        get_peft_config,
+        get_quantization_config,
+    )
+
+else:
+    import sys
+
+    sys.modules[__name__] = _LazyModule(
+        __name__,
+        globals()["__file__"],
+        _import_structure,
+        module_spec=__spec__,
+        extra_objects={"__version__": __version__},
+    )

tasks/tasksmith-b71e9e0a47b6/tests/source/trl/_compat.py

@@ -0,0 +1,164 @@
+# 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.
+
+"""
+Compatibility shims for third-party dependencies.
+
+This module contains temporary patches to handle version incompatibilities between TRL's dependencies.
+
+Each patch should be removed when minimum version requirements eliminate the need.
+"""
+
+import warnings
+
+from packaging.version import Version
+
+from .import_utils import _is_package_available
+
+
+def _is_package_version_below(package_name: str, version_threshold: str) -> bool:
+    """
+    Check if installed package version is below the given threshold.
+
+    Args:
+        package_name (str): Package name.
+        version_threshold (str): Maximum version threshold.
+
+    Returns:
+        - True if package is installed and version < version_threshold.
+        - False if package is not installed or version >= version_threshold.
+    """
+    try:
+        is_available, version = _is_package_available(package_name, return_version=True)
+        return is_available and Version(version) < Version(version_threshold)
+    except Exception as e:
+        warnings.warn(
+            f"Failed to check {package_name} version against {version_threshold}: {e}. "
+            f"Compatibility patch may not be applied.",
+            stacklevel=2,
+        )
+        return False
+
+
+def _is_package_version_at_least(package_name: str, version_threshold: str) -> bool:
+    """
+    Check if installed package version is at least the given threshold.
+
+    Args:
+        package_name (str): Package name.
+        version_threshold (str): Minimum version threshold.
+
+    Returns:
+        - True if package is installed and version >= version_threshold.
+        - False if package is not installed or version < version_threshold.
+    """
+    try:
+        is_available, version = _is_package_available(package_name, return_version=True)
+        return is_available and Version(version) >= Version(version_threshold)
+    except Exception as e:
+        warnings.warn(
+            f"Failed to check {package_name} version against {version_threshold}: {e}. "
+            f"Compatibility patch may not be applied.",
+            stacklevel=2,
+        )
+        return False
+
+
+def _patch_vllm_logging() -> None:
+    """Set vLLM logging level to ERROR by default to reduce noise."""
+    if _is_package_available("vllm"):
+        import os
+
+        os.environ["VLLM_LOGGING_LEVEL"] = os.getenv("VLLM_LOGGING_LEVEL", "ERROR")
+
+
+def _patch_transformers_hybrid_cache() -> None:
+    """
+    Fix HybridCache import for transformers v5 compatibility.
+
+    - Issue: peft import HybridCache from transformers.cache_utils
+    - HybridCache removed in https://github.com/huggingface/transformers/pull/43168 (transformers>=5.0.0)
+    - Fixed in peft: https://github.com/huggingface/peft/pull/2735 (released in v0.18.0)
+    - This can be removed when TRL requires peft>=0.18.0
+    """
+    if _is_package_version_at_least("transformers", "5.0.0") and _is_package_version_below("peft", "0.18.0"):
+        try:
+            import transformers.cache_utils
+            from transformers.utils.import_utils import _LazyModule
+
+            Cache = transformers.cache_utils.Cache
+
+            # Patch for liger_kernel: Add HybridCache as an alias for Cache in the cache_utils module
+            transformers.cache_utils.HybridCache = Cache
+
+            # Patch for peft: Patch _LazyModule.__init__ to add HybridCache to transformers' lazy loading structures
+            _original_lazy_module_init = _LazyModule.__init__
+
+            def _patched_lazy_module_init(self, name, *args, **kwargs):
+                _original_lazy_module_init(self, name, *args, **kwargs)
+                if name == "transformers":
+                    # Update _LazyModule's internal structures
+                    if hasattr(self, "_import_structure") and "cache_utils" in self._import_structure:
+                        if "HybridCache" not in self._import_structure["cache_utils"]:
+                            self._import_structure["cache_utils"].append("HybridCache")
+
+                    if hasattr(self, "_class_to_module"):
+                        self._class_to_module["HybridCache"] = "cache_utils"
+
+                    if hasattr(self, "__all__") and "HybridCache" not in self.__all__:
+                        self.__all__.append("HybridCache")
+
+                    self.HybridCache = Cache
+
+            _LazyModule.__init__ = _patched_lazy_module_init
+
+        except Exception as e:
+            warnings.warn(f"Failed to patch transformers HybridCache compatibility: {e}", stacklevel=2)
+
+
+def _patch_transformers_parallelism_config() -> None:
+    """
+    Fix ParallelismConfig for transformers compatibility.
+
+    Ensure that ``transformers.training_args`` always defines the symbol `ParallelismConfig` so that Python's
+    `typing.get_type_hints` can resolve annotations on `transformers.TrainingArguments` without raising a `NameError`.
+
+    This is needed when running with ``accelerate<1.10.1``, where the module ``accelerate.parallelism_config`` did not
+    exist and therefore the type alias is not imported by Transformers.
+
+    See upstream fix PR in transformers#40818.
+
+    - Issue: transformers imports ParallelismConfig only if accelerate>=1.10.1 and raises NameError if
+      accelerate<1.10.1
+    - Fixed in transformers: https://github.com/huggingface/transformers/pull/40818 (released in v4.57.0)
+    - This can be removed when TRL requires transformers>=4.57.0 or accelerate>=1.10.1
+    """
+    if _is_package_version_below("transformers", "4.57.0") and _is_package_version_below("accelerate", "1.10.1"):
+        try:
+            from typing import Any
+
+            import transformers.training_args
+
+            if not hasattr(transformers.training_args, "ParallelismConfig"):
+                transformers.training_args.ParallelismConfig = Any
+        except Exception as e:
+            warnings.warn(f"Failed to patch transformers ParallelismConfig compatibility: {e}", stacklevel=2)
+
+
+# Apply vLLM patches
+_patch_vllm_logging()
+
+# Apply transformers patches
+_patch_transformers_hybrid_cache()
+_patch_transformers_parallelism_config()  # before creating HfArgumentParser

tasks/tasksmith-b71e9e0a47b6/tests/source/trl/_lazy_module.py

@@ -0,0 +1,79 @@
+# 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 os
+from itertools import chain
+from types import ModuleType
+from typing import Any
+
+
+class _LazyModule(ModuleType):
+    """
+    Module class that surfaces all objects but only performs associated imports when the objects are requested.
+    """
+
+    # Very heavily inspired by optuna.integration._IntegrationModule
+    # https://github.com/optuna/optuna/blob/master/optuna/integration/__init__.py
+    def __init__(self, name, module_file, import_structure, module_spec=None, extra_objects=None):
+        super().__init__(name)
+        self._modules = set(import_structure.keys())
+        self._class_to_module = {}
+        for key, values in import_structure.items():
+            for value in values:
+                self._class_to_module[value] = key
+        # Needed for autocompletion in an IDE
+        self.__all__ = list(import_structure.keys()) + list(chain(*import_structure.values()))
+        self.__file__ = module_file
+        self.__spec__ = module_spec
+        self.__path__ = [os.path.dirname(module_file)]
+        self._objects = {} if extra_objects is None else extra_objects
+        self._name = name
+        self._import_structure = import_structure
+
+    # Needed for autocompletion in an IDE
+    def __dir__(self):
+        result = super().__dir__()
+        # The elements of self.__all__ that are submodules may or may not be in the dir already, depending on whether
+        # they have been accessed or not. So we only add the elements of self.__all__ that are not already in the dir.
+        for attr in self.__all__:
+            if attr not in result:
+                result.append(attr)
+        return result
+
+    def __getattr__(self, name: str) -> Any:
+        if name in self._objects:
+            return self._objects[name]
+        if name in self._modules:
+            value = self._get_module(name)
+        elif name in self._class_to_module.keys():
+            module = self._get_module(self._class_to_module[name])
+            value = getattr(module, name)
+        else:
+            raise AttributeError(f"module {self.__name__} has no attribute {name}")
+
+        setattr(self, name, value)
+        return value
+
+    def _get_module(self, module_name: str):
+        try:
+            return importlib.import_module("." + module_name, self.__name__)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to import {self.__name__}.{module_name} because of the following error (look up to see its"
+                f" traceback):\n{e}"
+            ) from e
+
+    def __reduce__(self):
+        return (self.__class__, (self._name, self.__file__, self._import_structure))

tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/fsdp1.yaml

@@ -0,0 +1,28 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: FSDP
+downcast_bf16: 'no'
+enable_cpu_affinity: false
+fsdp_config:
+  fsdp_activation_checkpointing: false
+  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
+  fsdp_backward_prefetch: BACKWARD_PRE
+  fsdp_cpu_ram_efficient_loading: true
+  fsdp_forward_prefetch: true
+  fsdp_offload_params: false
+  fsdp_reshard_after_forward: FULL_SHARD
+  fsdp_state_dict_type: FULL_STATE_DICT
+  fsdp_sync_module_states: true
+  fsdp_use_orig_params: true
+  fsdp_version: 1
+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