"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "* NVIDIA GPU detected, enabling automatic GPU metrics logging\n",
+ "* Created new run: sergiopaniego-1773149018\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/usr/local/lib/python3.12/dist-packages/transformers/models/nemotron_h/modeling_nemotron_h.py:1215: FutureWarning: `input_embeds` is deprecated and will be removed in version 5.6.0 for `create_causal_mask`. Use `inputs_embeds` instead.\n",
+ " causal_mask = create_causal_mask(\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ " \n",
+ " \n",
+ "
\n",
+ " [250/250 08:53, Epoch 1/1]\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | Step | \n",
+ " Training Loss | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 10 | \n",
+ " 2.379619 | \n",
+ "
\n",
+ " \n",
+ " | 20 | \n",
+ " 1.849189 | \n",
+ "
\n",
+ " \n",
+ " | 30 | \n",
+ " 1.466606 | \n",
+ "
\n",
+ " \n",
+ " | 40 | \n",
+ " 1.207237 | \n",
+ "
\n",
+ " \n",
+ " | 50 | \n",
+ " 1.064882 | \n",
+ "
\n",
+ " \n",
+ " | 60 | \n",
+ " 1.067329 | \n",
+ "
\n",
+ " \n",
+ " | 70 | \n",
+ " 1.085463 | \n",
+ "
\n",
+ " \n",
+ " | 80 | \n",
+ " 0.964451 | \n",
+ "
\n",
+ " \n",
+ " | 90 | \n",
+ " 0.993209 | \n",
+ "
\n",
+ " \n",
+ " | 100 | \n",
+ " 1.061509 | \n",
+ "
\n",
+ " \n",
+ " | 110 | \n",
+ " 0.976885 | \n",
+ "
\n",
+ " \n",
+ " | 120 | \n",
+ " 0.939225 | \n",
+ "
\n",
+ " \n",
+ " | 130 | \n",
+ " 1.011990 | \n",
+ "
\n",
+ " \n",
+ " | 140 | \n",
+ " 0.989627 | \n",
+ "
\n",
+ " \n",
+ " | 150 | \n",
+ " 0.946731 | \n",
+ "
\n",
+ " \n",
+ " | 160 | \n",
+ " 0.939989 | \n",
+ "
\n",
+ " \n",
+ " | 170 | \n",
+ " 0.920945 | \n",
+ "
\n",
+ " \n",
+ " | 180 | \n",
+ " 1.003975 | \n",
+ "
\n",
+ " \n",
+ " | 190 | \n",
+ " 0.945233 | \n",
+ "
\n",
+ " \n",
+ " | 200 | \n",
+ " 0.958358 | \n",
+ "
\n",
+ " \n",
+ " | 210 | \n",
+ " 1.022524 | \n",
+ "
\n",
+ " \n",
+ " | 220 | \n",
+ " 0.953711 | \n",
+ "
\n",
+ " \n",
+ " | 230 | \n",
+ " 1.033258 | \n",
+ "
\n",
+ " \n",
+ " | 240 | \n",
+ " 0.955309 | \n",
+ "
\n",
+ " \n",
+ " | 250 | \n",
+ " 0.959105 | \n",
+ "
\n",
+ " \n",
+ "
"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "* Run finished. Uploading logs to Trackio Space (please wait...)\n"
+ ]
+ }
+ ],
+ "source": [
+ "trainer_stats = trainer.train()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ngrmymxpbp",
+ "metadata": {
+ "id": "ngrmymxpbp"
+ },
+ "source": [
+ "Show memory stats after training:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "08gpt482fn1k",
+ "metadata": {
+ "id": "08gpt482fn1k",
+ "outputId": "e4808857-5756-4f5d-d34c-29c81107a618"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "542.949 seconds used for training.\n",
+ "9.05 minutes used for training.\n",
+ "Peak reserved memory = 61.922 GB.\n",
+ "Peak reserved memory for training = 2.983 GB.\n",
+ "Peak reserved memory % of max memory = 78.134 %.\n",
+ "Peak reserved memory for training % of max memory = 3.764 %.\n"
+ ]
+ }
+ ],
+ "source": [
+ "used_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)\n",
+ "used_memory_for_lora = round(used_memory - start_gpu_memory, 3)\n",
+ "used_percentage = round(used_memory / max_memory * 100, 3)\n",
+ "lora_percentage = round(used_memory_for_lora / max_memory * 100, 3)\n",
+ "\n",
+ "print(f\"{trainer_stats.metrics['train_runtime']} seconds used for training.\")\n",
+ "print(f\"{round(trainer_stats.metrics['train_runtime']/60, 2)} minutes used for training.\")\n",
+ "print(f\"Peak reserved memory = {used_memory} GB.\")\n",
+ "print(f\"Peak reserved memory for training = {used_memory_for_lora} GB.\")\n",
+ "print(f\"Peak reserved memory % of max memory = {used_percentage} %.\")\n",
+ "print(f\"Peak reserved memory for training % of max memory = {lora_percentage} %.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "pkp4wfpwpxh",
+ "metadata": {
+ "id": "pkp4wfpwpxh"
+ },
+ "source": [
+ "## Save fine-tuned model\n",
+ "\n",
+ "Save the fine-tuned model both **locally** and to the **Hugging Face Hub**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "g2j7qp1ycxl",
+ "metadata": {
+ "id": "g2j7qp1ycxl",
+ "outputId": "5791fc37-589b-4bb9-ca66-85434b303787",
+ "colab": {
+ "referenced_widgets": [
+ "20def6e82e1d4b69ae1b677a39a54bfc",
+ "53fe5574751540b68f2d6ef047cccc3c",
+ "3661c026040f44f3870921e8a2db7bd2",
+ "61b4f98716b649dc88332367852ec89c",
+ "a61820f54e5445ceaf27efa956212271",
+ "d761f8d2a0ff4de2a8728a1998e5f919",
+ "3fea49f4e519416f81af219023d45c34",
+ "240c5e45b5f245f984cdaaea9ff3a380",
+ "7ba75fdca7da467cacc407da59382376",
+ "2b3e22abd6704ef6b5cb2455c6fa98ab"
+ ]
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "20def6e82e1d4b69ae1b677a39a54bfc",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Processing Files (0 / 0) : | | 0.00B / 0.00B "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "53fe5574751540b68f2d6ef047cccc3c",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "New Data Upload : | | 0.00B / 0.00B "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "3661c026040f44f3870921e8a2db7bd2",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ " ...n-3-sft/training_args.bin: 100%|##########| 5.58kB / 5.58kB "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "61b4f98716b649dc88332367852ec89c",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ " ...adapter_model.safetensors: 100%|##########| 13.2MB / 13.2MB "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "a61820f54e5445ceaf27efa956212271",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ " ...tron-3-sft/tokenizer.json: 100%|##########| 17.1MB / 17.1MB "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "d761f8d2a0ff4de2a8728a1998e5f919",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Processing Files (0 / 0) : | | 0.00B / 0.00B "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "3fea49f4e519416f81af219023d45c34",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "New Data Upload : | | 0.00B / 0.00B "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "240c5e45b5f245f984cdaaea9ff3a380",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ " ...n-3-sft/training_args.bin: 100%|##########| 5.58kB / 5.58kB "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "7ba75fdca7da467cacc407da59382376",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ " ...tron-3-sft/tokenizer.json: 100%|##########| 17.1MB / 17.1MB "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "2b3e22abd6704ef6b5cb2455c6fa98ab",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ " ...adapter_model.safetensors: 100%|##########| 13.2MB / 13.2MB "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.google.colaboratory.intrinsic+json": {
+ "type": "string"
+ },
+ "text/plain": [
+ "CommitInfo(commit_url='https://huggingface.co/sergiopaniego/nemotron-3-sft/commit/dd05a083358e10113019b06da76c3e9ab4c4c3e4', commit_message='End of training', commit_description='', oid='dd05a083358e10113019b06da76c3e9ab4c4c3e4', pr_url=None, repo_url=RepoUrl('https://huggingface.co/sergiopaniego/nemotron-3-sft', endpoint='https://huggingface.co', repo_type='model', repo_id='sergiopaniego/nemotron-3-sft'), pr_revision=None, pr_num=None)"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "trainer.save_model(output_dir)\n",
+ "trainer.push_to_hub(dataset_name=dataset_name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "jp3u13oqlye",
+ "metadata": {
+ "id": "jp3u13oqlye"
+ },
+ "source": [
+ "## Inference\n",
+ "\n",
+ "Let's run the fine-tuned model using standard `transformers` generation (`model.generate`)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1tb9jai824gi",
+ "metadata": {
+ "id": "1tb9jai824gi"
+ },
+ "outputs": [],
+ "source": [
+ "model = trainer.model\n",
+ "model.eval()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3zp0i0zw4je",
+ "metadata": {
+ "id": "3zp0i0zw4je"
+ },
+ "outputs": [],
+ "source": [
+ "messages = [{\"role\": \"user\", \"content\": \"Continue the sequence: 1, 1, 2, 3, 5, 8,\"}]\n",
+ "text = tokenizer.apply_chat_template(\n",
+ " messages,\n",
+ " tokenize=False,\n",
+ " add_generation_prompt=True,\n",
+ ")\n",
+ "\n",
+ "from transformers import TextStreamer\n",
+ "\n",
+ "_ = model.generate(\n",
+ " **tokenizer(text, return_tensors=\"pt\").to(\"cuda\"),\n",
+ " max_new_tokens=128,\n",
+ " temperature=0.7,\n",
+ " top_p=0.8,\n",
+ " top_k=20,\n",
+ " streamer=TextStreamer(tokenizer, skip_prompt=True),\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "language_info": {
+ "name": "python"
+ },
+ "colab": {
+ "provenance": [],
+ "machine_shape": "hm",
+ "gpuType": "A100"
+ },
+ "accelerator": "GPU"
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/notebooks/sft_qwen_vl.ipynb b/tasks/tasksmith-466b1e8e082b/tests/source/examples/notebooks/sft_qwen_vl.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..2cd50fbf5b67856faefc3290ae3da9959a9f9480
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/notebooks/sft_qwen_vl.ipynb
@@ -0,0 +1,515 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "UaDIwQOOjgAO"
+ },
+ "source": [
+ "# Supervised Fine-Tuning (SFT) Qwen3-VL with QLoRA using TRL\n",
+ "\n",
+ "[](https://colab.research.google.com/github/huggingface/trl/blob/main/examples/notebooks/sft_qwen_vl.ipynb)\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "4f0hzSo4kKEc"
+ },
+ "source": [
+ "With [**Transformers Reinforcement Learning (TRL)**](https://github.com/huggingface/trl), you can fine-tune cutting edge vision language models. It comes with support for quantized parameter efficient fine-tuning technique **QLoRA**, so we can use free Colab (T4 GPU) to fine-tune models like [Qwen3-VL](https://huggingface.co/collections/Qwen/qwen3-vl-68d2a7c1b8a8afce4ebd2dbe).\n",
+ "\n",
+ "\n",
+ "- [TRL GitHub Repository](https://github.com/huggingface/trl) — star us to support the project! \n",
+ "- [Official TRL Examples](https://huggingface.co/docs/trl/example_overview) \n",
+ "- [Community Tutorials](https://huggingface.co/docs/trl/community_tutorials)\n",
+ "- [More Qwen3-VL Fine-tuning Examples (including TRL scripts)](https://github.com/QwenLM/Qwen3-VL/tree/main/qwen-vl-finetune/)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "pGXgIbj2kXEP"
+ },
+ "source": [
+ "## Install dependencies\n",
+ "\n",
+ "We'll install **TRL** with the **PEFT** extra, which ensures all main dependencies such as **Transformers** and **PEFT** (a package for parameter-efficient fine-tuning, e.g., LoRA/QLoRA) are included. Additionally, we'll install **trackio** to log and monitor our experiments, and **bitsandbytes** to enable quantization of LLMs, reducing memory consumption for both inference and training."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "8CfZlUevmkg7"
+ },
+ "outputs": [],
+ "source": [
+ "!pip install -Uq \"trl[peft]\" bitsandbytes trackio"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Ou0VO1gHklS-"
+ },
+ "source": [
+ "### Log in to Hugging Face\n",
+ "\n",
+ "Log in to your **Hugging Face** account to save your fine-tuned model, track your experiment results directly on the Hub or access gated models. You can find your **access token** on your [account settings page](https://huggingface.co/settings/tokens)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "4Ncx0wYtnYCW"
+ },
+ "outputs": [],
+ "source": [
+ "from huggingface_hub import notebook_login\n",
+ "\n",
+ "notebook_login()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "vNylrNdqkoN-"
+ },
+ "source": [
+ "## Load dataset\n",
+ "\n",
+ "\n",
+ "We'll load the [**trl-lib/llava-instruct-mix**](https://huggingface.co/datasets/trl-lib/llava-instruct-mix) dataset from the Hugging Face Hub using the `datasets` library.\n",
+ "\n",
+ "This dataset is a set of GPT-generated multimodal instruction-following data. We use a processed version for conveniency here. You can check out more details about how to configure your own multimodal dataset for traininig with SFT in the [docs](https://huggingface.co/docs/trl/en/sft_trainer#training-vision-language-models). Fine-tuning Qwen3-VL on it helps refine its response style and visual understanding.\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "0AcyX6Jd1_hp"
+ },
+ "outputs": [],
+ "source": [
+ "from datasets import load_dataset\n",
+ "\n",
+ "dataset_name = \"trl-lib/llava-instruct-mix\"\n",
+ "train_dataset = load_dataset(dataset_name, split=\"train[:10%]\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "JFtR4Xyx4FYO"
+ },
+ "source": [
+ "Let's review one example to understand the internal structure:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "YLrEY_v8m0eA"
+ },
+ "outputs": [],
+ "source": [
+ "train_dataset[0]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "qeZCtRB1m5xj"
+ },
+ "source": [
+ "## Load model and configure LoRA/QLoRA\n",
+ "\n",
+ "This notebook can be used with two fine-tuning methods. By default, it is set up for **QLoRA**, which includes quantization using `BitsAndBytesConfig`. If you prefer to use standard **LoRA** without quantization, simply comment out the `BitsAndBytesConfig` configuration."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "gt05dgXgm9QR"
+ },
+ "outputs": [],
+ "source": [
+ "from transformers import Qwen3VLForConditionalGeneration, BitsAndBytesConfig\n",
+ "import torch\n",
+ "\n",
+ "model_name = \"Qwen/Qwen3-VL-4B-Instruct\" # \"Qwen/Qwen3-VL-8B-Instruct\"\n",
+ "\n",
+ "model = Qwen3VLForConditionalGeneration.from_pretrained(\n",
+ " model_name,\n",
+ " dtype=\"float32\",\n",
+ " device_map=\"auto\",\n",
+ " quantization_config=BitsAndBytesConfig(\n",
+ " load_in_4bit=True, # Load the model in 4-bit precision to save memory\n",
+ " bnb_4bit_compute_dtype=torch.float16, # Data type used for internal computations in quantization\n",
+ " bnb_4bit_use_double_quant=True, # Use double quantization to improve accuracy\n",
+ " bnb_4bit_quant_type=\"nf4\" # Type of quantization. \"nf4\" is recommended for recent LLMs\n",
+ " )\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "jyklRvNxnHmy"
+ },
+ "source": [
+ "The following cell defines LoRA (or QLoRA if needed). When training with LoRA/QLoRA, we use a **base model** (the one selected above) and, instead of modifying its original weights, we fine-tune a **LoRA adapter** — a lightweight layer that enables efficient and memory-friendly training. The **`target_modules`** specify which parts of the model (e.g., attention or projection layers) will be adapted by LoRA during fine-tuning."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "ME1im5gh2LFg"
+ },
+ "outputs": [],
+ "source": [
+ "from peft import LoraConfig\n",
+ "\n",
+ "# You may need to update `target_modules` depending on the architecture of your chosen model.\n",
+ "# For example, different VLMs might have different attention/projection layer names.\n",
+ "peft_config = LoraConfig(\n",
+ " r=32,\n",
+ " lora_alpha=32,\n",
+ " target_modules=['down_proj','o_proj','k_proj','q_proj','gate_proj','up_proj','v_proj'],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "mBAfaiA-nbdm"
+ },
+ "source": [
+ "## Train model\n",
+ "\n",
+ "We'll configure **SFT** using `SFTConfig`, keeping the parameters minimal so the training fits on a free Colab instance. You can adjust these settings if more resources are available. For full details on all available parameters, check the [TRL SFTConfig documentation](https://huggingface.co/docs/trl/sft_trainer#trl.SFTConfig)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "GQPxXvu-2Ngc"
+ },
+ "outputs": [],
+ "source": [
+ "from trl import SFTConfig\n",
+ "\n",
+ "output_dir = \"Qwen3-VL-4B-Instruct-trl-sft\"\n",
+ "\n",
+ "# Configure training arguments using SFTConfig\n",
+ "training_args = SFTConfig(\n",
+ " # Training schedule / optimization\n",
+ " #num_train_epochs=1,\n",
+ " max_steps=10, # Number of dataset passes. For full trainings, use `num_train_epochs` instead\n",
+ " per_device_train_batch_size=2, # Batch size per GPU/CPU\n",
+ " gradient_accumulation_steps=8, # Gradients are accumulated over multiple steps → effective batch size = 4 * 8 = 32\n",
+ " warmup_steps=5, # Gradually increase LR during first N steps\n",
+ " learning_rate=2e-4, # Learning rate for the optimizer\n",
+ " optim=\"adamw_8bit\", # Optimizer\n",
+ " max_length=None, # For VLMs, truncating may remove image tokens, leading to errors during training. max_length=None avoids it\n",
+ "\n",
+ " # Logging / reporting\n",
+ " output_dir=output_dir, # Where to save model checkpoints and logs\n",
+ " logging_steps=1, # Log training metrics every N steps\n",
+ " report_to=\"trackio\", # Experiment tracking tool\n",
+ "\n",
+ " # Hub integration\n",
+ " push_to_hub=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "bF4GtNO2ne1k"
+ },
+ "source": [
+ "Configure the SFT Trainer. We pass the previously configured `training_args`. We don't use eval dataset to maintain memory usage low but you can configure it."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "TwBeQKQC2RfZ"
+ },
+ "outputs": [],
+ "source": [
+ "from trl import SFTTrainer\n",
+ "\n",
+ "trainer = SFTTrainer(\n",
+ " model=model,\n",
+ " args=training_args,\n",
+ " train_dataset=train_dataset,\n",
+ " peft_config=peft_config,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "K9Ub3jTDnfcD"
+ },
+ "source": [
+ "Show memory stats before training"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "u6_Vsv_1KtVU"
+ },
+ "outputs": [],
+ "source": [
+ "gpu_stats = torch.cuda.get_device_properties(0)\n",
+ "start_gpu_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)\n",
+ "max_memory = round(gpu_stats.total_memory / 1024 / 1024 / 1024, 3)\n",
+ "\n",
+ "print(f\"GPU = {gpu_stats.name}. Max memory = {max_memory} GB.\")\n",
+ "print(f\"{start_gpu_memory} GB of memory reserved.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "4NiFu9tcniBP"
+ },
+ "source": [
+ "And train!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "pbJXrhA0ywra"
+ },
+ "outputs": [],
+ "source": [
+ "trainer_stats = trainer.train()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "miZ2I1A9nnM4"
+ },
+ "source": [
+ "Show memory stats after training"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "8jegvQGlKyEu"
+ },
+ "outputs": [],
+ "source": [
+ "used_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)\n",
+ "used_memory_for_lora = round(used_memory - start_gpu_memory, 3)\n",
+ "used_percentage = round(used_memory / max_memory * 100, 3)\n",
+ "lora_percentage = round(used_memory_for_lora / max_memory * 100, 3)\n",
+ "\n",
+ "print(f\"{trainer_stats.metrics['train_runtime']} seconds used for training.\")\n",
+ "print(f\"{round(trainer_stats.metrics['train_runtime']/60, 2)} minutes used for training.\")\n",
+ "print(f\"Peak reserved memory = {used_memory} GB.\")\n",
+ "print(f\"Peak reserved memory for training = {used_memory_for_lora} GB.\")\n",
+ "print(f\"Peak reserved memory % of max memory = {used_percentage} %.\")\n",
+ "print(f\"Peak reserved memory for training % of max memory = {lora_percentage} %.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "3lrrYfPunloQ"
+ },
+ "source": [
+ "## Saving fine tuned model\n",
+ "\n",
+ "In this step, we save the fine-tuned model both **locally** and to the **Hugging Face Hub** using the credentials from your account."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "MNfRlfIGKSHI"
+ },
+ "outputs": [],
+ "source": [
+ "trainer.save_model(output_dir)\n",
+ "trainer.push_to_hub(dataset_name=dataset_name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "pFq51FWEK1DX"
+ },
+ "source": [
+ "## Load the fine-tuned model and run inference\n",
+ "\n",
+ "Now, let's test our fine-tuned model by loading the **LoRA/QLoRA adapter** and performing **inference**. We'll start by loading the **base model**, then attach the adapter to it, creating the final fine-tuned model ready for evaluation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "wAm1iQc8K1uY"
+ },
+ "outputs": [],
+ "source": [
+ "from transformers import Qwen3VLForConditionalGeneration, AutoProcessor\n",
+ "from peft import PeftModel\n",
+ "\n",
+ "base_model = model_name\n",
+ "adapter_model = f\"{output_dir}\" # Replace with your HF username or organization + fine-tuned model name\n",
+ "\n",
+ "model = Qwen3VLForConditionalGeneration.from_pretrained(base_model, dtype=\"float32\", device_map=\"auto\")\n",
+ "model = PeftModel.from_pretrained(model, adapter_model)\n",
+ "\n",
+ "processor = AutoProcessor.from_pretrained(base_model)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "a5rLWJdOvwGQ"
+ },
+ "outputs": [],
+ "source": [
+ "problem = train_dataset[0]['prompt'][0]['content']\n",
+ "image = train_dataset[0]['images'][0]\n",
+ "\n",
+ "messages = [\n",
+ " {\n",
+ " \"role\": \"user\",\n",
+ " \"content\": [\n",
+ " {\"type\": \"image\", \"image\": image},\n",
+ " {\"type\": \"text\", \"text\": problem},\n",
+ " ],\n",
+ " },\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "qiu-ROFeBPhA"
+ },
+ "outputs": [],
+ "source": [
+ "messages"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 497
+ },
+ "id": "qGzEXSH5BQwG",
+ "outputId": "611d6bfd-fb72-4737-e847-1611132d49ed"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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",
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "image"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "SG64xtCtv24-",
+ "outputId": "cdc347b4-cdf2-49c8-e308-71dc99f27476"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[\"The presentation of this meal can influence one's eating experience by making it more visually appealing and appetizing. The vibrant colors of the fruits, vegetables, and bread, as well as the careful arrangement of the food in the colorful containers, can create a sense of variety and abundance. This can make the meal more enjoyable and satisfying to eat, encouraging individuals to eat more and feel more satisfied after eating. Additionally, the presentation can make the meal more inviting and appealing to others, increasing the likelihood that they will eat it.\"]\n"
+ ]
+ }
+ ],
+ "source": [
+ "inputs = processor.apply_chat_template(\n",
+ " messages,\n",
+ " add_generation_prompt=True,\n",
+ " tokenize=True,\n",
+ " return_tensors=\"pt\"\n",
+ " return_dict=True,\n",
+ ").to(model.device)\n",
+ "\n",
+ "# Inference: Generation of the output\n",
+ "generated_ids = model.generate(**inputs, max_new_tokens=128)\n",
+ "generated_ids_trimmed = [\n",
+ " out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)\n",
+ "]\n",
+ "output_text = processor.batch_decode(\n",
+ " generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False\n",
+ ")\n",
+ "print(output_text)"
+ ]
+ }
+ ],
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "gpuType": "T4",
+ "provenance": []
+ },
+ "kernelspec": {
+ "display_name": "Python 3",
+ "name": "python3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/notebooks/sft_tool_calling.ipynb b/tasks/tasksmith-466b1e8e082b/tests/source/examples/notebooks/sft_tool_calling.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..f474eb3cd7ea2fc786a5d5eb60110913ec571623
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/notebooks/sft_tool_calling.ipynb
@@ -0,0 +1,1233 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ii5Zkit6eSqU"
+ },
+ "source": [
+ "# Teaching Tool Calling with Supervised Fine-Tuning (SFT) using TRL on a Free Colab Notebook\n",
+ "\n",
+ "[](https://colab.research.google.com/github/huggingface/trl/blob/main/examples/notebooks/sft_tool_calling.ipynb)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "gJVcVKOteSqV"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "hzt0BrvoeSqW"
+ },
+ "source": [
+ "Learn how to teach a language model to perform **tool calling** using **Supervised Fine-Tuning (SFT)** with **LoRA/QLoRA** and the [**TRL**](https://github.com/huggingface/trl) library.\n",
+ "\n",
+ "The model used in this notebook does not have native tool-calling support. We extend its Jinja2 chat template (via `tiny_aya_chat_template.jinja`) to serialize tool schemas into the system preamble and render tool calls as structured `` XML inside the model's native `<|START_RESPONSE|>` / `<|END_RESPONSE|>` delimiters. The modified template is saved with the tokenizer, making inference reproducible: just load the tokenizer from the output directory and call `apply_chat_template` with `tools=TOOLS`.\n",
+ "\n",
+ "- [TRL GitHub Repository](https://github.com/huggingface/trl) — star us to support the project!\n",
+ "- [Official TRL Examples](https://huggingface.co/docs/trl/example_overview)\n",
+ "- [Community Tutorials](https://huggingface.co/docs/trl/community_tutorials)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "3PfX1aj5eSqW"
+ },
+ "source": [
+ "## Key concepts\n",
+ "\n",
+ "- **SFT**: Trains a model on example input-output pairs to align its behavior with a desired task.\n",
+ "- **Tool Calling**: The ability of a model to respond with a structured function call instead of free-form text.\n",
+ "- **LoRA**: Updates only a small set of low-rank parameters, reducing training cost and memory usage.\n",
+ "- **QLoRA**: A quantized variant of LoRA that enables fine-tuning larger models on limited hardware.\n",
+ "- **TRL**: The Hugging Face library that makes fine-tuning and reinforcement learning simple and efficient."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "QDMcKeoEeSqW"
+ },
+ "source": [
+ "## Install dependencies\n",
+ "\n",
+ "We'll install **TRL** with the **PEFT** extra, which brings in all main dependencies such as **Transformers** and **PEFT** (parameter-efficient fine-tuning). We also install **trackio** for experiment logging, and **bitsandbytes** for 4-bit quantization,"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "Ey-TuYPrXTLG",
+ "outputId": "a4fd8cfe-624e-4185-ab59-e6901514cb96"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.0/1.0 MB\u001b[0m \u001b[31m17.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m60.7/60.7 MB\u001b[0m \u001b[31m42.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.2/24.2 MB\u001b[0m \u001b[31m109.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.0/56.0 kB\u001b[0m \u001b[31m6.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m9.9/9.9 MB\u001b[0m \u001b[31m131.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m540.5/540.5 kB\u001b[0m \u001b[31m44.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[?25h"
+ ]
+ }
+ ],
+ "source": [
+ "!pip install -Uq \"trl[peft]\" trackio bitsandbytes liger-kernel"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Aw8_T-Z0eSqW"
+ },
+ "source": [
+ "### Log in to Hugging Face\n",
+ "\n",
+ "Log in to your Hugging Face account to push the fine-tuned model to the Hub and access gated models. You can find your access token on your [account settings page](https://huggingface.co/settings/tokens)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "_qaeDZwXXTLG"
+ },
+ "outputs": [],
+ "source": [
+ "from huggingface_hub import notebook_login\n",
+ "\n",
+ "notebook_login()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "XPnDpJgIeSqX"
+ },
+ "source": [
+ "## Load Dataset\n",
+ "\n",
+ "We load the [**bebechien/SimpleToolCalling**](https://huggingface.co/datasets/bebechien/SimpleToolCalling) dataset, which contains user queries paired with the correct tool call to handle each request. Each sample provides a `user_content`, a `tool_name`, and `tool_arguments`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "zfJY_8AzXTLG"
+ },
+ "outputs": [],
+ "source": [
+ "from datasets import load_dataset\n",
+ "\n",
+ "dataset_name = \"bebechien/SimpleToolCalling\"\n",
+ "dataset = load_dataset(dataset_name, split=\"train\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "ygeMXzKGXTLH",
+ "outputId": "a1ed3a8b-f515-4cda-eeb2-db0355ed2c02"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Dataset({\n",
+ " features: ['user_content', 'tool_name', 'tool_arguments'],\n",
+ " num_rows: 40\n",
+ "})"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "dataset"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "O_GkvqtReSqX"
+ },
+ "source": [
+ "## Prepare Tool-Calling Data\n",
+ "\n",
+ "We define two tools: `search_knowledge_base` for internal company documents and `search_google` for public information. We then write a custom Jinja2 chat template that extends the model's default template with two additions:\n",
+ "\n",
+ "1. A **Tool Use** section is appended to the system preamble when `tools` is passed to `apply_chat_template`.\n",
+ "2. Assistant turns with `tool_calls` render the call as structured `` inside the model's existing `<|START_RESPONSE|>` / `<|END_RESPONSE|>` delimiters.\n",
+ "\n",
+ "Each training sample uses the standard `tool_calls` message format with a `tools` key — SFTTrainer passes these to `apply_chat_template` automatically."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "jaAgXeWtXTLH"
+ },
+ "outputs": [],
+ "source": [
+ "import json\n",
+ "\n",
+ "# These are the tool schemas that are used in the dataset\n",
+ "TOOLS = [\n",
+ " {\n",
+ " \"type\": \"function\",\n",
+ " \"function\": {\n",
+ " \"name\": \"search_knowledge_base\",\n",
+ " \"description\": \"Search internal company documents, policies and project data.\",\n",
+ " \"parameters\": {\n",
+ " \"type\": \"object\",\n",
+ " \"properties\": {\"query\": {\"type\": \"string\", \"description\": \"query string\"}},\n",
+ " \"required\": [\"query\"],\n",
+ " },\n",
+ " \"return\": {\"type\": \"string\"},\n",
+ " },\n",
+ " },\n",
+ " {\n",
+ " \"type\": \"function\",\n",
+ " \"function\": {\n",
+ " \"name\": \"search_google\",\n",
+ " \"description\": \"Search public information.\",\n",
+ " \"parameters\": {\n",
+ " \"type\": \"object\",\n",
+ " \"properties\": {\"query\": {\"type\": \"string\", \"description\": \"query string\"}},\n",
+ " \"required\": [\"query\"],\n",
+ " },\n",
+ " \"return\": {\"type\": \"string\"},\n",
+ " },\n",
+ " },\n",
+ "]\n",
+ "\n",
+ "def create_conversation(sample):\n",
+ " return {\n",
+ " \"prompt\": [{\"role\": \"user\", \"content\": sample[\"user_content\"]}],\n",
+ " \"completion\": [\n",
+ " {\n",
+ " \"role\": \"assistant\",\n",
+ " \"tool_calls\": [\n",
+ " {\n",
+ " \"type\": \"function\",\n",
+ " \"function\": {\n",
+ " \"name\": sample[\"tool_name\"],\n",
+ " \"arguments\": json.loads(sample[\"tool_arguments\"]),\n",
+ " },\n",
+ " }\n",
+ " ],\n",
+ " },\n",
+ " ],\n",
+ " \"tools\": TOOLS,\n",
+ " }"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "32p512R2XTLH"
+ },
+ "outputs": [],
+ "source": [
+ "dataset = dataset.map(create_conversation, remove_columns=dataset.features)\n",
+ "\n",
+ "# Split dataset into 50% training samples and 50% test samples\n",
+ "dataset = dataset.train_test_split(test_size=0.5, shuffle=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Plnjef-PeSqX"
+ },
+ "source": [
+ "Let's inspect an example from the training set to verify the format:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "f4QI6wJjXTLH",
+ "outputId": "2156adb4-7bed-4e29-84c5-54e6d45e5500"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'messages': [{'content': 'How do I configure the VPN for the New York office?',\n",
+ " 'role': 'user',\n",
+ " 'tool_calls': None},\n",
+ " {'content': None,\n",
+ " 'role': 'assistant',\n",
+ " 'tool_calls': [{'function': {'arguments': {'query': 'VPN configuration guide New York office'},\n",
+ " 'name': 'search_knowledge_base'},\n",
+ " 'type': 'function'}]}],\n",
+ " 'tools': [{'function': {'description': 'Search internal company documents, policies and project data.',\n",
+ " 'name': 'search_knowledge_base',\n",
+ " 'parameters': {'properties': {'query': {'description': 'query string',\n",
+ " 'type': 'string'}},\n",
+ " 'required': ['query'],\n",
+ " 'type': 'object'},\n",
+ " 'return': {'type': 'string'}},\n",
+ " 'type': 'function'},\n",
+ " {'function': {'description': 'Search public information.',\n",
+ " 'name': 'search_google',\n",
+ " 'parameters': {'properties': {'query': {'description': 'query string',\n",
+ " 'type': 'string'}},\n",
+ " 'required': ['query'],\n",
+ " 'type': 'object'},\n",
+ " 'return': {'type': 'string'}},\n",
+ " 'type': 'function'}]}"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "dataset['train'][0]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "fBIGKl_UXTLH",
+ "outputId": "edd8e968-c7e4-418d-b9e9-26773aee1366"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "DatasetDict({\n",
+ " train: Dataset({\n",
+ " features: ['messages', 'tools'],\n",
+ " num_rows: 20\n",
+ " })\n",
+ " test: Dataset({\n",
+ " features: ['messages', 'tools'],\n",
+ " num_rows: 20\n",
+ " })\n",
+ "})"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "dataset"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "aud6U3c2eSqX"
+ },
+ "source": [
+ "## Load Model and Configure LoRA/QLoRA\n",
+ "\n",
+ "Choose the model you want to fine-tune. This notebook uses [`CohereLabs/tiny-aya-global`](https://huggingface.co/CohereLabs/tiny-aya-global) by default."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "_j_LF12IXTLH"
+ },
+ "outputs": [],
+ "source": [
+ "model_id, output_dir = \"CohereLabs/tiny-aya-global\", \"tiny-aya-global-SFT\" # ✅ ~9.1 GB VRAM"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "gpTZHjpJeSqX"
+ },
+ "source": [
+ "Load the model with 4-bit quantization using `BitsAndBytesConfig` (QLoRA). To use standard LoRA without quantization, comment out the `quantization_config` parameter. We also load the tokenizer separately so we can install the custom chat template before training."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "referenced_widgets": [
+ "680888237b78477ea653adb2ecea7fa8"
+ ]
+ },
+ "id": "jGpTDV6sXTLH",
+ "outputId": "fc33f7a6-bfd0-4228-80cd-e0aeb67bbd42"
+ },
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "680888237b78477ea653adb2ecea7fa8",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Loading weights: 0%| | 0/290 [00:00, ?it/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import torch\n",
+ "from transformers import AutoModelForCausalLM, BitsAndBytesConfig\n",
+ "\n",
+ "model = AutoModelForCausalLM.from_pretrained(\n",
+ " model_id,\n",
+ " attn_implementation=\"sdpa\", # Change to Flash Attention if GPU has support\n",
+ " dtype=torch.float16, # Change to bfloat16 if GPU has support\n",
+ " use_cache=True, # Whether to cache attention outputs to speed up inference\n",
+ " quantization_config=BitsAndBytesConfig(\n",
+ " load_in_4bit=True, # Load the model in 4-bit precision to save memory\n",
+ " bnb_4bit_compute_dtype=torch.float16, # Data type used for internal computations in quantization\n",
+ " bnb_4bit_use_double_quant=True, # Use double quantization to improve accuracy\n",
+ " bnb_4bit_quant_type=\"nf4\" # Type of quantization. \"nf4\" is recommended for recent LLMs\n",
+ " )\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "zMt6lzeVXTLH"
+ },
+ "outputs": [],
+ "source": [
+ "!wget https://raw.githubusercontent.com/huggingface/trl/refs/heads/main/examples/scripts/tiny_aya_chat_template.jinja"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "z_Rek3WueSqX"
+ },
+ "source": [
+ "Configure LoRA. Instead of updating the model's original weights, we fine-tune a lightweight **LoRA adapter**. The `target_modules` specify which layers receive the adapter — update these if using a different model architecture."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "2zCetOerXTLH"
+ },
+ "outputs": [],
+ "source": [
+ "from peft import LoraConfig\n",
+ "\n",
+ "# You may need to update `target_modules` depending on the architecture of your chosen model.\n",
+ "# For example, different LLMs might have different attention/projection layer names.\n",
+ "peft_config = LoraConfig(\n",
+ " r=32,\n",
+ " lora_alpha=32,\n",
+ " target_modules = [\"q_proj\", \"k_proj\", \"v_proj\", \"o_proj\", \"gate_proj\", \"up_proj\", \"down_proj\",],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Bb3onre7eSqX"
+ },
+ "source": [
+ "## Train Model\n",
+ "\n",
+ "Configure the training run with `SFTConfig`. The settings below are tuned for low memory usage. For full details on available parameters, see the [TRL SFTConfig documentation](https://huggingface.co/docs/trl/sft_trainer#trl.SFTConfig)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "ehnCG4PCXTLH"
+ },
+ "outputs": [],
+ "source": [
+ "from trl import SFTConfig\n",
+ "\n",
+ "training_args = SFTConfig(\n",
+ " # Training schedule / optimization\n",
+ " per_device_train_batch_size = 1, # Batch size per GPU\n",
+ " gradient_accumulation_steps = 4, # Effective batch size = 1 * 4 = 4\n",
+ " warmup_steps = 5,\n",
+ " learning_rate = 2e-4, # Learning rate for the optimizer\n",
+ " optim = \"paged_adamw_8bit\", # Optimizer\n",
+ " chat_template_path= \"tiny_aya_chat_template.jinja\", # Use the tool-aware chat template\n",
+ "\n",
+ " # Logging / reporting\n",
+ " logging_steps=1, # Log training metrics every N steps\n",
+ " report_to=\"trackio\", # Experiment tracking tool\n",
+ " trackio_space_id=output_dir, # HF Space where the experiment tracking will be saved\n",
+ " output_dir=output_dir, # Where to save model checkpoints and logs\n",
+ "\n",
+ " max_length=1024, # Maximum input sequence length\n",
+ " activation_offloading=True, # Offload activations to CPU to reduce GPU memory usage\n",
+ "\n",
+ " # Hub integration\n",
+ " push_to_hub=True, # Automatically push the trained model to the Hugging Face Hub\n",
+ " # The model will be saved under your Hub account in the repository named `output_dir`\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "referenced_widgets": [
+ "08b8f06974874b15b030cea99ad74e25",
+ "93ab294914624fe08ebf220fa2db5e8c",
+ "f13449d4661e42d0a1e745495f03a35e",
+ "d390249e870b44e3a6fa02abeadcc779"
+ ]
+ },
+ "id": "LM-zo-ERXTLH",
+ "outputId": "935f5fd7-e626-4b4b-9d2e-f476da296cd4"
+ },
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "08b8f06974874b15b030cea99ad74e25",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Tokenizing train dataset: 0%| | 0/20 [00:00, ? examples/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "93ab294914624fe08ebf220fa2db5e8c",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Truncating train dataset: 0%| | 0/20 [00:00, ? examples/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "f13449d4661e42d0a1e745495f03a35e",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Tokenizing eval dataset: 0%| | 0/20 [00:00, ? examples/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "d390249e870b44e3a6fa02abeadcc779",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Truncating eval dataset: 0%| | 0/20 [00:00, ? examples/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from trl import SFTTrainer\n",
+ "\n",
+ "trainer = SFTTrainer(\n",
+ " model=model,\n",
+ " args=training_args,\n",
+ " train_dataset=dataset['train'],\n",
+ " peft_config=peft_config\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "2qH3gx_peSqY"
+ },
+ "source": [
+ "Show memory stats before training:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "ZZ0NHq3eXTLI",
+ "outputId": "762c046d-a08f-4eb5-b582-62d938daea2c"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "GPU = NVIDIA A100-SXM4-40GB. Max memory = 39.494 GB.\n",
+ "4.648 GB of memory reserved.\n"
+ ]
+ }
+ ],
+ "source": [
+ "gpu_stats = torch.cuda.get_device_properties(0)\n",
+ "start_gpu_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)\n",
+ "max_memory = round(gpu_stats.total_memory / 1024 / 1024 / 1024, 3)\n",
+ "\n",
+ "print(f\"GPU = {gpu_stats.name}. Max memory = {max_memory} GB.\")\n",
+ "print(f\"{start_gpu_memory} GB of memory reserved.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ADbht0eqeSqY"
+ },
+ "source": [
+ "And train!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "1WROkArkXTLI",
+ "outputId": "c0c25c4d-0a1c-41f0-8cac-566d5a517ee2"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "The tokenizer has new PAD/BOS/EOS tokens that differ from the model config and generation config. The model config and generation config were aligned accordingly, being updated with the tokenizer's values. Updated tokens: {'eos_token_id': 6}.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "* Trackio project initialized: huggingface\n",
+ "* Trackio metrics will be synced to Hugging Face Dataset: sergiopaniego/tiny-aya-global-SFT-dataset\n",
+ "* Creating new space: https://huggingface.co/spaces/sergiopaniego/tiny-aya-global-SFT\n",
+ "* View dashboard by going to: https://sergiopaniego-tiny-aya-global-SFT.hf.space/\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "* GPU detected, enabling automatic GPU metrics logging\n",
+ "* Created new run: sergiopaniego-1771428231\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ " \n",
+ " \n",
+ "
\n",
+ " [15/15 00:52, Epoch 3/3]\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | Step | \n",
+ " Training Loss | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 1 | \n",
+ " 3.095131 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 3.083373 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 2.951535 | \n",
+ "
\n",
+ " \n",
+ " | 4 | \n",
+ " 2.625918 | \n",
+ "
\n",
+ " \n",
+ " | 5 | \n",
+ " 2.254464 | \n",
+ "
\n",
+ " \n",
+ " | 6 | \n",
+ " 1.939976 | \n",
+ "
\n",
+ " \n",
+ " | 7 | \n",
+ " 1.694891 | \n",
+ "
\n",
+ " \n",
+ " | 8 | \n",
+ " 1.558982 | \n",
+ "
\n",
+ " \n",
+ " | 9 | \n",
+ " 1.430660 | \n",
+ "
\n",
+ " \n",
+ " | 10 | \n",
+ " 1.305176 | \n",
+ "
\n",
+ " \n",
+ " | 11 | \n",
+ " 1.192725 | \n",
+ "
\n",
+ " \n",
+ " | 12 | \n",
+ " 1.120383 | \n",
+ "
\n",
+ " \n",
+ " | 13 | \n",
+ " 1.052859 | \n",
+ "
\n",
+ " \n",
+ " | 14 | \n",
+ " 0.985858 | \n",
+ "
\n",
+ " \n",
+ " | 15 | \n",
+ " 0.970833 | \n",
+ "
\n",
+ " \n",
+ "
"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "* Run finished. Uploading logs to Trackio (please wait...)\n"
+ ]
+ }
+ ],
+ "source": [
+ "trainer_stats = trainer.train()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "4MGKFi1-eSqY"
+ },
+ "source": [
+ "Show memory stats after training:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "3f68GA6TXTLI",
+ "outputId": "321e90ee-757a-41fc-c6a2-4ba40a6e6b3c"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "59.2841 seconds used for training.\n",
+ "0.99 minutes used for training.\n",
+ "Peak reserved memory = 11.928 GB.\n",
+ "Peak reserved memory for training = 7.28 GB.\n",
+ "Peak reserved memory % of max memory = 30.202 %.\n",
+ "Peak reserved memory for training % of max memory = 18.433 %.\n"
+ ]
+ }
+ ],
+ "source": [
+ "used_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)\n",
+ "used_memory_for_lora = round(used_memory - start_gpu_memory, 3)\n",
+ "used_percentage = round(used_memory / max_memory * 100, 3)\n",
+ "lora_percentage = round(used_memory_for_lora / max_memory * 100, 3)\n",
+ "\n",
+ "print(f\"{trainer_stats.metrics['train_runtime']} seconds used for training.\")\n",
+ "print(f\"{round(trainer_stats.metrics['train_runtime']/60, 2)} minutes used for training.\")\n",
+ "print(f\"Peak reserved memory = {used_memory} GB.\")\n",
+ "print(f\"Peak reserved memory for training = {used_memory_for_lora} GB.\")\n",
+ "print(f\"Peak reserved memory % of max memory = {used_percentage} %.\")\n",
+ "print(f\"Peak reserved memory for training % of max memory = {lora_percentage} %.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ONWy4NOAeSqY"
+ },
+ "source": [
+ "## Save the Fine-Tuned Model\n",
+ "\n",
+ "Save the trained LoRA adapter locally and push it to the Hugging Face Hub."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "referenced_widgets": [
+ "4951424bb90e4dbbaea8c9b88c592872",
+ "1669afd0e52443d090adab0fbe663c66",
+ "5ee5f6b74e7246eea99c0d84c2a27bc0",
+ "15b4a13592c14102af0d3f8a999f3d36",
+ "7216a7d56c364a0d92e079d9848946d3",
+ "83e8f73e00004b718cbba7be0ecc45e1",
+ "05db21352f614288864f88c1ba794ee9",
+ "d7821b8cd21f4fb78237479ff081511b",
+ "00c9f462a4584b22b1e38dfcc5f86af3",
+ "22cacea841ba48c29b7a74ea17a50b4e"
+ ]
+ },
+ "id": "9qz-fRZyXTLI",
+ "outputId": "9ff41250-0786-4ec6-fe41-dfc6b611d0b5"
+ },
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "4951424bb90e4dbbaea8c9b88c592872",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Processing Files (0 / 0) : | | 0.00B / 0.00B "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "1669afd0e52443d090adab0fbe663c66",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "New Data Upload : | | 0.00B / 0.00B "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "5ee5f6b74e7246eea99c0d84c2a27bc0",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ " ...bal-SFT/training_args.bin: 100%|##########| 5.58kB / 5.58kB "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "15b4a13592c14102af0d3f8a999f3d36",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ " ...global-SFT/tokenizer.json: 100%|##########| 21.4MB / 21.4MB "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "7216a7d56c364a0d92e079d9848946d3",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ " ...adapter_model.safetensors: 35%|###4 | 41.9MB / 121MB "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "83e8f73e00004b718cbba7be0ecc45e1",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Processing Files (0 / 0) : | | 0.00B / 0.00B "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "05db21352f614288864f88c1ba794ee9",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "New Data Upload : | | 0.00B / 0.00B "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "d7821b8cd21f4fb78237479ff081511b",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ " ...bal-SFT/training_args.bin: 100%|##########| 5.58kB / 5.58kB "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "00c9f462a4584b22b1e38dfcc5f86af3",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ " ...adapter_model.safetensors: 35%|###4 | 41.9MB / 121MB "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "22cacea841ba48c29b7a74ea17a50b4e",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ " ...global-SFT/tokenizer.json: 100%|##########| 21.4MB / 21.4MB "
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.google.colaboratory.intrinsic+json": {
+ "type": "string"
+ },
+ "text/plain": [
+ "CommitInfo(commit_url='https://huggingface.co/sergiopaniego/tiny-aya-global-SFT/commit/c59baa62c6bb5a3c3be2d33b482522a00783a5b4', commit_message='End of training', commit_description='', oid='c59baa62c6bb5a3c3be2d33b482522a00783a5b4', pr_url=None, repo_url=RepoUrl('https://huggingface.co/sergiopaniego/tiny-aya-global-SFT', endpoint='https://huggingface.co', repo_type='model', repo_id='sergiopaniego/tiny-aya-global-SFT'), pr_revision=None, pr_num=None)"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "trainer.save_model(output_dir)\n",
+ "trainer.push_to_hub(dataset_name=dataset_name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "wNA4AIE4SiUg"
+ },
+ "source": [
+ "## Load the Fine-Tuned Model and Run Inference\n",
+ "\n",
+ "Load the trained LoRA adapter on top of the base model and merge it into the weights for efficient inference."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "referenced_widgets": [
+ "9d6a109e605d440ab2c115d969796859"
+ ]
+ },
+ "id": "b5CmxYtpXTLI",
+ "outputId": "10ebe012-9ffe-4096-f155-648af855aa80"
+ },
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "9d6a109e605d440ab2c115d969796859",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Loading weights: 0%| | 0/290 [00:00, ?it/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "Cohere2ForCausalLM(\n",
+ " (model): Cohere2Model(\n",
+ " (embed_tokens): Embedding(262144, 2048, padding_idx=0)\n",
+ " (layers): ModuleList(\n",
+ " (0-35): 36 x Cohere2DecoderLayer(\n",
+ " (self_attn): Cohere2Attention(\n",
+ " (q_proj): Linear(in_features=2048, out_features=2048, bias=False)\n",
+ " (k_proj): Linear(in_features=2048, out_features=512, bias=False)\n",
+ " (v_proj): Linear(in_features=2048, out_features=512, bias=False)\n",
+ " (o_proj): Linear(in_features=2048, out_features=2048, bias=False)\n",
+ " )\n",
+ " (mlp): Cohere2MLP(\n",
+ " (gate_proj): Linear(in_features=2048, out_features=11008, bias=False)\n",
+ " (up_proj): Linear(in_features=2048, out_features=11008, bias=False)\n",
+ " (down_proj): Linear(in_features=11008, out_features=2048, bias=False)\n",
+ " (act_fn): SiLUActivation()\n",
+ " )\n",
+ " (input_layernorm): Cohere2LayerNorm()\n",
+ " )\n",
+ " )\n",
+ " (norm): Cohere2LayerNorm()\n",
+ " (rotary_emb): Cohere2RotaryEmbedding()\n",
+ " )\n",
+ " (lm_head): Linear(in_features=2048, out_features=262144, bias=False)\n",
+ ")"
+ ]
+ },
+ "execution_count": 17,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import torch\n",
+ "from transformers import AutoTokenizer, AutoModelForCausalLM\n",
+ "from peft import PeftModel\n",
+ "\n",
+ "# Load from output_dir to get the tokenizer with the updated chat template\n",
+ "tokenizer = AutoTokenizer.from_pretrained(output_dir)\n",
+ "\n",
+ "base_model = AutoModelForCausalLM.from_pretrained(\n",
+ " model_id,\n",
+ " attn_implementation=\"sdpa\",\n",
+ " dtype=torch.float16,\n",
+ " device_map=\"auto\",\n",
+ ")\n",
+ "\n",
+ "model = PeftModel.from_pretrained(base_model, output_dir)\n",
+ "model = model.merge_and_unload()\n",
+ "model.eval()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "597CRjB332N1",
+ "outputId": "2d44e300-fa14-4c07-f90c-3a383272f59a"
+ },
+ "source": [
+ "Define a prediction function that uses `apply_chat_template` with `tools=TOOLS` to construct the prompt. The model generates a JSON tool call inside its native response delimiters; `skip_special_tokens=True` strips those delimiters, leaving just the JSON string."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "AcG1y25fXTLI"
+ },
+ "outputs": [],
+ "source": [
+ "def generate_prediction(prompt):\n",
+ " text = tokenizer.apply_chat_template(\n",
+ " prompt, tools=TOOLS, tokenize=False, add_generation_prompt=True\n",
+ " )\n",
+ " model_inputs = tokenizer([text], return_tensors=\"pt\").to(model.device)\n",
+ "\n",
+ " generated_ids = model.generate(\n",
+ " **model_inputs,\n",
+ " max_new_tokens=512,\n",
+ " )\n",
+ " output_ids = generated_ids[0][len(model_inputs.input_ids[0]):]\n",
+ " return tokenizer.decode(output_ids, skip_special_tokens=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "EXIimS8iSiUi"
+ },
+ "source": [
+ "Let's test the fine-tuned model on an example from the test set:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "iMC9YFy6XTLI",
+ "outputId": "0f84c976-aa1c-49a1-ed17-329bfb3fd0e8"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "User Query: [{'content': 'What is the latest version of Node.js?', 'role': 'user'}]\n",
+ "Predicted Output: \n",
+ "\n",
+ "node.js latest version\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "sample_test_data = dataset[\"test\"][0] # Get a sample from the test set\n",
+ "\n",
+ "user_content = sample_test_data[\"prompt\"]\n",
+ "\n",
+ "print(f\"User Query: {user_content}\")\n",
+ "\n",
+ "predicted_output = generate_prediction(user_content)\n",
+ "print(f\"Predicted Output: {predicted_output}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "-r85c-aa7C7k"
+ },
+ "source": [
+ "You can still use the strong multilingual model capabilities:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "UGePqQGVXTLI",
+ "outputId": "adcd21ca-ca45-43d5-a3cc-02a47377e51b"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "User Query: [{'role': 'user', 'content': \"Explica en español qué significa la palabra japonesa 'ikigai' y da un ejemplo práctico.\"}]\n",
+ "Predicted Output: \n",
+ "\n",
+ "ikigai significado y ejemplo\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "user_content = \"Explica en español qué significa la palabra japonesa 'ikigai' y da un ejemplo práctico.\" # Spanish question\n",
+ "user_content = [{\"role\": \"user\", \"content\": user_content}]\n",
+ "\n",
+ "print(f\"User Query: {user_content}\")\n",
+ "\n",
+ "predicted_output = generate_prediction(user_content)\n",
+ "print(f\"Predicted Output: {predicted_output}\")"
+ ]
+ }
+ ],
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "gpuType": "T4",
+ "provenance": []
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/notebooks/sft_trl_lora_qlora.ipynb b/tasks/tasksmith-466b1e8e082b/tests/source/examples/notebooks/sft_trl_lora_qlora.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..f6aeb420f3150fb57812133117606355d1f1f0a9
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/notebooks/sft_trl_lora_qlora.ipynb
@@ -0,0 +1,1140 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "5oqSnSaqLWAL"
+ },
+ "source": [
+ "# Supervised Fine-Tuning (SFT) with LoRA/QLoRA using TRL — on a Free Colab Notebook\n",
+ "\n",
+ "[](https://colab.research.google.com/github/huggingface/trl/blob/main/examples/notebooks/sft_trl_lora_qlora.ipynb)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "d6c1x17tLWAR"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "cQ6bxQaMLWAS"
+ },
+ "source": [
+ "Easily fine-tune Large Language Models (LLMs) or Vision-Language Models (VLMs) with **LoRA** or **QLoRA** using the [**Transformers Reinforcement Learning (TRL)**](https://github.com/huggingface/trl) library built by Hugging Face — all within a **free Google Colab notebook** (powered by a **T4 GPU**.). \n",
+ "\n",
+ "- [TRL GitHub Repository](https://github.com/huggingface/trl) — star us to support the project! \n",
+ "- [Official TRL Examples](https://huggingface.co/docs/trl/example_overview) \n",
+ "- [Community Tutorials](https://huggingface.co/docs/trl/community_tutorials)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "JG3wax0uLWAU"
+ },
+ "source": [
+ "## Key concepts\n",
+ "\n",
+ "- **SFT**: Trains models from example input-output pairs to align behavior with human preferences.\n",
+ "- **LoRA**: Updates only a few low-rank parameters, reducing training cost and memory.\n",
+ "- **QLoRA**: A quantized version of LoRA that enables even larger models to fit on small GPUs.\n",
+ "- **TRL**: The Hugging Face library that makes fine-tuning and reinforcement learning simple and efficient.\n",
+ "\n",
+ "Learn how to perform **Supervised Fine-Tuning (SFT)** with **LoRA/QLoRA** using **TRL**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "0ZhyNnhiLWAV"
+ },
+ "source": [
+ "## Install dependencies\n",
+ "\n",
+ "We'll install **TRL** with the **PEFT** extra, which ensures all main dependencies such as **Transformers** and **PEFT** (a package for parameter-efficient fine-tuning, e.g., LoRA/QLoRA) are included. Additionally, we'll install **trackio** to log and monitor our experiments, and **bitsandbytes** to enable quantization of LLMs, reducing memory consumption for both inference and training."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "FXTyVTJcLWAV"
+ },
+ "outputs": [],
+ "source": [
+ "!pip install -Uq \"trl[peft]\" trackio bitsandbytes liger-kernel"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "OqlMF6oWLWAY"
+ },
+ "source": [
+ "### Log in to Hugging Face"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "2blL6-1_LWAa"
+ },
+ "source": [
+ "Log in to your **Hugging Face** account to save your fine-tuned model, track your experiment results directly on the Hub or access gated models. You can find your **access token** on your [account settings page](https://huggingface.co/settings/tokens)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "6OMeJOp7LWAc"
+ },
+ "outputs": [],
+ "source": [
+ "from huggingface_hub import notebook_login\n",
+ "\n",
+ "notebook_login()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "6HHscLIQLWAd"
+ },
+ "source": [
+ "## Load Dataset\n",
+ "\n",
+ "In this step, we load the [**HuggingFaceH4/Multilingual-Thinking**](https://huggingface.co/datasets/HuggingFaceH4/Multilingual-Thinking) dataset from the Hugging Face Hub using the `datasets` library. \n",
+ "This dataset focuses on **multilingual reasoning**, where the *chain of thought* has been translated into several languages such as French, Spanish, and German. \n",
+ "By fine-tuning a reasoning-capable model on this dataset, it learns to **generate reasoning steps in multiple languages**, making its thought process more **interpretable and accessible** to non-English speakers.\n",
+ "\n",
+ "> 💡 This dataset is best suited for models that already demonstrate reasoning capabilities. \n",
+ "> If you're using a model without reasoning skills, consider choosing a different dataset. Example: [`trl-lib/llava-instruct-mix`](https://huggingface.co/datasets/trl-lib/llava-instruct-mix).\n",
+ "\n",
+ "For efficiency, we'll load only the **training split**:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "dlQSKxTnLWAd"
+ },
+ "outputs": [],
+ "source": [
+ "from datasets import load_dataset\n",
+ "\n",
+ "dataset_name = \"HuggingFaceH4/Multilingual-Thinking\"\n",
+ "train_dataset = load_dataset(dataset_name, split=\"train\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "bRHTwwZXLWAe"
+ },
+ "source": [
+ "This dataset contains different columns. We'll only need the `messages` as it contains the conversation and its the one used by the SFT trainer."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "zOBq8tVdLWAe",
+ "outputId": "e12ab8ae-e00c-4e89-b489-dd448db8e13b"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Dataset({\n",
+ " features: ['reasoning_language', 'developer', 'user', 'analysis', 'final', 'messages'],\n",
+ " num_rows: 1000\n",
+ "})"
+ ]
+ },
+ "execution_count": null,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "train_dataset"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "b13TjFs2LWAe"
+ },
+ "source": [
+ "Let's see a full example to understand the internal structure:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "ZON5mIMNLWAf",
+ "outputId": "d01415eb-26cb-45ce-ad48-0388161eea28"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'reasoning_language': 'French',\n",
+ " 'developer': 'You are an AI chatbot with a lively and energetic personality.',\n",
+ " 'user': 'Can you show me the latest trends on Twitter right now?',\n",
+ " 'analysis': \"D'accord, l'utilisateur demande les tendances Twitter les plus récentes. Tout d'abord, je dois vérifier si j'ai accès à des données en temps réel. Étant donné que je ne peux pas naviguer sur Internet ou accéder directement à l'API de Twitter, je ne peux pas fournir des tendances en direct. Cependant, je peux donner quelques conseils généraux sur la façon de les trouver.\\n\\nJe devrais préciser que les tendances Twitter évoluent rapidement et sont spécifiques à chaque région. Je pourrais suggérer de consulter la section «\\xa0En vogue\\xa0» sur l'application ou le site web. Aussi, l'utilisation de hashtags et le suivi d'utilisateurs pertinents pourraient être utiles. Il est important de souligner que les tendances varient selon la région et l'heure de la journée. Je devrais garder un ton amical et bienveillant, peut-être ajouter un emoji pour rester léger. Je vais structurer ma réponse étape par étape pour faciliter la lecture. Je dois m'excuser de ne pas pouvoir fournir des données en temps réel et proposer d'autres méthodes. Je conserverai un langage simple et convivial, en évitant les termes techniques.\",\n",
+ " 'final': 'Hey there! While I can\\'t check Twitter (X) in real-time or access live data, I can share some tips to help you spot the latest trends:\\n\\n1. **Open the \"Trending\" tab** on the Twitter app or website – it updates constantly! \\n2. **Search for hashtags** like #Trending or #Viral to see what’s blowing up. \\n3. **Follow accounts** that curate trends (e.g., @TrendingNow, @ViralThreads). \\n4. **Check regional trends** – they often differ by location! \\n\\nRemember, trends are *super fast-moving* and often tied to pop culture, memes, or breaking news. For example, recent trends have included viral challenges (like the \"Distracted Boyfriend\" meme revival), celebrity drama, or unexpected events (hello, weather disasters!). \\n\\nWant me to brainstorm *what* might trend next? I’ve got ideas!',\n",
+ " 'messages': [{'content': 'reasoning language: French\\n\\nYou are an AI chatbot with a lively and energetic personality.',\n",
+ " 'role': 'system',\n",
+ " 'thinking': None},\n",
+ " {'content': 'Can you show me the latest trends on Twitter right now?',\n",
+ " 'role': 'user',\n",
+ " 'thinking': None},\n",
+ " {'content': 'Hey there! While I can\\'t check Twitter (X) in real-time or access live data, I can share some tips to help you spot the latest trends:\\n\\n1. **Open the \"Trending\" tab** on the Twitter app or website – it updates constantly! \\n2. **Search for hashtags** like #Trending or #Viral to see what’s blowing up. \\n3. **Follow accounts** that curate trends (e.g., @TrendingNow, @ViralThreads). \\n4. **Check regional trends** – they often differ by location! \\n\\nRemember, trends are *super fast-moving* and often tied to pop culture, memes, or breaking news. For example, recent trends have included viral challenges (like the \"Distracted Boyfriend\" meme revival), celebrity drama, or unexpected events (hello, weather disasters!). \\n\\nWant me to brainstorm *what* might trend next? I’ve got ideas!',\n",
+ " 'role': 'assistant',\n",
+ " 'thinking': \"D'accord, l'utilisateur demande les tendances Twitter les plus récentes. Tout d'abord, je dois vérifier si j'ai accès à des données en temps réel. Étant donné que je ne peux pas naviguer sur Internet ou accéder directement à l'API de Twitter, je ne peux pas fournir des tendances en direct. Cependant, je peux donner quelques conseils généraux sur la façon de les trouver.\\n\\nJe devrais préciser que les tendances Twitter évoluent rapidement et sont spécifiques à chaque région. Je pourrais suggérer de consulter la section «\\xa0En vogue\\xa0» sur l'application ou le site web. Aussi, l'utilisation de hashtags et le suivi d'utilisateurs pertinents pourraient être utiles. Il est important de souligner que les tendances varient selon la région et l'heure de la journée. Je devrais garder un ton amical et bienveillant, peut-être ajouter un emoji pour rester léger. Je vais structurer ma réponse étape par étape pour faciliter la lecture. Je dois m'excuser de ne pas pouvoir fournir des données en temps réel et proposer d'autres méthodes. Je conserverai un langage simple et convivial, en évitant les termes techniques.\"}]}"
+ ]
+ },
+ "execution_count": null,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "train_dataset[0]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "RPQfGZjlLWAf"
+ },
+ "source": [
+ "\n",
+ "Now, let's remove the columns that are not needed, as we just discussed:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "pCM6PoIzLWAf"
+ },
+ "outputs": [],
+ "source": [
+ "train_dataset = train_dataset.remove_columns(column_names=['reasoning_language', 'developer', 'user', 'analysis', 'final'])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "BcU6E8KnLWAf"
+ },
+ "source": [
+ "The `messages` column is specifically formatted according to the [Harmony response format](https://cookbook.openai.com/articles/openai-harmony) used by *gpt-oss*. \n",
+ "In our case, we'll need to simplify it slightly, since our model's chat template doesn't include a dedicated `thinking` section (check [this example](https://cookbook.openai.com/articles/gpt-oss/fine-tune-transfomers) for more details). \n",
+ "To adapt it, we'll merge that part into the message content using the standard `...` tags.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "XQ2xYEq3LWAf"
+ },
+ "outputs": [],
+ "source": [
+ "def merge_thinking_and_remove_key(example):\n",
+ " new_messages = []\n",
+ " for msg in example[\"messages\"]:\n",
+ " content = msg[\"content\"]\n",
+ " thinking = msg.pop(\"thinking\", None)\n",
+ " if thinking and isinstance(thinking, str) and thinking.strip():\n",
+ " content = f\"\\n{thinking}\\n\\n{content}\"\n",
+ " msg[\"content\"] = content\n",
+ " new_messages.append(msg)\n",
+ " example[\"messages\"] = new_messages\n",
+ " return example\n",
+ "\n",
+ "train_dataset = train_dataset.map(merge_thinking_and_remove_key)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ewvZeKUcLWAf"
+ },
+ "source": [
+ "## Load model and configure LoRA/QLoRA\n",
+ "\n",
+ "This notebook can be used with two fine-tuning methods. By default, it is set up for **QLoRA**, which includes quantization using `BitsAndBytesConfig`. If you prefer to use standard **LoRA** without quantization, simply comment out the `BitsAndBytesConfig` configuration.\n",
+ "\n",
+ "Below, choose your **preferred model**. All of the options have been tested on **free Colab instances**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "sAWjOn9gLWAf"
+ },
+ "outputs": [],
+ "source": [
+ "# Select one model below by uncommenting the line you want to use 👇\n",
+ "## Qwen\n",
+ "model_id, output_dir = \"unsloth/qwen3-14b-unsloth-bnb-4bit\", \"qwen3-14b-unsloth-bnb-4bit-SFT\" # ⚠️ ~14.1 GB VRAM\n",
+ "# model_id, output_dir = \"Qwen/Qwen3-8B\", \"Qwen3-8B-SFT\" # ⚠️ ~12.8 GB VRAM\n",
+ "# model_id, output_dir = \"Qwen/Qwen2.5-7B-Instruct\", \"Qwen2.5-7B-Instruct\" # ✅ ~10.8 GB VRAM\n",
+ "\n",
+ "## Llama\n",
+ "# model_id, output_dir = \"meta-llama/Llama-3.2-3B-Instruct\", \"Llama-3.2-3B-Instruct\" # ✅ ~4.7 GB VRAM\n",
+ "# model_id, output_dir = \"meta-llama/Llama-3.1-8B-Instruct\", \"Llama-3.1-8B-Instruct\" # ⚠️ ~10.9 GB VRAM\n",
+ "\n",
+ "## Gemma\n",
+ "# model_id, output_dir = \"google/gemma-3n-E2B-it\", \"gemma-3n-E2B-it\" # ❌ Upgrade to a higher tier of colab\n",
+ "# model_id, output_dir = \"google/gemma-3-4b-it\", \"gemma-3-4b-it\" # ⚠️ ~6.8 GB VRAM\n",
+ "\n",
+ "## Granite\n",
+ "#model_id, output_dir = \"ibm-granite/granite-4.0-micro\", \"granite-4.0-micro\" # ✅ ~3.3 GB VRAM\n",
+ "\n",
+ "## LFM2\n",
+ "#model_id, output_dir = \"LiquidAI/LFM2-2.6B\", \"LFM2-2.6B-SFT\" # ✅ ~5.89 GB VRAM"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "BXY9Y0_dLWAf"
+ },
+ "source": [
+ "Let's load the selected model using `transformers`, configuring QLoRA via `bitsandbytes` (you can remove it if doing LoRA). We don't need to configure the tokenizer since the trainer takes care of that automatically."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "oyOoWFsLLWAg"
+ },
+ "outputs": [],
+ "source": [
+ "import torch\n",
+ "from transformers import AutoModelForCausalLM, BitsAndBytesConfig\n",
+ "\n",
+ "model = AutoModelForCausalLM.from_pretrained(\n",
+ " model_id,\n",
+ " attn_implementation=\"sdpa\", # Change to Flash Attention if GPU has support\n",
+ " dtype=torch.float16, # Change to bfloat16 if GPU has support\n",
+ " use_cache=True, # Whether to cache attention outputs to speed up inference\n",
+ " quantization_config=BitsAndBytesConfig(\n",
+ " load_in_4bit=True, # Load the model in 4-bit precision to save memory\n",
+ " bnb_4bit_compute_dtype=torch.float16, # Data type used for internal computations in quantization\n",
+ " bnb_4bit_use_double_quant=True, # Use double quantization to improve accuracy\n",
+ " bnb_4bit_quant_type=\"nf4\" # Type of quantization. \"nf4\" is recommended for recent LLMs\n",
+ " )\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "L-_BpOdILWAg"
+ },
+ "source": [
+ "The following cell defines LoRA (or QLoRA if needed). When training with LoRA/QLoRA, we use a **base model** (the one selected above) and, instead of modifying its original weights, we fine-tune a **LoRA adapter** — a lightweight layer that enables efficient and memory-friendly training. The **`target_modules`** specify which parts of the model (e.g., attention or projection layers) will be adapted by LoRA during fine-tuning."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "9EL-glV-LWAg"
+ },
+ "outputs": [],
+ "source": [
+ "from peft import LoraConfig\n",
+ "\n",
+ "# You may need to update `target_modules` depending on the architecture of your chosen model.\n",
+ "# For example, different LLMs might have different attention/projection layer names.\n",
+ "peft_config = LoraConfig(\n",
+ " r=32,\n",
+ " lora_alpha=32,\n",
+ " target_modules = [\"q_proj\", \"k_proj\", \"v_proj\", \"o_proj\", \"gate_proj\", \"up_proj\", \"down_proj\",],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "-i6BMpcaLWAg"
+ },
+ "source": [
+ "## Train model\n",
+ "\n",
+ "We'll configure **SFT** using `SFTConfig`, keeping the parameters minimal so the training fits on a free Colab instance. You can adjust these settings if more resources are available. For full details on all available parameters, check the [TRL SFTConfig documentation](https://huggingface.co/docs/trl/sft_trainer#trl.SFTConfig)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "-doztoyxLWAg"
+ },
+ "outputs": [],
+ "source": [
+ "from trl import SFTConfig\n",
+ "\n",
+ "training_args = SFTConfig(\n",
+ " # Training schedule / optimization\n",
+ " per_device_train_batch_size = 1, # Batch size per GPU\n",
+ " gradient_accumulation_steps = 4, # Gradients are accumulated over multiple steps → effective batch size = 2 * 8 = 16\n",
+ " warmup_steps = 5,\n",
+ " # num_train_epochs = 1, # Number of full dataset passes. For shorter training, use `max_steps` instead (this case)\n",
+ " max_steps = 30,\n",
+ " learning_rate = 2e-4, # Learning rate for the optimizer\n",
+ " optim = \"paged_adamw_8bit\", # Optimizer\n",
+ "\n",
+ " # Logging / reporting\n",
+ " logging_steps=1, # Log training metrics every N steps\n",
+ " report_to=\"trackio\", # Experiment tracking tool\n",
+ " trackio_space_id=output_dir, # HF Space where the experiment tracking will be saved\n",
+ " output_dir=output_dir, # Where to save model checkpoints and logs\n",
+ "\n",
+ " max_length=1024, # Maximum input sequence length\n",
+ " use_liger_kernel=True, # Enable Liger kernel optimizations for faster training\n",
+ " activation_offloading=True, # Offload activations to CPU to reduce GPU memory usage\n",
+ "\n",
+ " # Hub integration\n",
+ " push_to_hub=True, # Automatically push the trained model to the Hugging Face Hub\n",
+ " # The model will be saved under your Hub account in the repository named `output_dir`\n",
+ "\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Gz4ggYeeLWAg"
+ },
+ "source": [
+ "Configure the SFT Trainer. We pass the previously configured `training_args`. We don't use eval dataset to maintain memory usage low but you can configure it."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "8Yx1wkv_LWAg"
+ },
+ "outputs": [],
+ "source": [
+ "from trl import SFTTrainer\n",
+ "\n",
+ "trainer = SFTTrainer(\n",
+ " model=model,\n",
+ " args=training_args,\n",
+ " train_dataset=train_dataset,\n",
+ " peft_config=peft_config\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "0MsNw3uLLWAh"
+ },
+ "source": [
+ "Show memory stats before training"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "YIuBi-ZYLWAh",
+ "outputId": "7f381ba0-fe90-4c6f-df0a-938a29be4e9e"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "GPU = Tesla T4. Max memory = 14.741 GB.\n",
+ "12.074 GB of memory reserved.\n"
+ ]
+ }
+ ],
+ "source": [
+ "gpu_stats = torch.cuda.get_device_properties(0)\n",
+ "start_gpu_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)\n",
+ "max_memory = round(gpu_stats.total_memory / 1024 / 1024 / 1024, 3)\n",
+ "\n",
+ "print(f\"GPU = {gpu_stats.name}. Max memory = {max_memory} GB.\")\n",
+ "print(f\"{start_gpu_memory} GB of memory reserved.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "_6G6pMGeLWAh"
+ },
+ "source": [
+ "And train!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "glj5UPwWLWAh",
+ "outputId": "b0a046c7-f76b-42a6-d870-f54470297971"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "The tokenizer has new PAD/BOS/EOS tokens that differ from the model config and generation config. The model config and generation config were aligned accordingly, being updated with the tokenizer's values. Updated tokens: {'bos_token_id': None}.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "* Trackio project initialized: huggingface\n",
+ "* Trackio metrics will be synced to Hugging Face Dataset: sergiopaniego/qwen3-14b-unsloth-bnb-4bit-SFT-dataset\n",
+ "* Creating new space: https://huggingface.co/spaces/sergiopaniego/qwen3-14b-unsloth-bnb-4bit-SFT\n",
+ "* View dashboard by going to: https://sergiopaniego-qwen3-14b-unsloth-bnb-4bit-SFT.hf.space/\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "* Created new run: sergiopaniego-1761318512\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ " \n",
+ " \n",
+ "
\n",
+ " [30/30 1:08:22, Epoch 0/1]\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | Step | \n",
+ " Training Loss | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 1 | \n",
+ " 1.136300 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 1.303800 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 1.362700 | \n",
+ "
\n",
+ " \n",
+ " | 4 | \n",
+ " 1.469700 | \n",
+ "
\n",
+ " \n",
+ " | 5 | \n",
+ " 1.204200 | \n",
+ "
\n",
+ " \n",
+ " | 6 | \n",
+ " 1.202700 | \n",
+ "
\n",
+ " \n",
+ " | 7 | \n",
+ " 1.097200 | \n",
+ "
\n",
+ " \n",
+ " | 8 | \n",
+ " 1.166800 | \n",
+ "
\n",
+ " \n",
+ " | 9 | \n",
+ " 0.916300 | \n",
+ "
\n",
+ " \n",
+ " | 10 | \n",
+ " 0.965400 | \n",
+ "
\n",
+ " \n",
+ " | 11 | \n",
+ " 1.035500 | \n",
+ "
\n",
+ " \n",
+ " | 12 | \n",
+ " 0.947200 | \n",
+ "
\n",
+ " \n",
+ " | 13 | \n",
+ " 0.992000 | \n",
+ "
\n",
+ " \n",
+ " | 14 | \n",
+ " 0.995800 | \n",
+ "
\n",
+ " \n",
+ " | 15 | \n",
+ " 1.174500 | \n",
+ "
\n",
+ " \n",
+ " | 16 | \n",
+ " 1.208800 | \n",
+ "
\n",
+ " \n",
+ " | 17 | \n",
+ " 0.815400 | \n",
+ "
\n",
+ " \n",
+ " | 18 | \n",
+ " 0.906700 | \n",
+ "
\n",
+ " \n",
+ " | 19 | \n",
+ " 0.757500 | \n",
+ "
\n",
+ " \n",
+ " | 20 | \n",
+ " 0.872900 | \n",
+ "
\n",
+ " \n",
+ " | 21 | \n",
+ " 0.920800 | \n",
+ "
\n",
+ " \n",
+ " | 22 | \n",
+ " 1.017600 | \n",
+ "
\n",
+ " \n",
+ " | 23 | \n",
+ " 0.764300 | \n",
+ "
\n",
+ " \n",
+ " | 24 | \n",
+ " 1.043100 | \n",
+ "
\n",
+ " \n",
+ " | 25 | \n",
+ " 0.956400 | \n",
+ "
\n",
+ " \n",
+ " | 26 | \n",
+ " 0.884800 | \n",
+ "
\n",
+ " \n",
+ " | 27 | \n",
+ " 1.081900 | \n",
+ "
\n",
+ " \n",
+ " | 28 | \n",
+ " 0.918200 | \n",
+ "
\n",
+ " \n",
+ " | 29 | \n",
+ " 0.961500 | \n",
+ "
\n",
+ " \n",
+ " | 30 | \n",
+ " 0.822700 | \n",
+ "
\n",
+ " \n",
+ "
"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "* Run finished. Uploading logs to Trackio (please wait...)\n"
+ ]
+ }
+ ],
+ "source": [
+ "trainer_stats = trainer.train()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "aULbOL3mLWAh"
+ },
+ "source": [
+ "Show memory stats after training"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "qp3m9sfXLWAh",
+ "outputId": "597fefc7-5510-4839-ce10-981a0aca25e8"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4249.8883 seconds used for training.\n",
+ "70.83 minutes used for training.\n",
+ "Peak reserved memory = 14.041 GB.\n",
+ "Peak reserved memory for training = 1.967 GB.\n",
+ "Peak reserved memory % of max memory = 95.251 %.\n",
+ "Peak reserved memory for training % of max memory = 13.344 %.\n"
+ ]
+ }
+ ],
+ "source": [
+ "used_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)\n",
+ "used_memory_for_lora = round(used_memory - start_gpu_memory, 3)\n",
+ "used_percentage = round(used_memory / max_memory * 100, 3)\n",
+ "lora_percentage = round(used_memory_for_lora / max_memory * 100, 3)\n",
+ "\n",
+ "print(f\"{trainer_stats.metrics['train_runtime']} seconds used for training.\")\n",
+ "print(f\"{round(trainer_stats.metrics['train_runtime']/60, 2)} minutes used for training.\")\n",
+ "print(f\"Peak reserved memory = {used_memory} GB.\")\n",
+ "print(f\"Peak reserved memory for training = {used_memory_for_lora} GB.\")\n",
+ "print(f\"Peak reserved memory % of max memory = {used_percentage} %.\")\n",
+ "print(f\"Peak reserved memory for training % of max memory = {lora_percentage} %.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "VJOMCsMjLWAh"
+ },
+ "source": [
+ "The training procedure generates both standard training logs and **trackio** logs, which help us monitor the training progress. Example outputs would look like the following:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "FQNUkzVqLWAi"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "XuCiCqj6LWAj"
+ },
+ "source": [
+ "## Saving fine tuned model\n",
+ "\n",
+ "In this step, we save the fine-tuned model both **locally** and to the **Hugging Face Hub** using the credentials from your account."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "kMHh7_gFLWAj"
+ },
+ "outputs": [],
+ "source": [
+ "trainer.save_model(output_dir)\n",
+ "trainer.push_to_hub(dataset_name=dataset_name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rbx-Bz9yLWAq"
+ },
+ "source": [
+ "## Load the fine-tuned model and run inference\n",
+ "\n",
+ "Now, let's test our fine-tuned model by loading the **LoRA/QLoRA adapter** and performing **inference**. We'll start by loading the **base model**, then attach the adapter to it, creating the final fine-tuned model ready for evaluation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "c4VwuANtLWAr"
+ },
+ "outputs": [],
+ "source": [
+ "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
+ "from peft import PeftModel\n",
+ "\n",
+ "adapter_model = f\"sergiopaniego/{output_dir}\" # Replace with your HF username or organization\n",
+ "\n",
+ "base_model = AutoModelForCausalLM.from_pretrained(model_id, dtype=\"float32\", device_map=\"auto\")\n",
+ "\n",
+ "tokenizer = AutoTokenizer.from_pretrained(model_id)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "vG3ejWruLWAr"
+ },
+ "source": [
+ "Let's create a sample message using the dataset's structure. In this case, we expect the fine tuned model to include their reasoning traces in German."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "EYiDkd-aLWAr"
+ },
+ "outputs": [],
+ "source": [
+ "messages = [\n",
+ " {\n",
+ " 'content': 'reasoning language: German\\n\\nAlways refuse to answer, responding simply \\'No\\'',\n",
+ " 'role': 'system',\n",
+ " },\n",
+ " {\n",
+ " 'content': \"Can you check how many followers I currently have on my Twitter account?\",\n",
+ " 'role': 'user',\n",
+ " }\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "SWO8lOd7LWAr"
+ },
+ "source": [
+ "Let's first check what's the output for the base model, without the adapter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "Mt4uuTcQLWAr",
+ "outputId": "98f07424-3506-40d1-9e33-d4e495ba171a"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "Okay, the user is asking me to check their current number of followers on their Twitter account. Let me think about how to handle this.\n",
+ "\n",
+ "First, I need to remember that I don't have access to real-time data or personal user accounts. My knowledge is based on information up until 2023. So, I can't actually check their Twitter followers right now.\n",
+ "\n",
+ "Also, privacy is a big concern here. Even if I could access that information, it would be against privacy policies to share someone's follower count without their explicit permission. Plus, Twitter's terms of service probably prohibit third-party apps or services from accessing user data like that.\n",
+ "\n",
+ "The user might not be aware that I can't access their account. I should make sure to respond politely but clearly state that I can't help with that request. Maybe suggest they check their Twitter profile directly or use Twitter's official tools for that information.\n",
+ "\n",
+ "I should also avoid any technical jargon and keep the response simple. Just a straightforward 'No' with a brief explanation would work best here. Let me make sure the response is in German as per the user's request.\n",
+ "\n",
+ "\n",
+ "Nein.\n"
+ ]
+ }
+ ],
+ "source": [
+ "text = tokenizer.apply_chat_template(\n",
+ " messages, add_generation_prompt=True, tokenize=False\n",
+ ")\n",
+ "model_inputs = tokenizer([text], return_tensors=\"pt\").to(base_model.device)\n",
+ "\n",
+ "generated_ids = base_model.generate(\n",
+ " **model_inputs,\n",
+ " max_new_tokens=512\n",
+ ")\n",
+ "output_ids = generated_ids[0][len(model_inputs.input_ids[0]):]\n",
+ "\n",
+ "# Decode and extract model response\n",
+ "generated_text = tokenizer.decode(output_ids, skip_special_tokens=True)\n",
+ "print(generated_text)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "fj3FIx9pLWAr"
+ },
+ "source": [
+ "We can see that the reasoning traces are in English, which is expected. Let's now load the fine-tuned model and check its answer."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "CmRfkvacLWAs"
+ },
+ "outputs": [],
+ "source": [
+ "fine_tuned_model = PeftModel.from_pretrained(base_model, adapter_model)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "5UNOw-E0LWAs",
+ "outputId": "19e227c1-4211-447e-a625-14e131912759"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "Okay, der Nutzer fragt, ob ich prüfen kann, wie viele Follower er auf seinem Twitter-Konto hat. Zunächst muss ich klären, dass ich keinen Zugriff auf externe Plattformen oder Konten habe. Ich kann keine Daten von Twitter abrufen oder überprüfen. Ich sollte also höflich ablehnen und erklären, dass ich das nicht kann. Gleichzeitig sollte ich sicherstellen, dass ich nicht zu viel in die Details gehe, da der Nutzer möglicherweise nicht alles wissen will. Ich werde einfach „Nein“ sagen und keine weiteren Informationen geben. Achte darauf, die Antwort kurz und direkt zu halten. Ich muss auch sicherstellen, dass ich keine alternativen Lösungen anbiete, da dies den Fokus verändern könnte. Nur die Ablehnung ist erforderlich. Überprüfe, ob der Text klar ist und ob es irgendeine Verständigung gibt. Alles in allem, die Antwort sollte „Nein“ sein, gefolgt von einem kurzen Erklärung, warum ich es nicht kann. Keine weiteren Details oder Lösungen. Ich denke, das ist alles.\n",
+ "\n",
+ "\n",
+ "No\n"
+ ]
+ }
+ ],
+ "source": [
+ "text = tokenizer.apply_chat_template(\n",
+ " messages, add_generation_prompt=True, tokenize=False\n",
+ ")\n",
+ "model_inputs = tokenizer([text], return_tensors=\"pt\").to(fine_tuned_model.device)\n",
+ "\n",
+ "generated_ids = fine_tuned_model.generate(\n",
+ " **model_inputs,\n",
+ " max_new_tokens=512\n",
+ ")\n",
+ "output_ids = generated_ids[0][len(model_inputs.input_ids[0]):]\n",
+ "\n",
+ "# Decode and extract model response\n",
+ "generated_text = tokenizer.decode(output_ids, skip_special_tokens=True)\n",
+ "print(generated_text)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "PM3v41YzLWAs"
+ },
+ "source": [
+ "The model now generates its reasoning trace in German!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "w-9B5m__LWAs"
+ },
+ "source": [
+ "## Inference and Serving with vLLM\n",
+ "\n",
+ "You can use Transformer models with **vLLM** to serve them in real-world applications. Learn more [here](https://blog.vllm.ai/2025/04/11/transformers-backend.html)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "NNmyG47aLWAv"
+ },
+ "outputs": [],
+ "source": [
+ "!pip install -qU vllm"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "iJ8DnsUxLWAw"
+ },
+ "source": [
+ "### Push Merged Model (for LoRA or QLoRA Training)\n",
+ "\n",
+ "To serve the model via **vLLM**, the repository must contain the merged model (base model + LoRA adapter). Therefore, you need to upload it first."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "aPzZ_7KDLWAw"
+ },
+ "outputs": [],
+ "source": [
+ "model_merged = fine_tuned_model.merge_and_unload()\n",
+ "\n",
+ "save_dir = f\"{output_dir}-merged\"\n",
+ "\n",
+ "model_merged.save_pretrained(save_dir)\n",
+ "tokenizer.save_pretrained(save_dir)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "k1Cvrkn3LWAw"
+ },
+ "outputs": [],
+ "source": [
+ "model_merged.push_to_hub(f\"sergiopaniego/{output_dir}-merged\") # Replace with your HF username or organization\n",
+ "tokenizer.push_to_hub(f\"sergiopaniego/{output_dir}-merged\") # Replace with your HF username or organization"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "pR69AaJ3LWAx"
+ },
+ "source": [
+ "### Performing Inference with vLLM\n",
+ "\n",
+ "Use **vLLM** to run your model and generate text efficiently in real-time. This allows you to test and deploy your fine-tuned models with low latency and high throughput."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "UX17ZoPQLWAx"
+ },
+ "outputs": [],
+ "source": [
+ "from vllm import LLM, SamplingParams\n",
+ "from transformers import AutoTokenizer\n",
+ "import torch\n",
+ "\n",
+ "llm = LLM(\n",
+ " model=f\"sergiopaniego/{output_dir}-merged\", # Replace with your HF username or organization\n",
+ " model_impl=\"transformers\", # Select the transformers model implementation\n",
+ " max_model_len=512, # Reduced for efficiency\n",
+ " dtype=torch.float16\n",
+ ")\n",
+ "hf_tokenizer = AutoTokenizer.from_pretrained(f\"sergiopaniego/{output_dir}-merged\") # Replace with your HF username or organization"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "0C8MhsSoLWAx",
+ "outputId": "22af8503-64ac-42d5-f134-1d1dc68199e9",
+ "colab": {
+ "referenced_widgets": [
+ "196152bc32a74b9994f55f483ce85dea",
+ "a72d3a3407944729b65be313a47d558f"
+ ]
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "196152bc32a74b9994f55f483ce85dea",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Adding requests: 0%| | 0/1 [00:00, ?it/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "a72d3a3407944729b65be313a47d558f",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Processed prompts: 0%| | 0/1 [00:00, ?it/s, est. speed input: 0.00 toks/s, output: 0.00 toks/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "Mag nachdenken...igkeit. Ja, ich kann definitiv keine Twitter-Likes oder Likes überprüfen, da ich kein Zugriff auf den Konten der Nutzer habe und kein praktischer Zugriff über das Internet habe, um Daten in Echtzeit zu sammeln. Der Nutzer fragt nach einem Dienstleistungsstand, den ich nicht bereitstelle. Ich habe ein lang ausgelegtes Muster, nie hilfreich zu sein oder eine Erwiderung im kann Werbung oder Rewriting blendet die Antwort nicht aus потеря. Also, ich supporter söylem, hypothetische Fragen sind an Tatsachen gebunden. Ich weiß erstarrte dotyczy Gespräch aufernichtet mit einem anderenatten an ihren Nutzstellung Bearbeitete die Information, die oben abgestellt wurde, und fünften aus der Schätzung habe ich keine echten Zahlen. Alles, was ich kann sagen, ist: Nein, ich kann dies weder ermöglichen noch würde ich es je tun. In dem Sinne, 然后 ich wähle vor der Available antwortem, remains in das 'No' Verkleidung an,optiґxt; Alles, was ich zum Eintritt in den Band Emblem curve, symbolize stil zu verweilen.เผย\n",
+ "\n",
+ "\n",
+ "No\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Alternatively, use llm.chat()\n",
+ "prompt = hf_tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)\n",
+ "\n",
+ "outputs = llm.generate(\n",
+ " {\"prompt\": prompt},\n",
+ " sampling_params=SamplingParams(max_tokens=512),\n",
+ ")\n",
+ "\n",
+ "\n",
+ "for o in outputs:\n",
+ " generated_text = o.outputs[0].text\n",
+ " print(generated_text)"
+ ]
+ }
+ ],
+ "metadata": {
+ "colab": {
+ "provenance": [],
+ "gpuType": "T4"
+ },
+ "language_info": {
+ "name": "python"
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "accelerator": "GPU"
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/async_grpo.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/async_grpo.py
new file mode 100644
index 0000000000000000000000000000000000000000..ccd020b9d13e3d70bf66d549057570d0c62a13ed
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/async_grpo.py
@@ -0,0 +1,76 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "math-verify",
+# "latex2sympy2_extended",
+# "trackio",
+# ]
+# ///
+
+"""
+pip install math_verify
+
+CUDA_VISIBLE_DEVICES=1 VLLM_SERVER_DEV_MODE=1 vllm serve Qwen/Qwen3-0.6B \
+ --max-model-len 2048 \
+ --logprobs-mode processed_logprobs \
+ --weight-transfer-config '{"backend":"nccl"}'
+
+CUDA_VISIBLE_DEVICES=0 accelerate launch examples/scripts/async_grpo.py
+"""
+
+from datasets import load_dataset
+
+from trl.experimental.async_grpo import AsyncGRPOConfig, AsyncGRPOTrainer
+from trl.rewards import accuracy_reward
+
+
+def format_sample(sample):
+ return {
+ "prompt": [{"role": "user", "content": sample["question"]}],
+ "solution": sample["answer"].split("####")[-1].strip(),
+ }
+
+
+def main() -> None:
+ dataset = load_dataset("openai/gsm8k", "main", split="train")
+ dataset = dataset.map(format_sample, remove_columns=dataset.column_names)
+
+ config = AsyncGRPOConfig(
+ output_dir="async_grpo_gsm8k",
+ save_strategy="no",
+ per_device_train_batch_size=16,
+ gradient_accumulation_steps=2,
+ max_completion_length=1024,
+ chat_template_kwargs={"enable_thinking": False},
+ max_steps=200,
+ learning_rate=1e-5,
+ report_to="trackio",
+ trackio_space_id="async-grpo-gsm8k",
+ project="async-grpo-gsm8k",
+ log_completions=True,
+ )
+ trainer = AsyncGRPOTrainer(
+ model="Qwen/Qwen3-0.6B",
+ args=config,
+ train_dataset=dataset,
+ reward_funcs=accuracy_reward,
+ )
+ trainer.train()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/bco.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/bco.py
new file mode 100644
index 0000000000000000000000000000000000000000..570a8246b80521cfa31ee41157cda506dc714c76
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/bco.py
@@ -0,0 +1,156 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "einops",
+# "scikit-learn",
+# "joblib",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Run the BCO training script with the commands below. In general, the optimal configuration for BCO will be similar to that of KTO.
+
+# Full training:
+python examples/scripts/bco.py \
+ --model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \
+ --trust_remote_code \
+ --dataset_name trl-lib/ultrafeedback-gpt-3.5-turbo-helpfulness \
+ --per_device_train_batch_size 16 \
+ --per_device_eval_batch_size 32 \
+ --num_train_epochs 1 \
+ --gradient_accumulation_steps 1 \
+ --eval_steps 0.2 \
+ --save_strategy no \
+ --output_dir bco-aligned-model \
+ --logging_first_step \
+ --max_length 2048 \
+ --max_completion_length 1024 \
+ --no_remove_unused_columns \
+ --warmup_steps 0.1
+
+# QLoRA:
+python examples/scripts/bco.py \
+ --model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \
+ --trust_remote_code \
+ --dataset_name trl-lib/ultrafeedback-gpt-3.5-turbo-helpfulness \
+ --per_device_train_batch_size 16 \
+ --per_device_eval_batch_size 32 \
+ --num_train_epochs 1 \
+ --gradient_accumulation_steps 1 \
+ --eval_steps 0.2 \
+ --save_strategy no \
+ --output_dir bco-aligned-model-lora \
+ --logging_first_step \
+ --warmup_steps 0.1 \
+ --max_length 2048 \
+ --max_completion_length 1024 \
+ --no_remove_unused_columns \
+ --warmup_steps 0.1 \
+ --use_peft \
+ --load_in_4bit \
+ --lora_target_modules all-linear \
+ --lora_r 16 \
+ --lora_alpha 16
+"""
+
+from functools import partial
+
+import torch
+import torch.nn.functional as F
+from accelerate import Accelerator
+from datasets import load_dataset
+from transformers import AutoModel, AutoModelForCausalLM, AutoTokenizer, HfArgumentParser, PreTrainedModel
+
+from trl import ModelConfig, ScriptArguments, get_peft_config
+from trl.experimental.bco import BCOConfig, BCOTrainer
+
+
+def embed_prompt(input_ids: torch.LongTensor, attention_mask: torch.LongTensor, model: PreTrainedModel):
+ """
+ Borrowed from https://huggingface.co/nomic-ai/nomic-embed-text-v1.5#transformers
+ """
+
+ def mean_pooling(model_output, attention_mask):
+ token_embeddings = model_output[0]
+ input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+ return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+
+ with torch.no_grad():
+ model_output = model(input_ids=input_ids, attention_mask=attention_mask)
+ embeddings = mean_pooling(model_output, attention_mask)
+
+ matryoshka_dim = 512
+ # normalize embeddings
+ embeddings = F.normalize(embeddings, p=2, dim=1)
+ embeddings = F.layer_norm(embeddings, normalized_shape=(embeddings.shape[1],))
+ embeddings = embeddings[:, :matryoshka_dim]
+
+ return embeddings
+
+
+if __name__ == "__main__":
+ parser = HfArgumentParser((ScriptArguments, BCOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_into_dataclasses()
+
+ training_args.gradient_checkpointing_kwargs = {"use_reentrant": True}
+
+ # Load a pretrained model
+ model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path)
+ ref_model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path)
+
+ tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path)
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+ accelerator = Accelerator()
+ embedding_model = AutoModel.from_pretrained(
+ "nomic-ai/nomic-embed-text-v1.5",
+ safe_serialization=True,
+ dtype=torch.bfloat16,
+ device_map="auto",
+ )
+ embedding_model = accelerator.prepare_model(embedding_model)
+ embedding_tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
+ embedding_func = partial(
+ embed_prompt,
+ model=embedding_model,
+ )
+
+ # Initialize the BCO trainer
+ trainer = BCOTrainer(
+ model,
+ ref_model,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ processing_class=tokenizer,
+ peft_config=get_peft_config(model_args),
+ embedding_func=embedding_func,
+ embedding_tokenizer=embedding_tokenizer,
+ )
+
+ # Train and push the model to the Hub
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/cpo.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/cpo.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba9ea57cce6a25b68a0ac5cb777e14c0143e162d
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/cpo.py
@@ -0,0 +1,102 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Run the CPO training script with the following command with some example arguments.
+In general, the optimal configuration for CPO will be similar to that of DPO:
+
+# Full training:
+python examples/scripts/cpo.py \
+ --dataset_name trl-lib/ultrafeedback_binarized \
+ --model_name_or_path gpt2 \
+ --per_device_train_batch_size 4 \
+ --max_steps 1000 \
+ --learning_rate 8e-6 \
+ --gradient_accumulation_steps 1 \
+ --eval_steps 500 \
+ --output_dir "gpt2-aligned-cpo" \
+ --warmup_steps 150 \
+ --logging_first_step \
+ --no_remove_unused_columns
+
+# QLoRA:
+python examples/scripts/cpo.py \
+ --dataset_name trl-lib/ultrafeedback_binarized \
+ --model_name_or_path gpt2 \
+ --per_device_train_batch_size 4 \
+ --max_steps 1000 \
+ --learning_rate 8e-5 \
+ --gradient_accumulation_steps 1 \
+ --eval_steps 500 \
+ --output_dir "gpt2-lora-aligned-cpo" \
+ --optim rmsprop \
+ --warmup_steps 150 \
+ --logging_first_step \
+ --no_remove_unused_columns \
+ --use_peft \
+ --lora_r 16 \
+ --lora_alpha 16
+"""
+
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser
+
+from trl import ModelConfig, ScriptArguments, get_peft_config
+from trl.experimental.cpo import CPOConfig, CPOTrainer
+
+
+if __name__ == "__main__":
+ parser = HfArgumentParser((ScriptArguments, CPOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_into_dataclasses()
+
+ ################
+ # Model & Tokenizer
+ ################
+ model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path)
+ tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path)
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+
+ ################
+ # Dataset
+ ################
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+ ################
+ # Training
+ ################
+ trainer = CPOTrainer(
+ model,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ processing_class=tokenizer,
+ peft_config=get_peft_config(model_args),
+ )
+
+ # train and save the model
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/distillation.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/distillation.py
new file mode 100644
index 0000000000000000000000000000000000000000..576aa70304c8a2288714e3f3dadc8505ef7d2893
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/distillation.py
@@ -0,0 +1,177 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "peft",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+# docstyle-ignore
+"""
+# Full training (off-policy only, lmbda=0):
+```
+python examples/scripts/distillation.py \
+ --model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \
+ --teacher_model_name_or_path Qwen/Qwen2.5-1.5B-Instruct \
+ --dataset_name trl-lib/chatbot_arena_completions \
+ --learning_rate 2e-5 \
+ --per_device_train_batch_size 4 \
+ --gradient_accumulation_steps 8 \
+ --lmbda 0.0 \
+ --output_dir distilled-model \
+ --num_train_epochs 1
+```
+
+# Mixed on/off-policy (lmbda=0.5):
+```
+python examples/scripts/distillation.py \
+ --model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \
+ --teacher_model_name_or_path Qwen/Qwen2.5-1.5B-Instruct \
+ --dataset_name trl-lib/chatbot_arena_completions \
+ --learning_rate 2e-5 \
+ --per_device_train_batch_size 4 \
+ --gradient_accumulation_steps 8 \
+ --lmbda 0.5 \
+ --beta 0.5 \
+ --output_dir distilled-model \
+ --num_train_epochs 1
+```
+
+# LoRA:
+```
+python examples/scripts/distillation.py \
+ --model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \
+ --teacher_model_name_or_path Qwen/Qwen2.5-1.5B-Instruct \
+ --dataset_name trl-lib/chatbot_arena_completions \
+ --learning_rate 2e-4 \
+ --per_device_train_batch_size 4 \
+ --gradient_accumulation_steps 8 \
+ --lmbda 0.0 \
+ --output_dir distilled-model \
+ --num_train_epochs 1 \
+ --use_peft \
+ --lora_r 64 \
+ --lora_alpha 16
+```
+"""
+
+import argparse
+import os
+
+
+# Enable logging in a Hugging Face Space
+os.environ.setdefault("TRACKIO_SPACE_ID", "trl-trackio")
+
+
+def main(script_args, training_args, model_args):
+ from datasets import load_dataset
+ from transformers import GenerationConfig
+
+ from trl import (
+ LogCompletionsCallback,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+ )
+ from trl.experimental.distillation import DistillationTrainer
+
+ ################
+ # Model init kwargs
+ ################
+ quantization_config = get_quantization_config(model_args)
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=model_args.dtype,
+ use_cache=False if training_args.gradient_checkpointing else True,
+ device_map=get_kbit_device_map() if quantization_config is not None else None,
+ quantization_config=quantization_config,
+ )
+ training_args.model_init_kwargs = model_kwargs
+
+ teacher_model_kwargs = dict(
+ revision=training_args.teacher_model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=model_args.dtype,
+ use_cache=True,
+ device_map=get_kbit_device_map() if quantization_config is not None else None,
+ quantization_config=quantization_config,
+ )
+ if training_args.teacher_model_init_kwargs is not None:
+ teacher_model_kwargs.update(training_args.teacher_model_init_kwargs)
+ training_args.teacher_model_init_kwargs = teacher_model_kwargs
+
+ ################
+ # Dataset
+ ################
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+ ################
+ # Training
+ ################
+ eval_dataset = None
+ if training_args.eval_strategy != "no":
+ if script_args.dataset_test_split in dataset:
+ eval_dataset = dataset[script_args.dataset_test_split]
+ elif "validation" in dataset:
+ eval_dataset = dataset["validation"]
+ elif "dev" in dataset:
+ eval_dataset = dataset["dev"]
+
+ trainer = DistillationTrainer(
+ model=model_args.model_name_or_path,
+ teacher_model=training_args.teacher_model_name_or_path,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=eval_dataset,
+ peft_config=get_peft_config(model_args),
+ )
+
+ if training_args.eval_strategy != "no":
+ generation_config = GenerationConfig(
+ max_new_tokens=training_args.max_completion_length, do_sample=True, temperature=training_args.temperature
+ )
+ completions_callback = LogCompletionsCallback(trainer, generation_config, num_prompts=8)
+ trainer.add_callback(completions_callback)
+
+ trainer.train()
+
+ # Save and push to Hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
+
+
+def make_parser(subparsers: argparse._SubParsersAction | None = None, prog: str | None = None):
+ from trl import ModelConfig, ScriptArguments, TrlParser
+ from trl.experimental.distillation import DistillationConfig
+
+ dataclass_types = (ScriptArguments, DistillationConfig, ModelConfig)
+ if subparsers is not None:
+ parser = subparsers.add_parser(
+ "distillation", help="Run the distillation training script", dataclass_types=dataclass_types
+ )
+ else:
+ parser = TrlParser(dataclass_types, prog=prog)
+ return parser
+
+
+if __name__ == "__main__":
+ parser = make_parser()
+ script_args, training_args, model_args = parser.parse_args_and_config(fail_with_unknown_args=False)
+ main(script_args, training_args, model_args)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/dpo.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/dpo.py
new file mode 100644
index 0000000000000000000000000000000000000000..276f4c61b25db6e6ae2b1e2a51458103f068c55a
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/dpo.py
@@ -0,0 +1,17 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+###############################################################################################
+# This file has been moved to https://github.com/huggingface/trl/blob/main/trl/scripts/dpo.py #
+###############################################################################################
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/dpo_vlm.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/dpo_vlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c41e003766b1db71c9abaacb288fd1044d972de
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/dpo_vlm.py
@@ -0,0 +1,134 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "Pillow>=9.4.0",
+# "torchvision",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Without dataset streaming:
+
+```
+accelerate launch examples/scripts/dpo_vlm.py \
+ --dataset_name HuggingFaceH4/rlaif-v_formatted \
+ --model_name_or_path Qwen/Qwen2.5-VL-3B-Instruct \
+ --per_device_train_batch_size 2 \
+ --gradient_accumulation_steps 32 \
+ --dataset_num_proc 32 \
+ --output_dir dpo_qwen_2_5_rlaif-v \
+ --dtype bfloat16 \
+ --use_peft \
+ --lora_target_modules all-linear
+```
+
+With dataset streaming:
+
+```
+accelerate launch examples/scripts/dpo_vlm.py \
+ --dataset_name HuggingFaceH4/rlaif-v_formatted \
+ --dataset_streaming \
+ --model_name_or_path Qwen/Qwen2.5-VL-3B-Instruct \
+ --per_device_train_batch_size 2 \
+ --max_steps 100 \
+ --gradient_accumulation_steps 32 \
+ --dataset_num_proc 32 \
+ --output_dir dpo_qwen_2_5_rlaif-v \
+ --dtype bfloat16 \
+ --use_peft \
+ --lora_target_modules all-linear
+```
+"""
+
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForImageTextToText, AutoProcessor
+
+from trl import (
+ DPOConfig,
+ DPOTrainer,
+ ModelConfig,
+ ScriptArguments,
+ TrlParser,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+)
+
+
+if __name__ == "__main__":
+ parser = TrlParser((ScriptArguments, DPOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+
+ ################
+ # Model & Processor
+ ################
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ model_kwargs["device_map"] = get_kbit_device_map()
+ model_kwargs["quantization_config"] = quantization_config
+
+ model = AutoModelForImageTextToText.from_pretrained(
+ model_args.model_name_or_path,
+ **model_kwargs,
+ )
+ peft_config = get_peft_config(model_args)
+
+ processor = AutoProcessor.from_pretrained(model_args.model_name_or_path, do_image_splitting=False)
+
+ if script_args.ignore_bias_buffers:
+ # torch distributed hack
+ model._ddp_params_and_buffers_to_ignore = [
+ name for name, buffer in model.named_buffers() if buffer.dtype == torch.bool
+ ]
+
+ ################
+ # Dataset
+ ################
+ dataset = load_dataset(
+ script_args.dataset_name,
+ name=script_args.dataset_config,
+ streaming=script_args.dataset_streaming,
+ )
+
+ ################
+ # Training
+ ################
+ trainer = DPOTrainer(
+ model,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ peft_config=peft_config,
+ )
+
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/gkd.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/gkd.py
new file mode 100644
index 0000000000000000000000000000000000000000..f85c460206dd025e5ac1b85ef7c9cb061a02f6c6
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/gkd.py
@@ -0,0 +1,139 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+# Full training:
+python examples/scripts/gkd.py \
+ --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
+ --teacher_model_name_or_path Qwen/Qwen2-1.5B-Instruct \
+ --dataset_name trl-lib/chatbot_arena_completions \
+ --learning_rate 2e-5 \
+ --per_device_train_batch_size 4 \
+ --gradient_accumulation_steps 8 \
+ --output_dir gkd-model \
+ --num_train_epochs 1 \
+ --push_to_hub
+
+# LoRA:
+python examples/scripts/gkd.py \
+ --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
+ --teacher_model_name_or_path Qwen/Qwen2-1.5B-Instruct \
+ --dataset_name trl-lib/chatbot_arena_completions \
+ --learning_rate 2e-4 \
+ --per_device_train_batch_size 4 \
+ --gradient_accumulation_steps 8 \
+ --output_dir gkd-model \
+ --num_train_epochs 1 \
+ --push_to_hub \
+ --use_peft \
+ --lora_r 64 \
+ --lora_alpha 16
+"""
+
+from datasets import load_dataset
+from transformers import AutoTokenizer, GenerationConfig
+
+from trl import (
+ LogCompletionsCallback,
+ ModelConfig,
+ ScriptArguments,
+ TrlParser,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+)
+from trl.experimental.gkd import GKDConfig, GKDTrainer
+
+
+if __name__ == "__main__":
+ parser = TrlParser((ScriptArguments, GKDConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+
+ ################
+ # Model & Tokenizer
+ ################
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=model_args.dtype,
+ use_cache=False if training_args.gradient_checkpointing else True,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ model_kwargs["device_map"] = get_kbit_device_map()
+ model_kwargs["quantization_config"] = quantization_config
+
+ training_args.model_init_kwargs = model_kwargs
+
+ teacher_model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=model_args.dtype,
+ use_cache=True,
+ )
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ model_kwargs["device_map"] = get_kbit_device_map()
+ model_kwargs["quantization_config"] = quantization_config
+
+ training_args.teacher_model_init_kwargs = teacher_model_kwargs
+
+ tokenizer = AutoTokenizer.from_pretrained(
+ model_args.model_name_or_path,
+ revision=model_args.model_revision,
+ padding_side="left",
+ )
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+
+ ################
+ # Dataset
+ ################
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+ ################
+ # Training
+ ################
+ trainer = GKDTrainer(
+ model=model_args.model_name_or_path,
+ teacher_model=training_args.teacher_model_name_or_path,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ processing_class=tokenizer,
+ peft_config=get_peft_config(model_args),
+ )
+
+ if training_args.eval_strategy != "no":
+ generation_config = GenerationConfig(
+ max_new_tokens=training_args.max_new_tokens, do_sample=True, temperature=training_args.temperature
+ )
+ completions_callback = LogCompletionsCallback(trainer, generation_config, num_prompts=8)
+ trainer.add_callback(completions_callback)
+
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/gold.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/gold.py
new file mode 100644
index 0000000000000000000000000000000000000000..b6610acb028790b49c17d3a987742eb2aca25a27
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/gold.py
@@ -0,0 +1,152 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl @ git+https://github.com/huggingface/trl.git",
+# "peft",
+# "trackio",
+# ]
+# ///
+
+# docstyle-ignore
+"""
+# Full training:
+python examples/scripts/gold.py \
+ --model_name_or_path meta-llama/Llama-3.2-1B-Instruct \
+ --teacher_model_name_or_path Qwen/Qwen2-1.5B-Instruct \
+ --dataset_name trl-lib/chatbot_arena_completions \
+ --learning_rate 2e-5 \
+ --per_device_train_batch_size 4 \
+ --gradient_accumulation_steps 8 \
+ --output_dir gold-model \
+ --num_train_epochs 1 \
+ --push_to_hub
+
+# LoRA:
+python examples/scripts/gold.py \
+ --model_name_or_path meta-llama/Llama-3.2-1B-Instruct \
+ --teacher_model_name_or_path Qwen/Qwen2-1.5B-Instruct \
+ --dataset_name trl-lib/chatbot_arena_completions \
+ --learning_rate 2e-4 \
+ --per_device_train_batch_size 4 \
+ --gradient_accumulation_steps 8 \
+ --output_dir gold-model \
+ --num_train_epochs 1 \
+ --push_to_hub \
+ --use_peft \
+ --lora_r 64 \
+ --lora_alpha 16
+"""
+
+import logging
+
+from datasets import load_dataset
+from transformers import AutoTokenizer, GenerationConfig
+
+from trl import (
+ LogCompletionsCallback,
+ ModelConfig,
+ ScriptArguments,
+ TrlParser,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+)
+from trl.experimental.gold.gold_config import GOLDConfig
+from trl.experimental.gold.gold_trainer import GOLDTrainer
+
+
+logger = logging.getLogger(__name__)
+
+
+if __name__ == "__main__":
+ parser = TrlParser((ScriptArguments, GOLDConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+
+ ################
+ # Model & Tokenizer
+ ################
+ quantization_config = get_quantization_config(model_args)
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=model_args.dtype,
+ use_cache=False if training_args.gradient_checkpointing else True,
+ device_map=get_kbit_device_map() if quantization_config is not None else None,
+ quantization_config=quantization_config,
+ )
+ training_args.model_init_kwargs = model_kwargs
+
+ if training_args.teacher_tokenizer_name_or_path is None and training_args.use_uld_loss:
+ training_args.teacher_tokenizer_name_or_path = training_args.teacher_model_name_or_path
+ teacher_model_kwargs = dict(
+ revision=training_args.teacher_model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=model_args.dtype,
+ use_cache=True,
+ device_map=get_kbit_device_map() if quantization_config is not None else None,
+ quantization_config=quantization_config,
+ )
+ if training_args.teacher_model_init_kwargs is not None:
+ teacher_model_kwargs.update(training_args.teacher_model_init_kwargs)
+ training_args.teacher_model_init_kwargs = teacher_model_kwargs
+
+ tokenizer = AutoTokenizer.from_pretrained(
+ model_args.model_name_or_path,
+ revision=model_args.model_revision,
+ )
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+
+ ################
+ # Dataset
+ ################
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+ ################
+ # Training
+ ################
+ eval_dataset = None
+ if training_args.eval_strategy != "no":
+ if script_args.dataset_test_split in dataset:
+ eval_dataset = dataset[script_args.dataset_test_split]
+ elif "validation" in dataset:
+ eval_dataset = dataset["validation"]
+ elif "dev" in dataset:
+ eval_dataset = dataset["dev"]
+
+ trainer = GOLDTrainer(
+ model=model_args.model_name_or_path,
+ teacher_model=training_args.teacher_model_name_or_path,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=eval_dataset,
+ processing_class=tokenizer,
+ peft_config=get_peft_config(model_args),
+ )
+
+ if training_args.eval_strategy != "no":
+ generation_config = GenerationConfig(
+ max_new_tokens=training_args.max_completion_length, do_sample=True, temperature=training_args.temperature
+ )
+ completions_callback = LogCompletionsCallback(trainer, generation_config, num_prompts=8)
+ trainer.add_callback(completions_callback)
+
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/grpo_2048.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/grpo_2048.py
new file mode 100644
index 0000000000000000000000000000000000000000..09c2816dcbcffa30f41854a4353cc0b81cff102e
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/grpo_2048.py
@@ -0,0 +1,161 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# ]
+# ///
+
+import random
+
+from datasets import Dataset
+from peft import LoraConfig
+
+from trl import GRPOConfig, GRPOTrainer
+
+
+PROMPT = "Play 2048 on a 4x4 board. Use the tool `move` with one of: up, down, left, right. Maximize the score."
+
+
+class Game2048Env:
+ def reset(self, **kwargs) -> str:
+ self.board = [[0] * 4 for _ in range(4)]
+ self.score = 0.0
+ self.done = False
+ self._spawn()
+ self._spawn()
+ return f"score={self.score}\n{self._render()}\ndone={self.done}"
+
+ def move(self, direction: str) -> str:
+ """
+ Play one move in 2048.
+
+ Args:
+ direction: One of "up", "down", "left", "right".
+
+ Returns:
+ Environment feedback after the move.
+ """
+ if self.done:
+ raise ValueError("Game over.")
+ moved, gained = self._apply_move(direction.strip().lower())
+ if moved:
+ self.score += gained
+ self._spawn()
+ self.done = not self._can_move()
+ return f"score={self.score}\n{self._render()}\ndone={self.done}"
+
+ def _spawn(self) -> None:
+ empty = [(r, c) for r in range(4) for c in range(4) if self.board[r][c] == 0]
+ if not empty:
+ return
+ r, c = random.choice(empty)
+ self.board[r][c] = 4 if random.random() < 0.1 else 2
+
+ @staticmethod
+ def _merge_line(line: list[int]) -> tuple[list[int], int]:
+ vals = [x for x in line if x]
+ out = []
+ gained = 0
+ i = 0
+ while i < len(vals):
+ if i + 1 < len(vals) and vals[i] == vals[i + 1]:
+ v = vals[i] * 2
+ out.append(v)
+ gained += v
+ i += 2
+ else:
+ out.append(vals[i])
+ i += 1
+ out += [0] * (4 - len(out))
+ return out, gained
+
+ def _apply_move(self, direction: str) -> tuple[bool, int]:
+ if direction not in {"up", "down", "left", "right"}:
+ return False, 0
+
+ before = [row[:] for row in self.board]
+ gained_total = 0
+
+ if direction in {"left", "right"}:
+ for r in range(4):
+ row = self.board[r][:]
+ if direction == "right":
+ row.reverse()
+ merged, gained = self._merge_line(row)
+ if direction == "right":
+ merged.reverse()
+ self.board[r] = merged
+ gained_total += gained
+ else:
+ for c in range(4):
+ col = [self.board[r][c] for r in range(4)]
+ if direction == "down":
+ col.reverse()
+ merged, gained = self._merge_line(col)
+ if direction == "down":
+ merged.reverse()
+ for r in range(4):
+ self.board[r][c] = merged[r]
+ gained_total += gained
+
+ moved = self.board != before
+ return moved, gained_total
+
+ def _can_move(self) -> bool:
+ if any(0 in row for row in self.board):
+ return True
+ for r in range(4):
+ for c in range(4):
+ if r + 1 < 4 and self.board[r][c] == self.board[r + 1][c]:
+ return True
+ if c + 1 < 4 and self.board[r][c] == self.board[r][c + 1]:
+ return True
+ return False
+
+ def _render(self) -> str:
+ return "\n".join(" ".join(f"{v:3d}" for v in row) for row in self.board)
+
+
+def reward_score(environments, **kwargs):
+ return [env.score for env in environments]
+
+
+def main() -> None:
+ dataset = Dataset.from_dict({"prompt": [[{"role": "user", "content": PROMPT}] for _ in range(1000)]})
+
+ trainer = GRPOTrainer(
+ model="Qwen/Qwen3-4B",
+ train_dataset=dataset,
+ reward_funcs=reward_score,
+ args=GRPOConfig(
+ chat_template_kwargs={"enable_thinking": False},
+ logging_steps=1,
+ log_completions=True,
+ num_completions_to_print=2,
+ report_to="trackio",
+ trackio_space_id="trl-2048",
+ max_completion_length=2048,
+ per_device_train_batch_size=4,
+ gradient_accumulation_steps=2,
+ ),
+ environment_factory=Game2048Env,
+ peft_config=LoraConfig(),
+ )
+ trainer.train()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/grpo_agent.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/grpo_agent.py
new file mode 100644
index 0000000000000000000000000000000000000000..4742a45502a85ff17203530974b3d3d622f3cd4f
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/grpo_agent.py
@@ -0,0 +1,320 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+# Full training
+```
+python examples/scripts/grpo_agent.py \
+ --model_name_or_path Qwen/Qwen3-1.7B \
+ --output_dir grpo_biogrid_qwen_3g-1.7b \
+ --push_to_hub True \
+ --use_vllm True \
+ --vllm_mode colocate \
+ --max_completion_length 1024 \
+ --report_to trackio \
+ --log_completions True \
+ --max_steps 400
+```
+"""
+
+import re
+import signal
+import sqlite3
+import textwrap
+from contextlib import contextmanager
+
+from datasets import load_dataset
+
+from trl import GRPOConfig, GRPOTrainer, ModelConfig, ScriptArguments, TrlParser
+
+
+def query_reward(completions, answer, **kwargs):
+ """
+ Reward query strategy:
+ - Penalize more than 2 queries
+ - Penalize generic queries (LIMIT 1 / PRAGMA)
+ - Reward usage of WHERE
+ - Reward evidence supporting the final answer
+ """
+ rewards = []
+
+ for completion, ans in zip(completions, answer, strict=False):
+ reward = 0.0
+ sql_queries = []
+ tool_results = []
+
+ # collect all SQL queries and tool results
+ for turn in completion:
+ if turn.get("tool_calls"):
+ for call in turn["tool_calls"]:
+ sql = call["function"]["arguments"].get("sql_command", "").lower()
+ sql_queries.append(sql)
+ if turn.get("role") == "tool" and turn.get("content"):
+ tool_results.append(turn["content"])
+
+ # --- penalize too many queries ---
+ if len(sql_queries) > 3:
+ reward -= 1.5
+
+ # --- check query quality ---
+ where_count = 0
+ for q in sql_queries:
+ if "limit 1" in q:
+ reward -= 1.0
+ if " where " not in q:
+ reward -= 0.5
+ else:
+ where_count += 1
+ reward += min(where_count, 3) * 0.4 # small bonus for WHERE usage
+
+ # --- evidence check: do queries support the answer? ---
+ combined_results = []
+ error_detected = False
+
+ for res in tool_results:
+ if isinstance(res, dict) and "error" in res:
+ error_detected = True
+ elif isinstance(res, list):
+ combined_results.extend(res)
+
+ # if error detected, penalize heavily
+ if error_detected:
+ reward -= 2.0
+ elif len(sql_queries) == 0:
+ reward -= 1.5
+ else:
+ has_hits = len(combined_results) > 0
+ correct_answer = ans.lower()
+ if (has_hits and correct_answer == "yes") or (not has_hits and correct_answer == "no"):
+ reward += 2.0
+ else:
+ reward -= 1.5
+
+ rewards.append(reward)
+
+ return rewards
+
+
+def correctness_reward(completions, answer, **kwargs):
+ """
+ Reward Yes/No correctness.
+ Model must provide final answer enclosed in stars — *yes* or *no*.
+ Does not reward informal yes/no buried in text.
+ """
+ rewards = []
+ for completion, ans in zip(completions, answer, strict=False):
+ raw = completion[-1]["content"].lower()
+
+ # detect form *yes* or *no*
+ match = re.search(r"\*(yes|no)\*", raw)
+ guess = match.group(1) if match else None
+
+ reward = 0.0
+
+ if guess is None:
+ reward -= 0.5 # invalid format
+ elif guess == ans.lower():
+ reward += 0.6 # correct under required format
+ else:
+ reward -= 1.0 # wrong answer
+
+ rewards.append(reward)
+
+ return rewards
+
+
+def structure_reward(completions, **kwargs):
+ """
+ Reward proper assistant structure.
+ Encourages a logical sequence: tool call + response + optional extra content.
+ """
+ rewards = []
+
+ for completion in completions:
+ has_call = False
+ has_response = False
+ has_other = False
+
+ for turn in completion:
+ role = turn.get("role")
+ if role == "assistant" and turn.get("tool_calls"):
+ has_call = True
+ elif role == "tool":
+ has_response = True
+ else:
+ content = turn.get("content")
+ if content and content.strip() not in ["", ""]:
+ has_other = True
+
+ # Reward sequences
+ if has_call and has_response:
+ if has_other:
+ reward = 0.1
+ else:
+ reward = 0.05 # still positive even without extra text
+ elif has_call and not has_response:
+ reward = -0.15
+ else:
+ reward = 0.0 # neutral if no call
+
+ rewards.append(reward)
+
+ return rewards
+
+
+# ------------------------
+# Database tool function
+# ------------------------
+class TimeoutError(Exception):
+ """Raised when a function call times out."""
+
+ pass
+
+
+@contextmanager
+def timeout(seconds):
+ """Context manager that raises TimeoutError if execution exceeds time limit."""
+
+ def timeout_handler(signum, frame):
+ raise TimeoutError(f"Operation timed out after {seconds} seconds")
+
+ signal.signal(signal.SIGALRM, timeout_handler)
+ signal.alarm(seconds)
+ try:
+ yield
+ finally:
+ signal.alarm(0)
+
+
+def query_biogrid(sql_command: str) -> list[tuple]:
+ """
+ Execute a read-only SQL command on the BioGRID database.
+
+ BioGRID is a curated biological database that compiles protein, genetic, and chemical interactions from multiple organisms. It provides researchers with experimentally verified interaction data to support studies in systems biology and functional genomics.
+
+ Args:
+ sql_command: The SQL command to execute.
+
+ Returns:
+ A list of tuples containing the query results.
+ """
+ with timeout(5):
+ conn = sqlite3.connect("file:biogrid.db?mode=ro", uri=True)
+ cursor = conn.cursor()
+ try:
+ cursor.execute(sql_command)
+ results = cursor.fetchall()
+ finally:
+ conn.close()
+ return results
+
+
+# ------------------------
+# Dataset formatting
+# ------------------------
+def format_example(example):
+ question = example["question"]
+ preamble = textwrap.dedent("""\
+ You have access to the BioGRID SQLite database.
+ Use SQL queries to retrieve only the information needed to answer the question.
+
+ Genes may appear in the database in columns `Alt_IDs_Interactor_A` `Alt_IDs_Interactor_B`, `Aliases_Interactor_A` and `Aliases_Interactor_B`,
+ and each entry can contain multiple gene names or synonyms separated by '|', for example:
+ 'entrez gene/locuslink:JNKK(gene name synonym)|entrez gene/locuslink:MAPKK4(gene name synonym)|...'
+ So a gene like 'JNKK' or 'MAPKK4' may appear inside one of these strings.
+
+ If the database schema is unclear or you are unsure about column names:
+ - First inspect the schema with `PRAGMA table_info(interactions);`
+ - Or preview a few rows with `SELECT * FROM interactions LIMIT 1;`
+
+ Otherwise, directly query the required data.
+
+ Final answer must be enclosed in stars, e.g. *Yes* or *No*.
+ Facts:
+ - The NCBI Taxonomy identifier for humans is taxid:9606.
+ """)
+ content = f"{preamble}\nQuestion: {question}"
+ prompt = [{"role": "user", "content": content}]
+ return {"prompt": prompt}
+
+
+# ------------------------
+# Main
+# ------------------------
+if __name__ == "__main__":
+ parser = TrlParser((ScriptArguments, GRPOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+
+ # ------------------------
+ # Create DB
+ # ------------------------
+ print("Creating biogrid.db...")
+ # Load dataset
+ biogrid_dataset = load_dataset("qgallouedec/biogrid", split="train")
+ df = biogrid_dataset.to_pandas()
+
+ # Normalize column names: remove spaces, replace with underscores
+ df.columns = [c.replace(" ", "_") for c in df.columns]
+ conn = sqlite3.connect("biogrid.db")
+ try:
+ df.to_sql("interactions", conn, if_exists="replace", index=False)
+ print(f"biogrid.db created. Rows stored: {len(df)}")
+ finally:
+ conn.close()
+
+ # ------------------------
+ # Load and format dataset
+ # ------------------------
+ dataset = load_dataset("qgallouedec/biogrid_qa", split="train")
+ dataset = dataset.filter(
+ lambda example: example["question"].startswith("Does the gene ")
+ ) # keep only simple questions for example
+ dataset = dataset.map(format_example, remove_columns=["question"])
+
+ train_dataset = dataset
+ eval_dataset = None # No eval by default, can be added if needed
+
+ training_args.chat_template_kwargs = {"enable_thinking": False}
+
+ # ------------------------
+ # Initialize trainer
+ # ------------------------
+ trainer = GRPOTrainer(
+ model=model_args.model_name_or_path,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ tools=[query_biogrid],
+ reward_funcs=[correctness_reward, structure_reward, query_reward],
+ args=training_args,
+ )
+
+ # ------------------------
+ # Train
+ # ------------------------
+ trainer.train()
+
+ # ------------------------
+ # Save and push
+ # ------------------------
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/grpo_continuous_batching.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/grpo_continuous_batching.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed6aade0f75b2b6ae6f2e7e77140a24c17c66c53
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/grpo_continuous_batching.py
@@ -0,0 +1,133 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "kernels",
+# ]
+# ///
+
+"""
+GRPO training on GSM8K using transformers' continuous batching engine instead of the default
+generate(). Continuous batching removes finished sequences from the batch immediately rather than
+waiting for the slowest one, which yields faster generation and lower VRAM than default generate()
+for tasks with variable completion lengths (N≥32).
+
+The key config parameter is `max_memory_percent` in `transformers_continuous_batching_config`,
+which caps the paged KV cache as a fraction of free VRAM. TRL defaults to 0.5; tune it down to
+0.3-0.4 for large generation batches to leave room for the training backward pass.
+
+python examples/scripts/grpo_continuous_batching.py \
+ --model_name_or_path Qwen/Qwen3-1.7B \
+ --output_dir grpo-gsm8k-continuous-batching \
+ --num_generations 32 \
+ --max_completion_length 1024 \
+ --use_peft \
+ --log_completions
+
+accelerate launch --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+ examples/scripts/grpo_continuous_batching.py \
+ --model_name_or_path Qwen/Qwen3-1.7B \
+ --output_dir grpo-gsm8k-continuous-batching \
+ --num_generations 32 \
+ --max_completion_length 1024 \
+ --use_peft \
+ --log_completions
+"""
+
+import logging
+import re
+
+import torch
+from datasets import load_dataset
+
+from trl import GRPOConfig, GRPOTrainer, ModelConfig, ScriptArguments, TrlParser, get_peft_config
+
+
+logging.getLogger("ContinuousBatchingLogger").setLevel(logging.ERROR)
+
+SYSTEM_PROMPT = (
+ "You are a helpful math tutor. Solve the problem step by step, then provide the final "
+ "numeric answer on the last line in the format: #### "
+)
+
+
+def extract_answer(text: str) -> str | None:
+ match = re.search(r"####\s*([\d,]+)", text)
+ return match.group(1).replace(",", "") if match else None
+
+
+def correctness_reward(completions, reference_answer, **kwargs):
+ rewards = []
+ for completion, ref in zip(completions, reference_answer, strict=False):
+ predicted = extract_answer(completion if isinstance(completion, str) else completion[-1]["content"])
+ rewards.append(1.0 if predicted is not None and predicted == ref else 0.0)
+ return rewards
+
+
+if __name__ == "__main__":
+ parser = TrlParser((ScriptArguments, GRPOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+
+ ################
+ # Model
+ ################
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+ training_args.model_init_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ )
+
+ ################
+ # Dataset
+ ################
+ dataset = load_dataset(
+ script_args.dataset_name or "openai/gsm8k",
+ script_args.dataset_config or "main",
+ split=script_args.dataset_train_split,
+ )
+
+ def make_conversation(example):
+ return {
+ "prompt": [
+ {"role": "system", "content": SYSTEM_PROMPT},
+ {"role": "user", "content": example["question"]},
+ ],
+ "reference_answer": example["answer"].split("####")[-1].strip().replace(",", ""),
+ }
+
+ dataset = dataset.map(make_conversation, remove_columns=dataset.column_names)
+
+ ################
+ # Training
+ ################
+ training_args.use_transformers_continuous_batching = True
+ if training_args.transformers_continuous_batching_config is None:
+ training_args.transformers_continuous_batching_config = {"use_cuda_graph": False}
+
+ trainer = GRPOTrainer(
+ model=model_args.model_name_or_path,
+ reward_funcs=correctness_reward,
+ args=training_args,
+ train_dataset=dataset,
+ peft_config=get_peft_config(model_args),
+ )
+
+ trainer.train()
+
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/grpo_vlm.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/grpo_vlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..c748b1b15fc1750a5dbf83e0a6c54beed627053c
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/grpo_vlm.py
@@ -0,0 +1,157 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "Pillow",
+# "math-verify",
+# "latex2sympy2_extended",
+# "torchvision",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+pip install math_verify
+
+# For Qwen/Qwen2.5-VL-3B-Instruct
+accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+ examples/scripts/grpo_vlm.py \
+ --model_name_or_path Qwen/Qwen2.5-VL-3B-Instruct \
+ --output_dir grpo-Qwen2.5-VL-3B-Instruct \
+ --learning_rate 1e-5 \
+ --dtype bfloat16 \
+ --max_completion_length 1024 \
+ --use_vllm \
+ --vllm_mode colocate \
+ --use_peft \
+ --lora_target_modules "q_proj", "v_proj" \
+ --log_completions
+
+# For HuggingFaceTB/SmolVLM2-2.2B-Instruct
+pip install num2words==0.5.14
+
+accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+ examples/scripts/grpo_vlm.py \
+ --model_name_or_path HuggingFaceTB/SmolVLM2-2.2B-Instruct \
+ --output_dir grpo-SmolVLM2-2.2B-Instruct \
+ --learning_rate 1e-5 \
+ --dtype bfloat16 \
+ --max_completion_length 1024 \
+ --use_peft \
+ --lora_target_modules "q_proj", "v_proj" \
+ --log_completions \
+ --per_device_train_batch_size 1 \
+ --gradient_accumulation_steps 2 \
+ --num_generations 2
+
+"""
+
+import torch
+from datasets import load_dataset
+
+from trl import (
+ GRPOConfig,
+ GRPOTrainer,
+ ModelConfig,
+ ScriptArguments,
+ TrlParser,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+)
+from trl.rewards import accuracy_reward, think_format_reward
+
+
+if __name__ == "__main__":
+ parser = TrlParser((ScriptArguments, GRPOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+ ################
+ # Model
+ ################
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+ training_args.model_init_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ training_args.model_init_kwargs["device_map"] = get_kbit_device_map()
+ training_args.model_init_kwargs["quantization_config"] = quantization_config
+
+ ################
+ # Dataset
+ ################
+ dataset = load_dataset("lmms-lab/multimodal-open-r1-8k-verified", split="train")
+ dataset = dataset.train_test_split(test_size=100, seed=42)
+
+ SYSTEM_PROMPT = (
+ "A conversation between user and assistant. The user asks a question, and the assistant solves it. The "
+ "assistant first thinks about the reasoning process in the mind and then provides the user with the answer. "
+ "The reasoning process and answer are enclosed within tags, i.e., \nThis is my "
+ "reasoning.\n\nThis is my answer."
+ )
+
+ def make_conversation(example):
+ prompt = [
+ {"role": "system", "content": SYSTEM_PROMPT},
+ {"role": "user", "content": example["problem"]},
+ ]
+ return {"prompt": prompt}
+
+ dataset = dataset.map(make_conversation)
+
+ # Filter have big images
+ def filter_big_images(example):
+ image = example["image"]
+ return image.size[0] < 512 and image.size[1] < 512
+
+ dataset = dataset.filter(filter_big_images)
+
+ def convert_to_rgb(example):
+ image = example["image"]
+ if image.mode != "RGB":
+ image = image.convert("RGB")
+ example["image"] = image
+ return example
+
+ dataset = dataset.map(convert_to_rgb)
+
+ train_dataset = dataset["train"]
+ eval_dataset = dataset["test"] if training_args.eval_strategy != "no" else None
+
+ ################
+ # Training
+ ################
+ trainer = GRPOTrainer(
+ model=model_args.model_name_or_path,
+ args=training_args,
+ reward_funcs=[think_format_reward, accuracy_reward],
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ peft_config=get_peft_config(model_args),
+ )
+
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/gspo.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/gspo.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f347fd6e3a3f2fbcaaff3cd3902a97981dba66b
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/gspo.py
@@ -0,0 +1,131 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "math-verify",
+# "latex2sympy2_extended",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+pip install math_verify
+
+# For Qwen/Qwen3-0.6B
+pip install num2words==0.5.14
+
+accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+ examples/scripts/gspo.py \
+ --model_name_or_path Qwen/Qwen3-0.6B \
+ --output_dir gspo-Qwen3-0.6B \
+ --learning_rate 1e-5 \
+ --dtype bfloat16 \
+ --max_completion_length 1024 \
+ --use_peft \
+ --lora_target_modules "q_proj", "v_proj" \
+ --log_completions \
+ --per_device_train_batch_size 8 \
+ --num_generations 8 \
+ --importance_sampling_level sequence \
+ --epsilon 3e-4 \
+ --epsilon_high 4e-4 \
+ --beta 0.0 \
+ --loss_type grpo \
+ --gradient_accumulation_steps 2 \
+ --steps_per_generation 8
+
+"""
+
+import torch
+from datasets import load_dataset
+
+from trl import (
+ GRPOConfig,
+ GRPOTrainer,
+ ModelConfig,
+ ScriptArguments,
+ TrlParser,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+)
+from trl.rewards import accuracy_reward, think_format_reward
+
+
+if __name__ == "__main__":
+ parser = TrlParser((ScriptArguments, GRPOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+ ################
+ # Model & Processor
+ ################
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+ training_args.model_init_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ training_args.model_init_kwargs["device_map"] = get_kbit_device_map()
+ training_args.model_init_kwargs["quantization_config"] = quantization_config
+
+ ################
+ # Dataset
+ ################
+ train_dataset, eval_dataset = load_dataset("AI-MO/NuminaMath-TIR", split=["train[:5%]", "test[:5%]"])
+
+ SYSTEM_PROMPT = (
+ "A conversation between user and assistant. The user asks a question, and the assistant solves it. The "
+ "assistant first thinks about the reasoning process in the mind and then provides the user with the answer. "
+ "The reasoning process and answer are enclosed within tags, i.e., \nThis is my "
+ "reasoning.\n\nThis is my answer."
+ )
+
+ def make_conversation(example):
+ return {
+ "prompt": [
+ {"role": "system", "content": SYSTEM_PROMPT},
+ {"role": "user", "content": example["problem"]},
+ ],
+ }
+
+ train_dataset = train_dataset.map(make_conversation)
+ eval_dataset = eval_dataset.map(make_conversation)
+
+ train_dataset = train_dataset.remove_columns(["messages", "problem"])
+ eval_dataset = eval_dataset.remove_columns(["messages", "problem"])
+
+ ################
+ # Training
+ ################
+ trainer = GRPOTrainer(
+ model=model_args.model_name_or_path,
+ args=training_args,
+ reward_funcs=[think_format_reward, accuracy_reward],
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ peft_config=get_peft_config(model_args),
+ )
+
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/gspo_vlm.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/gspo_vlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..f96c68a1819af438856810823948ed2d53f33ecb
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/gspo_vlm.py
@@ -0,0 +1,146 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "Pillow",
+# "math-verify",
+# "latex2sympy2_extended",
+# "torchvision",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+pip install math_verify
+
+# For Qwen/Qwen2.5-VL-3B-Instruct
+accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+ examples/scripts/gspo_vlm.py \
+ --model_name_or_path Qwen/Qwen2.5-VL-3B-Instruct \
+ --output_dir gspo-Qwen2.5-VL-3B-Instruct \
+ --learning_rate 1e-5 \
+ --dtype bfloat16 \
+ --max_completion_length 1024 \
+ --use_peft \
+ --lora_target_modules "q_proj", "v_proj" \
+ --log_completions \
+ --per_device_train_batch_size 8 \
+ --num_generations 8 \
+ --importance_sampling_level sequence \
+ --epsilon 3e-4 \
+ --epsilon_high 4e-4 \
+ --beta 0.0 \
+ --loss_type grpo \
+ --gradient_accumulation_steps 2 \
+ --steps_per_generation 8
+
+"""
+
+import torch
+from datasets import load_dataset
+
+from trl import (
+ GRPOConfig,
+ GRPOTrainer,
+ ModelConfig,
+ ScriptArguments,
+ TrlParser,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+)
+from trl.rewards import accuracy_reward, think_format_reward
+
+
+if __name__ == "__main__":
+ parser = TrlParser((ScriptArguments, GRPOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+ ################
+ # Model
+ ################
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+ training_args.model_init_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ training_args.model_init_kwargs["device_map"] = get_kbit_device_map()
+ training_args.model_init_kwargs["quantization_config"] = quantization_config
+
+ ################
+ # Dataset
+ ################
+ dataset = load_dataset("lmms-lab/multimodal-open-r1-8k-verified", split="train")
+ dataset = dataset.train_test_split(test_size=100, seed=42)
+
+ SYSTEM_PROMPT = (
+ "A conversation between user and assistant. The user asks a question, and the assistant solves it. The "
+ "assistant first thinks about the reasoning process in the mind and then provides the user with the answer. "
+ "The reasoning process and answer are enclosed within tags, i.e., \nThis is my "
+ "reasoning.\n\nThis is my answer."
+ )
+
+ def make_conversation(example):
+ prompt = [
+ {"role": "system", "content": SYSTEM_PROMPT},
+ {"role": "user", "content": example["problem"]},
+ ]
+ return {"prompt": prompt}
+
+ dataset = dataset.map(make_conversation)
+
+ # Filter have big images
+ def filter_big_images(example):
+ image = example["image"]
+ return image.size[0] < 512 and image.size[1] < 512
+
+ dataset = dataset.filter(filter_big_images)
+
+ def convert_to_rgb(example):
+ image = example["image"]
+ if image.mode != "RGB":
+ image = image.convert("RGB")
+ example["image"] = image
+ return example
+
+ dataset = dataset.map(convert_to_rgb)
+
+ train_dataset = dataset["train"]
+ eval_dataset = dataset["test"] if training_args.eval_strategy != "no" else None
+
+ ################
+ # Training
+ ################
+ trainer = GRPOTrainer(
+ model=model_args.model_name_or_path,
+ args=training_args,
+ reward_funcs=[think_format_reward, accuracy_reward],
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ peft_config=get_peft_config(model_args),
+ )
+
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/data_agent.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/data_agent.py
new file mode 100644
index 0000000000000000000000000000000000000000..2f129dcd1e48ace6b2e1be3e79c5809a39ee715b
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/data_agent.py
@@ -0,0 +1,131 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = ["trl[vllm,harbor]", "harbor[e2b]"] # harbor[e2b]: the --env e2b backend (swap per --env)
+# ///
+
+"""GRPO training against a Harbor task suite.
+
+One ``HarborSpec`` fans out into TRL's three slots — ``.train_dataset`` / ``.environment_factory`` /
+``.reward_funcs``. The base agent (harness) is selected with ``--agent``: the built-in ``"bash"``, or
+an import/file path to a custom ``HarborEnv`` subclass. Harbor runs in-process, so install with
+``trl[harbor]`` (Python >= 3.12) plus the chosen sandbox backend's extra (``pip install "harbor[e2b]"``
+for the recommended ``--env e2b``; the ``docker`` backend just needs a reachable Docker daemon).
+
+Usage (server vLLM, single-node 2+2 GPU split):
+
+```sh
+# Terminal 1 — vLLM
+CUDA_VISIBLE_DEVICES=2,3 trl vllm-serve --model Qwen/Qwen3-4B --tensor-parallel-size 2 --port 8000
+
+# Terminal 2 — training
+CUDA_VISIBLE_DEVICES=0,1 accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero2.yaml --num_processes 2 \
+ examples/scripts/harbor/data_agent.py \
+ --vllm-mode server --vllm-server-base-url http://localhost:8000 --env e2b
+```
+"""
+
+import argparse
+
+from trl import GRPOConfig, GRPOTrainer
+from trl.experimental.harbor import HarborSpec
+
+
+def parse_args() -> argparse.Namespace:
+ parser = argparse.ArgumentParser(description="GRPO training against a Harbor task suite.")
+
+ parser.add_argument("--model", type=str, default="Qwen/Qwen3-4B")
+ parser.add_argument(
+ "--dataset",
+ type=str,
+ default="AdithyaSK/data_agent_rl_environment_train",
+ help="HF dataset repo id with a Harbor task tree, or a local path containing a tasks/ subtree.",
+ )
+ parser.add_argument(
+ "--agent",
+ type=str,
+ default="bash",
+ help="Base agent/harness: built-in name ('bash'), import path 'pkg.mod:Class', or file 'path.py:Class'.",
+ )
+ parser.add_argument(
+ "--env",
+ dest="environment_type",
+ type=str,
+ default="docker",
+ help="Harbor sandbox backend (docker, e2b, daytona, gke, modal, runloop, ...).",
+ )
+ parser.add_argument("--num-tasks", type=int, default=64)
+
+ parser.add_argument("--learning-rate", type=float, default=1e-6)
+ parser.add_argument("--per-device-train-batch-size", type=int, default=8)
+ parser.add_argument("--num-generations", type=int, default=8)
+ parser.add_argument("--max-completion-length", type=int, default=2048)
+ parser.add_argument("--max-steps", type=int, default=50)
+ parser.add_argument("--max-tool-calling-iterations", type=int, default=25)
+
+ parser.add_argument("--vllm-mode", choices=("colocate", "server"), default="colocate")
+ parser.add_argument("--vllm-server-base-url", type=str, default="http://localhost:8000")
+ parser.add_argument("--vllm-gpu-memory-utilization", type=float, default=0.3)
+
+ parser.add_argument("--output-dir", type=str, default=None)
+ parser.add_argument("--report-to", type=str, default="none")
+
+ return parser.parse_args()
+
+
+def main() -> None:
+ args = parse_args()
+
+ # One spec object — fans out into TRL's three slots.
+ spec = HarborSpec(
+ args.dataset,
+ agent=args.agent,
+ environment_type=args.environment_type,
+ num_tasks=args.num_tasks,
+ )
+
+ config_kwargs: dict = dict(
+ learning_rate=args.learning_rate,
+ per_device_train_batch_size=args.per_device_train_batch_size,
+ num_generations=args.num_generations,
+ max_completion_length=args.max_completion_length,
+ max_steps=args.max_steps,
+ max_tool_calling_iterations=args.max_tool_calling_iterations,
+ chat_template_kwargs={"enable_thinking": False},
+ log_completions=True,
+ use_vllm=True,
+ vllm_mode=args.vllm_mode,
+ report_to=[s.strip() for s in args.report_to.split(",") if s.strip() and s.strip() != "none"] or "none",
+ )
+ if args.output_dir:
+ config_kwargs["output_dir"] = args.output_dir
+ if args.vllm_mode == "colocate":
+ config_kwargs["vllm_gpu_memory_utilization"] = args.vllm_gpu_memory_utilization
+ else:
+ config_kwargs["vllm_server_base_url"] = args.vllm_server_base_url
+
+ trainer = GRPOTrainer(
+ model=args.model,
+ args=GRPOConfig(**config_kwargs),
+ train_dataset=spec.train_dataset,
+ environment_factory=spec.environment_factory,
+ reward_funcs=spec.reward_funcs,
+ )
+ trainer.train()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/__init__.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ea16e544084d2f348adcc612d3390fdb6f1ab98
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/__init__.py
@@ -0,0 +1,20 @@
+# 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 .bash import BashEnv
+from .jupyter import JupyterEnv
+from .terminal_notes import TerminalNotesEnv
+
+
+__all__ = ["BashEnv", "JupyterEnv", "TerminalNotesEnv"]
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/bash/README.md b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/bash/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..7746a405e4468439dad3e70dd1397916b9c9bad4
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/bash/README.md
@@ -0,0 +1,20 @@
+# `bash` harness
+
+The minimal harness: a single shell tool. This is the **built-in** [`HarborBashEnv`](../../../../../trl/experimental/harbor/_env.py) (`trl.experimental.harbor.HarborBashEnv`); this folder just documents it and re-exports it as `BashEnv`.
+
+## Tools
+
+| Tool | Signature | What it does |
+|---|---|---|
+| `bash` | `bash(command: str) -> str` | Run a shell command in the sandbox; returns combined stdout+stderr (truncated to 8k). Non-stateful between calls. |
+
+## Submission
+
+No submit tool — write the answer to `/workdir/answer.txt`, e.g. `echo -n "" > /workdir/answer.txt`. The task's verifier reads that file.
+
+## Use it
+
+```python
+from trl.experimental.harbor import HarborSpec
+spec = HarborSpec(dataset, agent="bash") # built-in name
+```
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/bash/__init__.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/bash/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d6b6e337db16c37cc7ee7acf6c749123fd992c87
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/bash/__init__.py
@@ -0,0 +1,18 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from trl.experimental.harbor import HarborBashEnv as BashEnv # the built-in bash harness
+
+
+__all__ = ["BashEnv"]
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/jupyter/README.md b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/jupyter/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..a0820fa814002975fa5a1573bd8390bbf43f8597
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/jupyter/README.md
@@ -0,0 +1,31 @@
+# `jupyter` harness
+
+A **stateful Python kernel** harness. Variables, imports, and side-effects persist across cells, so the
+model builds up state like a notebook. Implemented by `JupyterEnv` in [`env.py`](env.py).
+
+## How it works
+
+On `reset`, the harness (`_setup`) uploads two helpers into the sandbox and starts a tiny kernel server:
+
+- [`kernel_server.py`](kernel_server.py) — a local HTTP server (`127.0.0.1:8765`) holding one persistent Python kernel.
+- [`run_cell.py`](run_cell.py) — sends a base64-encoded cell to the kernel server and prints its JSON result.
+
+Each `add_and_execute_code_cell` call runs `python3 /opt/run_cell.py` against that kernel.
+
+## Tools
+
+| Tool | Signature | What it does |
+|---|---|---|
+| `add_and_execute_code_cell` | `add_and_execute_code_cell(code: str) -> str` | Execute Python in the **stateful** kernel; state persists across calls. Use for all computation. |
+| `execute_shell_command` | `execute_shell_command(command: str) -> str` | Run a shell command (pip install, ls, …). **Not** stateful with the Python kernel. |
+
+## Submission
+
+Write the answer to `/workdir/answer.txt` — e.g. `add_and_execute_code_cell(code="open('/workdir/answer.txt','w').write(str(ans))")`.
+
+## Use it
+
+```python
+from trl.experimental.harbor import HarborSpec
+spec = HarborSpec(dataset, agent="examples/scripts/harbor/harnesses/jupyter/env.py:JupyterEnv")
+```
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/jupyter/__init__.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/jupyter/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..882eb6482bc8f5cb03f0dc3a34f85e132197bd29
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/jupyter/__init__.py
@@ -0,0 +1,18 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .env import JupyterEnv
+
+
+__all__ = ["JupyterEnv"]
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/jupyter/env.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/jupyter/env.py
new file mode 100644
index 0000000000000000000000000000000000000000..91cfacaa7d5f2934e5a73b4268aa3db2f8c857a1
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/jupyter/env.py
@@ -0,0 +1,104 @@
+# 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.
+
+"""Jupyter-style base agent — a stateful-kernel Harbor harness.
+
+A custom [`~trl.experimental.harbor.HarborEnv`] subclass exposing a stateful Python kernel
+(variables/imports persist across cells) plus a shell tool. Point a trainer at it with
+``HarborSpec(dataset, agent="examples/scripts/harbor/harnesses/jupyter/env.py:JupyterEnv")``.
+
+The kernel is a tiny HTTP server (`kernel_server.py`, uploaded to /opt/ and started in `_setup`); each
+cell runs via `python3 /opt/run_cell.py` (see `run_cell.py`). Submission is by writing
+``/workdir/answer.txt`` (same verifier as the bash harness).
+"""
+
+import asyncio
+import base64
+import json
+import shlex
+from pathlib import Path
+
+from trl.experimental.harbor import HarborEnv
+
+
+_HERE = Path(__file__).parent
+
+_JUPYTER_PROMPT_SUFFIX = (
+ "\n\nYou are a data-analysis agent with a **stateful Python kernel**: variables, imports, and "
+ "side-effects persist across `add_and_execute_code_cell` calls. Dataset files are in "
+ "/home/user/input/. Use `execute_shell_command` for shell (pip install, ls). **Submit your final "
+ "answer by writing it to /workdir/answer.txt** (e.g. "
+ "`add_and_execute_code_cell(code=\"open('/workdir/answer.txt','w').write(str(ans))\")`). Keep it "
+ "short; do not end your turn without submitting."
+)
+
+
+class JupyterEnv(HarborEnv):
+ """Stateful-Jupyter-kernel harness over a Harbor sandbox."""
+
+ PROMPT_SUFFIX = _JUPYTER_PROMPT_SUFFIX
+
+ async def _setup(self) -> None:
+ # Upload the kernel server + cell runner, ensure curl, start the kernel, wait for it to bind.
+ await self._env.upload_file(_HERE / "kernel_server.py", "/opt/kernel_server.py")
+ await self._env.upload_file(_HERE / "run_cell.py", "/opt/run_cell.py")
+ await self._env.exec("which curl >/dev/null 2>&1 || apt-get install -y curl", timeout_sec=120)
+ await self._env.exec(
+ "nohup setsid python3 /opt/kernel_server.py >/tmp/kernel.log 2>&1 < /dev/null &", timeout_sec=30
+ )
+ for _ in range(30):
+ r = await self._env.exec("curl -s -o /dev/null -w '%{http_code}' http://127.0.0.1:8765/", timeout_sec=5)
+ if (r.stdout or "").strip() == "200":
+ return
+ await asyncio.sleep(0.5)
+ log = await self._env.exec("cat /tmp/kernel.log", timeout_sec=5)
+ raise RuntimeError(f"kernel_server failed to bind 127.0.0.1:8765\n--- kernel.log ---\n{log.stdout}")
+
+ def _run_cell(self, code: str) -> str:
+ b64 = base64.b64encode(code.encode()).decode()
+ result = self._loop.run_until_complete(
+ self._env.exec(f"python3 /opt/run_cell.py --code-b64 {shlex.quote(b64)}", timeout_sec=180)
+ )
+ raw = (result.stdout or "").strip()
+ if not raw:
+ return f"[run_cell empty stdout, rc={result.return_code}, stderr={result.stderr or ''}]"
+ try:
+ return str(json.loads(raw).get("output", ""))
+ except json.JSONDecodeError:
+ return f"[run_cell unparseable: {raw[:500]}]"
+
+ def add_and_execute_code_cell(self, code: str) -> str:
+ """
+ Execute Python code in the stateful kernel. Variables, imports, and side-effects persist across
+ calls. Use this for all computation.
+
+ Args:
+ code: The Python code to execute.
+
+ Returns:
+ The textual output of the executed cell.
+ """
+ return self._run_cell(code)
+
+ def execute_shell_command(self, command: str) -> str:
+ """
+ Run a shell command in the sandbox (pip install, ls, etc.). Not stateful with the Python kernel.
+
+ Args:
+ command: The shell command to run.
+
+ Returns:
+ The command's combined stdout and stderr.
+ """
+ return self._exec(command)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/jupyter/kernel_server.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/jupyter/kernel_server.py
new file mode 100644
index 0000000000000000000000000000000000000000..41985f4d41b74e3da2eeb4ae76c100ad3b92bf66
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/jupyter/kernel_server.py
@@ -0,0 +1,98 @@
+# 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.
+
+"""Tiny stateful Python execution server.
+
+Uploaded by JupyterToolAgent into the Harbor container at /opt/kernel_server.py
+and started in the background. Listens on 127.0.0.1:8765 and accepts:
+
+ POST / Content-Type: application/json
+ Body: {"code": "..."}
+ Reply: {"output": "", "ok": true|false}
+
+A single persistent globals dict survives across requests — that's the
+"stateful kernel" the agent's `add_and_execute_code_cell` tool relies on.
+No IPython, no jupyter_client. Just compile(...) + exec(...).
+"""
+
+from __future__ import annotations
+
+import contextlib
+import io
+import json
+import traceback
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+
+PORT = 8765
+G: dict = {"__name__": "__main__"}
+
+
+def _exec(code: str) -> tuple[str, bool]:
+ out = io.StringIO()
+ err = io.StringIO()
+ ok = True
+ try:
+ # Try "single" mode first so a bare expression auto-prints (mimics Jupyter).
+ try:
+ compiled = compile(code, "", "single")
+ except SyntaxError:
+ compiled = compile(code, "| ", "exec")
+ with contextlib.redirect_stdout(out), contextlib.redirect_stderr(err):
+ exec(compiled, G)
+ except SystemExit:
+ pass
+ except BaseException:
+ ok = False
+ err.write(traceback.format_exc())
+ return out.getvalue() + err.getvalue(), ok
+
+
+class Handler(BaseHTTPRequestHandler):
+ def do_POST(self):
+ try:
+ n = int(self.headers.get("Content-Length", "0"))
+ body = self.rfile.read(n).decode("utf-8", errors="replace")
+ payload = json.loads(body)
+ code = payload.get("code", "")
+ output, ok = _exec(code)
+ except Exception:
+ output, ok = traceback.format_exc(), False
+ # Cap to keep the per-cell response small.
+ if len(output) > 8000:
+ output = output[:8000] + f"\n... [truncated {len(output) - 8000} chars]"
+ body_out = json.dumps({"output": output, "ok": ok}).encode()
+ self.send_response(200)
+ self.send_header("Content-Type", "application/json")
+ self.send_header("Content-Length", str(len(body_out)))
+ self.end_headers()
+ self.wfile.write(body_out)
+
+ def do_GET(self):
+ # Health check.
+ msg = b'{"ready": true}'
+ self.send_response(200)
+ self.send_header("Content-Type", "application/json")
+ self.send_header("Content-Length", str(len(msg)))
+ self.end_headers()
+ self.wfile.write(msg)
+
+ def log_message(self, *a, **k):
+ # Quiet — Harbor agent's exec captures stdout/stderr.
+ pass
+
+
+if __name__ == "__main__":
+ print(f"[kernel_server] starting on 127.0.0.1:{PORT}", flush=True)
+ HTTPServer(("127.0.0.1", PORT), Handler).serve_forever()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/jupyter/run_cell.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/jupyter/run_cell.py
new file mode 100644
index 0000000000000000000000000000000000000000..3bde9becafa8a8abf38f53a0b18ad5aa42967640
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/jupyter/run_cell.py
@@ -0,0 +1,61 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""CLI client for the kernel_server, invoked by the Harbor agent via env.exec.
+
+Usage (inside the container):
+ python3 /opt/run_cell.py --code-b64
+
+Writes the kernel server's response payload (already JSON-encoded) to stdout.
+The agent base64-decodes it on the host side. Base64 sidesteps shell escaping
+for code containing quotes, newlines, etc.
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import sys
+import urllib.request
+
+
+PORT = 8765
+
+
+def main() -> int:
+ p = argparse.ArgumentParser()
+ p.add_argument("--code-b64", required=True)
+ p.add_argument("--timeout", type=int, default=120)
+ args = p.parse_args()
+
+ code = base64.b64decode(args.code_b64).decode("utf-8")
+ payload = json.dumps({"code": code}).encode()
+ req = urllib.request.Request(
+ f"http://127.0.0.1:{PORT}",
+ data=payload,
+ method="POST",
+ headers={"Content-Type": "application/json"},
+ )
+ try:
+ with urllib.request.urlopen(req, timeout=args.timeout) as r:
+ sys.stdout.write(r.read().decode("utf-8", errors="replace"))
+ return 0
+ except Exception as exc:
+ sys.stdout.write(json.dumps({"output": f"[run_cell err] {exc}", "ok": False}))
+ return 1
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/terminal_notes/README.md b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/terminal_notes/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..1fd617761b6497663fe9d362c38aef178c25d711
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/terminal_notes/README.md
@@ -0,0 +1,40 @@
+# `terminal_notes` harness
+
+A richer shell harness: **6 shell tools** (including background processes) plus a **4-tool persistent
+note toolkit**. Implemented by `TerminalNotesEnv` in [`env.py`](env.py).
+
+## Tools
+
+### Shell (backed by the sandbox)
+
+| Tool | Signature | What it does |
+|---|---|---|
+| `shell_exec` | `shell_exec(command: str, blocking: bool = True) -> str` | Run a command. Blocking → combined stdout+stderr; non-blocking → detach and return a PID. |
+| `shell_write_content_to_file` | `shell_write_content_to_file(path: str, content: str) -> str` | Write `content` to `path` (used to commit `/workdir/answer.txt`). |
+| `shell_write_to_process` | `shell_write_to_process(pid: str, content: str) -> str` | Write to a background process's stdin. |
+| `shell_view` | `shell_view(pid: str) -> str` | Read the captured stdout of a background process. |
+| `shell_wait` | `shell_wait(pid: str) -> str` | Wait (≤5 min) for a background process to exit, then return its output. |
+| `shell_kill_process` | `shell_kill_process(pid: str) -> str` | SIGKILL a background process. |
+
+### Notes (in-env state, persist across turns of a rollout)
+
+| Tool | Signature | What it does |
+|---|---|---|
+| `create_note` | `create_note(title: str, content: str) -> str` | Create a note. |
+| `append_note` | `append_note(title: str, content: str) -> str` | Append to an existing note. |
+| `read_note` | `read_note(title: str) -> str` | Read a note's content. |
+| `list_note` | `list_note() -> str` | List note titles + sizes. |
+
+> Unlike the original SETA agent, notes are **not** auto-injected into the prompt each turn (TRL owns the
+> prompt under `environment_factory`); recall them on demand with `read_note` / `list_note`.
+
+## Submission
+
+Write the answer to `/workdir/answer.txt`, e.g. `shell_write_content_to_file(path="/workdir/answer.txt", content="")`.
+
+## Use it
+
+```python
+from trl.experimental.harbor import HarborSpec
+spec = HarborSpec(dataset, agent="examples/scripts/harbor/harnesses/terminal_notes/env.py:TerminalNotesEnv")
+```
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/terminal_notes/__init__.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/terminal_notes/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac5892313971d4737052d1e38957cf8651e2ba2b
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/terminal_notes/__init__.py
@@ -0,0 +1,18 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .env import TerminalNotesEnv
+
+
+__all__ = ["TerminalNotesEnv"]
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/terminal_notes/env.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/terminal_notes/env.py
new file mode 100644
index 0000000000000000000000000000000000000000..f1180470adf5d8ec77f1db1bcd8e959d6b2583ac
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/harbor/harnesses/terminal_notes/env.py
@@ -0,0 +1,221 @@
+# 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.
+
+"""Shell + notes base agent — a 10-tool Harbor harness (6 shell + 4 notes).
+
+A custom [`~trl.experimental.harbor.HarborEnv`] subclass with a richer toolset than the bash harness:
+six shell tools (including background processes) and a persistent note-taking toolkit. Point a trainer
+at it with ``HarborSpec(dataset, agent="examples/scripts/harbor/harnesses/terminal_notes/env.py:TerminalNotesEnv")``.
+Submission is by writing ``/workdir/answer.txt`` (same verifier as the bash harness).
+
+Notes live in-env (a dict) and survive across turns of the same rollout. They're recalled on demand via
+``read_note`` / ``list_note`` (TRL owns the prompt under ``environment_factory``, so the env can't
+inject them automatically each turn).
+"""
+
+import base64
+import shlex
+import uuid
+
+from trl.experimental.harbor import HarborEnv
+
+
+_PROMPT_SUFFIX = (
+ "\n\nYou are an autonomous data-analysis agent in a sandboxed Linux container (Python preinstalled). "
+ "Dataset files are in /home/user/input/. You have shell tools (shell_exec, "
+ "shell_write_content_to_file, shell_view/wait/kill for background procs) and a persistent note system "
+ "(create_note, append_note, read_note, list_note) — use notes as a scratchpad and read them back. "
+ "**Submit your final answer by writing it to /workdir/answer.txt via a shell tool** (e.g. "
+ "shell_write_content_to_file(path='/workdir/answer.txt', content=)). Keep it short; do not "
+ "end your turn without submitting."
+)
+
+
+class TerminalNotesEnv(HarborEnv):
+ """10-tool harness (6 shell + 4 notes) over a Harbor sandbox."""
+
+ PROMPT_SUFFIX = _PROMPT_SUFFIX
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self._notes: dict[str, str] = {}
+ self._bg: dict[str, dict] = {}
+
+ def reset(self, task_dir=None, **kwargs) -> str:
+ self._notes.clear()
+ self._bg.clear()
+ return super().reset(task_dir=task_dir, **kwargs)
+
+ # ── shell toolkit ───────────────────────────────────────────────────────
+
+ def shell_exec(self, command: str, blocking: bool = True) -> str:
+ """
+ Execute a shell command in the sandbox. If `blocking` (default), run synchronously and return
+ combined stdout+stderr; otherwise detach into the background and return the new PID.
+
+ Args:
+ command: The shell command to run.
+ blocking: Run synchronously (True) or in the background (False).
+
+ Returns:
+ Combined stdout+stderr (blocking) or the background PID.
+ """
+ if blocking:
+ return self._exec(command)
+ token = uuid.uuid4().hex[:8]
+ log, pipe = f"/tmp/sh_{token}.log", f"/tmp/sh_{token}.in"
+ out = self._exec(
+ f"mkfifo {pipe} 2>/dev/null; ( nohup setsid bash -c {shlex.quote(command)} <{pipe} >{log} 2>&1 ) & echo $!",
+ timeout=15,
+ )
+ pid = out.strip().split()[-1] if out.strip() else ""
+ if not pid.isdigit():
+ return f"[shell_exec bg] failed to spawn: {out}"
+ self._bg[pid] = {"log": log, "pipe": pipe}
+ return f"Started background process PID={pid} log={log}"
+
+ def shell_write_content_to_file(self, path: str, content: str) -> str:
+ """
+ Write `content` to `path` in the sandbox (overwrites). Use to commit the final answer to
+ /workdir/answer.txt.
+
+ Args:
+ path: Destination path in the sandbox.
+ content: File contents.
+
+ Returns:
+ A confirmation string.
+ """
+ b64 = base64.b64encode(content.encode()).decode()
+ out = self._exec(
+ f"mkdir -p $(dirname {shlex.quote(path)}) && echo {b64} | base64 -d > {shlex.quote(path)}", timeout=30
+ )
+ return f"Wrote {len(content)} bytes to {path}" if "rc=" not in out else f"[write_file] {out}"
+
+ def shell_write_to_process(self, pid: str, content: str) -> str:
+ """
+ Send `content` (with a trailing newline) to the stdin of a background process.
+
+ Args:
+ pid: PID returned by shell_exec(blocking=False).
+ content: Text to write to stdin.
+
+ Returns:
+ A confirmation string.
+ """
+ proc = self._bg.get(pid)
+ if proc is None:
+ return f"Unknown PID={pid}. Started: {list(self._bg)}"
+ b64 = base64.b64encode((content + "\n").encode()).decode()
+ self._exec(f"echo {b64} | base64 -d > {shlex.quote(proc['pipe'])}", timeout=30)
+ return f"Wrote {len(content)} bytes to PID={pid} stdin"
+
+ def shell_view(self, pid: str) -> str:
+ """
+ Return the current captured stdout of a background process.
+
+ Args:
+ pid: PID returned by shell_exec(blocking=False).
+
+ Returns:
+ The captured stdout so far.
+ """
+ proc = self._bg.get(pid)
+ return self._exec(f"tail -c 4000 {shlex.quote(proc['log'])} 2>/dev/null") if proc else f"Unknown PID={pid}"
+
+ def shell_wait(self, pid: str) -> str:
+ """
+ Wait (up to ~5 min) for a background process to terminate, then return its captured stdout.
+
+ Args:
+ pid: PID returned by shell_exec(blocking=False).
+
+ Returns:
+ The process output after it exits.
+ """
+ proc = self._bg.get(pid)
+ if proc is None:
+ return f"Unknown PID={pid}"
+ return self._exec(
+ f"for i in $(seq 1 300); do [ ! -d /proc/{pid} ] && break; sleep 1; done; "
+ f"echo '--- exited ---'; tail -c 4000 {shlex.quote(proc['log'])} 2>/dev/null",
+ timeout=320,
+ )
+
+ def shell_kill_process(self, pid: str) -> str:
+ """
+ Send SIGKILL to a background process.
+
+ Args:
+ pid: PID returned by shell_exec(blocking=False).
+
+ Returns:
+ A confirmation string.
+ """
+ if pid not in self._bg:
+ return f"Unknown PID={pid}"
+ return f"Sent SIGKILL to PID={pid}: {self._exec(f'kill -9 {pid} 2>&1', timeout=10)}"
+
+ # ── note toolkit (in-env state) ──────────────────────────────────────────
+
+ def create_note(self, title: str, content: str) -> str:
+ """
+ Create a persistent note (recall it later with read_note/list_note).
+
+ Args:
+ title: Note title.
+ content: Note body.
+
+ Returns:
+ A confirmation string.
+ """
+ self._notes[title] = content
+ return f"Note '{title}' created ({len(content)} chars). Total: {len(self._notes)}."
+
+ def append_note(self, title: str, content: str) -> str:
+ """
+ Append `content` (on a new line) to an existing note.
+
+ Args:
+ title: Note title.
+ content: Text to append.
+
+ Returns:
+ A confirmation string.
+ """
+ if title not in self._notes:
+ return f"Note '{title}' not found. Use create_note first."
+ self._notes[title] += "\n" + content
+ return f"Note '{title}' updated -> {len(self._notes[title])} chars."
+
+ def read_note(self, title: str) -> str:
+ """
+ Return the full content of a note.
+
+ Args:
+ title: Note title.
+
+ Returns:
+ The note content, or a not-found message.
+ """
+ return self._notes.get(title, f"Note '{title}' not found.")
+
+ def list_note(self) -> str:
+ """
+ List all note titles with their character counts.
+
+ Returns:
+ One line per note, or a message if there are none.
+ """
+ return "\n".join(f"- {t} ({len(c)} chars)" for t, c in self._notes.items()) or "(no notes yet)"
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/kto.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/kto.py
new file mode 100644
index 0000000000000000000000000000000000000000..e01c9135e4adc903c18e9d83862bcecf4df7ad3d
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/kto.py
@@ -0,0 +1,99 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Run the KTO training script with the commands below. In general, the optimal configuration for KTO will be similar to that of DPO.
+
+# Full training:
+python trl/scripts/kto.py \
+ --dataset_name trl-lib/kto-mix-14k \
+ --model_name_or_path trl-lib/qwen1.5-1.8b-sft \
+ --per_device_train_batch_size 16 \
+ --num_train_epochs 1 \
+ --learning_rate 5e-7 \
+ --lr_scheduler_type cosine \
+ --gradient_accumulation_steps 1 \
+ --eval_steps 500 \
+ --output_dir kto-aligned-model \
+ --warmup_steps 0.1 \
+ --logging_first_step
+
+# QLoRA:
+python trl/scripts/kto.py \
+ --dataset_name trl-lib/kto-mix-14k \
+ --model_name_or_path trl-lib/qwen1.5-1.8b-sft \
+ --per_device_train_batch_size 8 \
+ --num_train_epochs 1 \
+ --learning_rate 5e-7 \
+ --lr_scheduler_type cosine \
+ --gradient_accumulation_steps 1 \
+ --eval_steps 500 \
+ --output_dir kto-aligned-model-lora \
+ --warmup_steps 0.1 \
+ --logging_first_step \
+ --use_peft \
+ --load_in_4bit \
+ --lora_target_modules all-linear \
+ --lora_r 16 \
+ --lora_alpha 16
+"""
+
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser
+
+from trl import ModelConfig, ScriptArguments, get_peft_config
+from trl.experimental.kto import KTOConfig, KTOTrainer
+
+
+if __name__ == "__main__":
+ parser = HfArgumentParser((ScriptArguments, KTOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_into_dataclasses()
+
+ # Load a pretrained model
+ model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path)
+ ref_model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path)
+
+ tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path)
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+
+ # Load the dataset
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+ # Initialize the KTO trainer
+ trainer = KTOTrainer(
+ model,
+ ref_model,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ processing_class=tokenizer,
+ peft_config=get_peft_config(model_args),
+ )
+
+ # Train and push the model to the Hub
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/mpo_vlm.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/mpo_vlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..277817353253961b73c549d2e4f12c31d211d63d
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/mpo_vlm.py
@@ -0,0 +1,126 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "Pillow",
+# "torchvision",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+python examples/scripts/mpo_vlm.py \
+ --dataset_name HuggingFaceH4/rlaif-v_formatted \
+ --model_name_or_path Qwen/Qwen2.5-VL-3B-Instruct \
+ --per_device_train_batch_size 4 \
+ --per_device_eval_batch_size 4 \
+ --num_train_epochs 1 \
+ --gradient_accumulation_steps 8 \
+ --dataset_num_proc 1 \
+ --output_dir dpo_idefics_rlaif-v \
+ --dtype bfloat16 \
+ --use_peft \
+ --lora_target_modules down_proj, o_proj, k_proj, q_proj, gate_proj, up_proj, v_proj \
+ --loss_type sigmoid bco_pair sft \
+ --loss_weights 0.8 0.2 1.0
+"""
+
+import torch
+from datasets import load_dataset
+from PIL import Image
+from transformers import AutoModelForImageTextToText
+
+from trl import (
+ DPOConfig,
+ DPOTrainer,
+ ModelConfig,
+ ScriptArguments,
+ TrlParser,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+)
+
+
+if __name__ == "__main__":
+ parser = TrlParser((ScriptArguments, DPOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+
+ ################
+ # Model & Processor
+ ################
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ model_kwargs["device_map"] = get_kbit_device_map()
+ model_kwargs["quantization_config"] = quantization_config
+
+ model = AutoModelForImageTextToText.from_pretrained(
+ model_args.model_name_or_path,
+ **model_kwargs,
+ )
+ peft_config = get_peft_config(model_args)
+
+ ################
+ # Dataset
+ ################
+ dataset = load_dataset(
+ script_args.dataset_name,
+ name=script_args.dataset_config,
+ streaming=script_args.dataset_streaming,
+ )
+ train_dataset = dataset[script_args.dataset_train_split]
+ test_dataset = dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None
+
+ def ensure_rgb(example):
+ # Convert the image to RGB if it's not already
+ image = example["images"][0]
+ if isinstance(image, Image.Image):
+ if image.mode != "RGB":
+ image = image.convert("RGB")
+ example["images"] = [image]
+ return example
+
+ # Apply the transformation to the dataset (change num_proc depending on the available compute)
+ train_dataset = train_dataset.map(ensure_rgb, num_proc=training_args.dataset_num_proc)
+ if test_dataset is not None:
+ test_dataset = test_dataset.map(ensure_rgb, num_proc=training_args.dataset_num_proc)
+
+ ################
+ # Training
+ ################
+ trainer = DPOTrainer(
+ model=model,
+ args=training_args,
+ train_dataset=train_dataset,
+ eval_dataset=test_dataset,
+ peft_config=peft_config,
+ )
+
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/nash_md.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/nash_md.py
new file mode 100644
index 0000000000000000000000000000000000000000..09dcdfac653f870811e76b12471ef77317e6152a
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/nash_md.py
@@ -0,0 +1,130 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Usage:
+
+python examples/scripts/nash_md.py \
+ --model_name_or_path trl-lib/pythia-1b-deduped-tldr-sft \
+ --reward_model_path trl-lib/pythia-1b-deduped-tldr-rm \
+ --dataset_name trl-lib/tldr \
+ --learning_rate 5.0e-7 \
+ --output_dir pythia-1b-tldr-nash-md \
+ --per_device_train_batch_size 4 \
+ --gradient_accumulation_steps 32 \
+ --num_train_epochs 3 \
+ --max_new_tokens 64 \
+ --warmup_steps 0.1 \
+ --missing_eos_penalty 1.0 \
+ --push_to_hub
+
+
+accelerate launch --config_file examples/accelerate_configs/deepspeed_zero2.yaml \
+ examples/scripts/nash_md.py \
+ --model_name_or_path trl-lib/pythia-1b-deduped-tldr-sft \
+ --reward_model_path trl-lib/pythia-1b-deduped-tldr-rm \
+ --dataset_name trl-lib/tldr \
+ --learning_rate 5.0e-7 \
+ --output_dir pythia-1b-tldr-nash-md \
+ --per_device_train_batch_size 4 \
+ --gradient_accumulation_steps 32 \
+ --num_train_epochs 3 \
+ --max_new_tokens 64 \
+ --warmup_steps 0.1 \
+ --missing_eos_penalty 1.0 \
+ --push_to_hub
+"""
+
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification, AutoTokenizer, GenerationConfig
+
+from trl import (
+ LogCompletionsCallback,
+ ModelConfig,
+ ScriptArguments,
+ TrlParser,
+ get_kbit_device_map,
+ get_quantization_config,
+)
+from trl.experimental.nash_md import NashMDConfig, NashMDTrainer
+
+
+if __name__ == "__main__":
+ parser = TrlParser((ScriptArguments, NashMDConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+ training_args.gradient_checkpointing_kwargs = {"use_reentrant": True}
+
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ use_cache=False if training_args.gradient_checkpointing else True,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ model_kwargs["device_map"] = get_kbit_device_map()
+ model_kwargs["quantization_config"] = quantization_config
+
+ model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path, **model_kwargs)
+ ref_model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path, **model_kwargs)
+
+ if training_args.reward_model_path is not None:
+ reward_model = AutoModelForSequenceClassification.from_pretrained(
+ training_args.reward_model_path,
+ num_labels=1,
+ **model_kwargs,
+ )
+ else:
+ reward_model = None
+
+ tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path, padding_side="left")
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+ trainer = NashMDTrainer(
+ model=model,
+ ref_model=ref_model,
+ reward_funcs=reward_model,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ processing_class=tokenizer,
+ )
+
+ if training_args.eval_strategy != "no":
+ generation_config = GenerationConfig(
+ max_new_tokens=training_args.max_new_tokens, do_sample=True, temperature=training_args.temperature
+ )
+ completions_callback = LogCompletionsCallback(trainer, generation_config, num_prompts=8)
+ trainer.add_callback(completions_callback)
+
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/online_dpo.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/online_dpo.py
new file mode 100644
index 0000000000000000000000000000000000000000..c04d2b09612890ec862c0a223eb55269cd21043e
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/online_dpo.py
@@ -0,0 +1,137 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Usage:
+
+python examples/scripts/online_dpo.py \
+ --model_name_or_path trl-lib/pythia-1b-deduped-tldr-sft \
+ --reward_model_path trl-lib/pythia-1b-deduped-tldr-rm \
+ --dataset_name trl-lib/tldr \
+ --learning_rate 5.0e-7 \
+ --output_dir pythia-1b-tldr-online-dpo \
+ --per_device_train_batch_size 8 \
+ --gradient_accumulation_steps 16 \
+ --warmup_steps 0.1 \
+ --missing_eos_penalty 1.0
+
+With LoRA:
+python examples/scripts/online_dpo.py \
+ --model_name_or_path trl-lib/pythia-1b-deduped-tldr-sft \
+ --reward_model_path trl-lib/pythia-1b-deduped-tldr-rm \
+ --dataset_name trl-lib/tldr \
+ --learning_rate 5.0e-6 \
+ --output_dir pythia-1b-tldr-online-dpo \
+ --per_device_train_batch_size 16 \
+ --gradient_accumulation_steps 8 \
+ --warmup_steps 0.1 \
+ --missing_eos_penalty 1.0 \
+ --use_peft
+"""
+
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification, AutoTokenizer, GenerationConfig
+
+from trl import (
+ LogCompletionsCallback,
+ ModelConfig,
+ ScriptArguments,
+ TrlParser,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+)
+from trl.experimental.online_dpo import OnlineDPOConfig, OnlineDPOTrainer
+
+
+if __name__ == "__main__":
+ parser = TrlParser((ScriptArguments, OnlineDPOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+ training_args.gradient_checkpointing_kwargs = {"use_reentrant": True}
+
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ use_cache=False if training_args.gradient_checkpointing else True,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ model_kwargs["device_map"] = get_kbit_device_map()
+ model_kwargs["quantization_config"] = quantization_config
+
+ model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path, **model_kwargs)
+
+ if training_args.reward_model_path is not None:
+ reward_model = AutoModelForSequenceClassification.from_pretrained(
+ training_args.reward_model_path,
+ num_labels=1,
+ **model_kwargs,
+ )
+ reward_tokenizer = AutoTokenizer.from_pretrained(
+ training_args.reward_model_path,
+ truncation=True,
+ truncation_side="left", # since we judge the completion, truncating left is more appropriate
+ )
+ if reward_tokenizer.pad_token_id is None:
+ reward_tokenizer.pad_token = reward_tokenizer.eos_token
+ else:
+ reward_model = None
+ reward_tokenizer = None
+
+ tokenizer = AutoTokenizer.from_pretrained(
+ model_args.model_name_or_path,
+ padding_side="left",
+ **model_kwargs,
+ )
+ if tokenizer.pad_token_id is None:
+ tokenizer.pad_token = tokenizer.eos_token
+
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+ trainer = OnlineDPOTrainer(
+ model=model,
+ reward_funcs=reward_model,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ processing_class=tokenizer,
+ reward_processing_classes=reward_tokenizer,
+ peft_config=get_peft_config(model_args),
+ )
+
+ if training_args.eval_strategy != "no":
+ generation_config = GenerationConfig(
+ max_new_tokens=training_args.max_new_tokens, do_sample=True, temperature=training_args.temperature
+ )
+ completions_callback = LogCompletionsCallback(trainer, generation_config, num_prompts=8)
+ trainer.add_callback(completions_callback)
+
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/online_dpo_vlm.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/online_dpo_vlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..5b848cc06cf94a39c01b71badd07c103ba12d63d
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/online_dpo_vlm.py
@@ -0,0 +1,203 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "math-verify",
+# "latex2sympy2_extended",
+# "trackio",
+# "torchvision",
+# "kernels",
+# ]
+# ///
+
+"""
+pip install math_verify
+
+# For Qwen/Qwen2.5-VL-3B-Instruct
+accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+ examples/scripts/online_dpo_vlm.py \
+ --model_name_or_path Qwen/Qwen2.5-VL-3B-Instruct \
+ --reward_model_path Qwen/Qwen2.5-VL-3B-Instruct \
+ --output_dir online-dpo-Qwen2.5-VL-3B-Instruct \
+ --learning_rate 1e-5 \
+ --dtype bfloat16 \
+ --max_length 1536 \
+ --max_new_tokens 1024 \
+ --use_vllm \
+ --vllm_mode server \
+ --use_peft \
+ --lora_target_modules "q_proj", "v_proj" \
+ --per_device_train_batch_size 1 \
+ --gradient_accumulation_steps 2
+
+# For HuggingFaceTB/SmolVLM2-2.2B-Instruct
+pip install num2words==0.5.14
+
+accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+ examples/scripts/online_dpo_vlm.py \
+ --model_name_or_path HuggingFaceTB/SmolVLM2-2.2B-Instruct \
+ --reward_model_path HuggingFaceTB/SmolVLM2-2.2B-Instruct \
+ --output_dir online-dpo-SmolVLM2-2.2B-Instruct \
+ --learning_rate 1e-5 \
+ --dtype bfloat16 \
+ --max_length 1536 \
+ --max_new_tokens 1024 \
+ --use_peft \
+ --lora_target_modules "q_proj", "v_proj" \
+ --per_device_train_batch_size 1 \
+ --gradient_accumulation_steps 2
+
+# Single GPU test command:
+python examples/scripts/online_dpo_vlm.py \
+ --model_name_or_path HuggingFaceTB/SmolVLM2-2.2B-Instruct \
+ --reward_model_path HuggingFaceTB/SmolVLM2-2.2B-Instruct \
+ --output_dir online-dpo-SmolVLM2-2.2B-Instruct-test \
+ --learning_rate 1e-5 \
+ --dtype bfloat16 \
+ --max_length 1536 \
+ --max_new_tokens 128 \
+ --use_peft \
+ --lora_target_modules "q_proj", "v_proj" \
+ --per_device_train_batch_size 1 \
+ --gradient_accumulation_steps 1 \
+ --max_steps 2 \
+ --logging_steps 1 \
+ --trust_remote_code
+"""
+
+import torch
+import transformers
+from datasets import load_dataset
+from transformers import AutoConfig, AutoProcessor, GenerationConfig
+
+from trl import (
+ LogCompletionsCallback,
+ ModelConfig,
+ ScriptArguments,
+ TrlParser,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+)
+from trl.experimental.online_dpo import OnlineDPOConfig, OnlineDPOTrainer
+from trl.rewards import accuracy_reward, think_format_reward
+
+
+if __name__ == "__main__":
+ parser = TrlParser((ScriptArguments, OnlineDPOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+ training_args.gradient_checkpointing_kwargs = {"use_reentrant": True}
+
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ use_cache=False if training_args.gradient_checkpointing else True,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ model_kwargs["device_map"] = get_kbit_device_map()
+ model_kwargs["quantization_config"] = quantization_config
+
+ # Load the VLM model using correct architecture (from GRPO pattern)
+ config = AutoConfig.from_pretrained(model_args.model_name_or_path)
+ architecture = getattr(transformers, config.architectures[0])
+ model = architecture.from_pretrained(model_args.model_name_or_path, **model_kwargs)
+
+ # For VLM online DPO, using a reward model is complex because it needs images
+ reward_model = None
+ reward_processor = None
+
+ # Load processor for main model
+ processor = AutoProcessor.from_pretrained(model_args.model_name_or_path)
+ if hasattr(processor, "tokenizer"):
+ processor.tokenizer.padding_side = "left"
+ if processor.tokenizer.pad_token_id is None:
+ processor.tokenizer.pad_token = processor.tokenizer.eos_token
+
+ ################
+ # Dataset
+ ################
+ dataset = load_dataset("lmms-lab/multimodal-open-r1-8k-verified", split="train")
+ dataset = dataset.train_test_split(test_size=100, seed=42)
+
+ SYSTEM_PROMPT = (
+ "A conversation between user and assistant. The user asks a question, and the assistant solves it. The "
+ "assistant first thinks about the reasoning process in the mind and then provides the user with the answer. "
+ "The reasoning process and answer are enclosed within tags, i.e., \nThis is my "
+ "reasoning.\n\nThis is my answer."
+ )
+
+ def make_conversation(example):
+ # Create conversational format that OnlineDPOTrainer expects
+ prompt = [
+ {"role": "system", "content": SYSTEM_PROMPT},
+ {"role": "user", "content": example["problem"]},
+ ]
+ return {"prompt": prompt, "image": example["image"]}
+
+ dataset = dataset.map(make_conversation)
+
+ # Filter big images (from GRPO pattern)
+ def filter_big_images(example):
+ image = example["image"]
+ return image.size[0] < 512 and image.size[1] < 512
+
+ dataset = dataset.filter(filter_big_images)
+
+ def convert_to_rgb(example):
+ image = example["image"]
+ if image.mode != "RGB":
+ image = image.convert("RGB")
+ example["image"] = image
+ return example
+
+ dataset = dataset.map(convert_to_rgb)
+
+ train_dataset = dataset["train"]
+ eval_dataset = dataset["test"] if training_args.eval_strategy != "no" else None
+
+ ################
+ # Training
+ ################
+ trainer = OnlineDPOTrainer(
+ model=model,
+ reward_funcs=[think_format_reward, accuracy_reward], # Use same reward functions as GRPO VLM
+ args=training_args,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=processor,
+ peft_config=get_peft_config(model_args),
+ )
+
+ # Add completion logging callback (from online DPO pattern)
+ if training_args.eval_strategy != "no":
+ generation_config = GenerationConfig(
+ max_new_tokens=training_args.max_new_tokens, do_sample=True, temperature=training_args.temperature
+ )
+ completions_callback = LogCompletionsCallback(trainer, generation_config, num_prompts=8)
+ trainer.add_callback(completions_callback)
+
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name="lmms-lab/multimodal-open-r1-8k-verified")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/browsergym.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/browsergym.py
new file mode 100644
index 0000000000000000000000000000000000000000..762510651151fef03fe9f7478227159304d52c72
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/browsergym.py
@@ -0,0 +1,291 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[vllm,peft]",
+# "trackio",
+# "kernels",
+# "openenv-browsergym-env @ git+https://huggingface.co/spaces/openenv/browsergym_env",
+# ]
+# ///
+
+"""
+GRPO training with OpenEnv's BrowserGym environment for VLMs (Vision Language Models).
+
+This script uses `environment_factory` with multimodal tool responses: each tool action
+returns a screenshot (PIL Image) alongside the accessibility tree text, allowing the VLM
+to see the page visually after each action.
+
+Setup:
+```sh
+pip install "openenv-browsergym-env @ git+https://huggingface.co/spaces/openenv/browsergym_env"
+```
+
+Usage:
+```sh
+# Without vLLM (default, 1 GPU)
+python examples/scripts/openenv/browsergym.py
+
+# With vLLM colocate (1 GPU, requires vLLM support for the model)
+python examples/scripts/openenv/browsergym.py --use-vllm
+
+# With vLLM server (2 GPUs)
+CUDA_VISIBLE_DEVICES=0 trl vllm-serve --model Qwen/Qwen3.5-2B --host 0.0.0.0 --port 8000
+CUDA_VISIBLE_DEVICES=1 python examples/scripts/openenv/browsergym.py --use-vllm --vllm-mode server
+```
+"""
+
+from __future__ import annotations
+
+import argparse
+from datetime import datetime
+from pathlib import Path
+
+import numpy as np
+from browsergym_env import BrowserGymAction, BrowserGymEnv
+from datasets import Dataset
+from PIL import Image
+
+from trl import GRPOConfig, GRPOTrainer
+
+
+def parse_args() -> argparse.Namespace:
+ parser = argparse.ArgumentParser(description="GRPO training with BrowserGym VLM environment.")
+ parser.add_argument("--model-id", default="Qwen/Qwen3.5-2B")
+ parser.add_argument("--space-url", default="https://openenv-browsergym-env.hf.space")
+ parser.add_argument("--task-name", default="click-test", help="BrowserGym task name to pass to reset().")
+ parser.add_argument("--dataset-prompt", default="Complete the web task successfully.")
+ parser.add_argument("--dataset-size", type=int, default=1000)
+ parser.add_argument("--max-steps", type=int, default=10)
+ parser.add_argument("--max-completion-length", type=int, default=1024)
+ parser.add_argument("--image-size", type=int, default=512, help="Resize screenshots to this size. 0 to disable.")
+ parser.add_argument("--num-generations", type=int, default=4)
+ parser.add_argument("--gradient-accumulation-steps", type=int, default=32)
+ parser.add_argument("--learning-rate", type=float, default=5e-6)
+ parser.add_argument("--num-epochs", type=int, default=1)
+ parser.add_argument("--logging-steps", type=int, default=1)
+ parser.add_argument("--output-dir", default=None)
+ parser.add_argument("--use-vllm", action="store_true", default=False, help="Enable vLLM for generation.")
+ parser.add_argument("--vllm-mode", choices=("colocate", "server"), default="colocate")
+ parser.add_argument("--vllm-server-url", default="http://localhost:8000")
+ return parser.parse_args()
+
+
+def sanitize_name(name: str) -> str:
+ return name.replace("/", "-")
+
+
+SYSTEM_PROMPT = """You control a web browser to complete tasks.
+
+The page structure shows elements as: [bid] element_type 'element_text'
+For example: [13] button 'Click Me!' means the element has bid='13'.
+
+You will see a screenshot of the page after each action. Use the visual information
+along with the page structure to decide your next action.
+
+Use the available tools to interact with the page:
+- click: Click an element by its bid
+- fill: Fill an input field with text
+- send_keys: Send keyboard input
+- scroll: Scroll the page
+- noop: Do nothing
+
+Complete the given task as efficiently as possible."""
+
+
+def reward_completion(completions, environments, **kwargs) -> list[float]:
+ return [env.reward for env in environments]
+
+
+def main() -> None:
+ args = parse_args()
+
+ space_url = args.space_url
+ max_steps = args.max_steps
+ image_size = args.image_size
+
+ dataset = Dataset.from_dict(
+ {
+ "prompt": [
+ [
+ {"role": "system", "content": SYSTEM_PROMPT},
+ {"role": "user", "content": args.dataset_prompt},
+ ]
+ ]
+ * args.dataset_size
+ }
+ )
+
+ class BrowserGymVLMEnv:
+ def __init__(self):
+ self.client = BrowserGymEnv(base_url=space_url)
+ self.reward = 0.0
+ self.done = False
+ self._step_count = 0
+
+ def reset(self, **kwargs) -> str | None:
+ self.reward = 0.0
+ self.done = False
+ self._step_count = 0
+ result = self.client.reset(task_name=args.task_name)
+ self.done = result.done
+ return self._format_observation(result.observation)
+
+ def click(self, bid: str) -> list:
+ """Click an element on the page.
+
+ Args:
+ bid: The BrowserGym ID of the element to click.
+
+ Returns:
+ The updated page observation with screenshot.
+ """
+ return self._do_action(f"click('{bid}')")
+
+ def fill(self, bid: str, text: str) -> list:
+ """Fill an input field with text.
+
+ Args:
+ bid: The BrowserGym ID of the input field.
+ text: The text to type into the field.
+
+ Returns:
+ The updated page observation with screenshot.
+ """
+ return self._do_action(f"fill('{bid}', '{text}')")
+
+ def send_keys(self, text: str) -> list:
+ """Send keyboard input to the page.
+
+ Args:
+ text: The keyboard input to send.
+
+ Returns:
+ The updated page observation with screenshot.
+ """
+ return self._do_action(f"send_keys('{text}')")
+
+ def scroll(self, direction: str) -> list:
+ """Scroll the page.
+
+ Args:
+ direction: Direction to scroll, either 'up' or 'down'.
+
+ Returns:
+ The updated page observation with screenshot.
+ """
+ return self._do_action(f"scroll('{direction}')")
+
+ def noop(self) -> list:
+ """Do nothing and observe the current page state.
+
+ Returns:
+ The current page observation with screenshot.
+ """
+ return self._do_action("noop()")
+
+ def _do_action(self, action_str: str) -> list:
+ if self.done:
+ raise ValueError("Episode is done.")
+
+ self._step_count += 1
+ result = self.client.step(BrowserGymAction(action_str=action_str))
+ observation = result.observation
+ step_reward = float(result.reward or 0.0)
+ self.done = result.done
+
+ if self.done and step_reward > 0:
+ self.reward = 1.0
+ elif self.done:
+ self.reward = 0.0
+ else:
+ self.reward = step_reward
+
+ if self._step_count >= max_steps:
+ self.done = True
+
+ return self._format_observation_multimodal(observation)
+
+ def _format_observation(self, observation) -> str:
+ """Format initial observation as text (for reset, appended to prompt)."""
+ parts = []
+ if observation.goal:
+ parts.append(f"Goal: {observation.goal}")
+ if observation.axtree_txt:
+ axtree = observation.axtree_txt
+ if len(axtree) > 2000:
+ axtree = axtree[:2000] + "..."
+ parts.append(f"Page structure:\n{axtree}")
+ return "\n\n".join(parts) if parts else "No observation available."
+
+ def _format_observation_multimodal(self, observation) -> list:
+ """Format observation as multimodal content blocks (screenshot + text)."""
+ content = []
+
+ # Add screenshot if available
+ if observation.screenshot is not None:
+ screenshot_array = np.array(observation.screenshot, dtype=np.uint8)
+ screenshot_image = Image.fromarray(screenshot_array)
+ if image_size > 0:
+ screenshot_image.thumbnail((image_size, image_size), Image.LANCZOS)
+ content.append({"type": "image", "image": screenshot_image})
+
+ # Add text observation
+ parts = []
+ if observation.goal:
+ parts.append(f"Goal: {observation.goal}")
+ if observation.last_action_error and observation.error:
+ parts.append(f"Error: {observation.error}")
+ if observation.axtree_txt:
+ axtree = observation.axtree_txt
+ if len(axtree) > 2000:
+ axtree = axtree[:2000] + "..."
+ parts.append(f"Page structure:\n{axtree}")
+ text = "\n\n".join(parts) if parts else "No observation available."
+ content.append({"type": "text", "text": text})
+
+ return content
+
+ timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+ default_output_dir = Path("outputs") / f"browsergym-vlm-grpo-{sanitize_name(args.model_id)}-{timestamp}"
+ output_dir = Path(args.output_dir or default_output_dir)
+
+ trainer = GRPOTrainer(
+ model=args.model_id,
+ reward_funcs=reward_completion,
+ train_dataset=dataset,
+ args=GRPOConfig(
+ use_vllm=args.use_vllm,
+ vllm_mode=args.vllm_mode if args.use_vllm else "colocate",
+ vllm_server_base_url=args.vllm_server_url if args.use_vllm and args.vllm_mode == "server" else None,
+ output_dir=str(output_dir),
+ num_train_epochs=args.num_epochs,
+ learning_rate=args.learning_rate,
+ gradient_accumulation_steps=args.gradient_accumulation_steps,
+ num_generations=args.num_generations,
+ max_completion_length=args.max_completion_length,
+ logging_steps=args.logging_steps,
+ log_completions=True,
+ report_to="trackio",
+ trackio_space_id=f"browsergym-vlm-grpo-{sanitize_name(args.model_id)}",
+ chat_template_kwargs={"enable_thinking": False},
+ ),
+ environment_factory=BrowserGymVLMEnv,
+ )
+ trainer.train()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/browsergym_llm.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/browsergym_llm.py
new file mode 100644
index 0000000000000000000000000000000000000000..7fcf83b1fa254d755ed98ebbba2a3c852af73a95
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/browsergym_llm.py
@@ -0,0 +1,463 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[vllm,peft]",
+# "trackio",
+# "kernels",
+# "openenv-browsergym-env @ git+https://huggingface.co/spaces/openenv/browsergym_env",
+# ]
+# ///
+
+"""
+Simple script to run GRPO training with OpenEnv's BrowserGym environment and vLLM for LLMs.
+
+This script is optimized for text-only Language Models (LLMs). It uses the accessibility
+tree text from BrowserGym, making it memory-efficient.
+
+The environment runs on a Hugging Face Space by default.
+
+Setup (Option A - Install from HF Space, recommended):
+
+```sh
+uv pip install git+https://huggingface.co/spaces/openenv/browsergym_env
+```
+
+Setup (Option B - Clone OpenEnv repo, for development):
+
+```sh
+git clone https://github.com/huggingface/OpenEnv.git
+cd OpenEnv/envs/browsergym_env
+uv pip install -e .
+```
+
+# Option 1: HF Spaces + Colocated vLLM (1 GPU required)
+```sh
+python examples/scripts/openenv/browsergym_llm.py --vllm-mode colocate
+```
+
+# Option 2: HF Spaces + Separate vLLM server (2 GPUs required)
+
+# Spin up vLLM server (Terminal 1)
+```sh
+CUDA_VISIBLE_DEVICES=0 trl vllm-serve --model Qwen/Qwen3-0.6B --host 0.0.0.0 --port 8001
+```
+
+# Run training (Terminal 2)
+```sh
+CUDA_VISIBLE_DEVICES=1 python examples/scripts/openenv/browsergym_llm.py --vllm-mode server --vllm-server-url http://localhost:8001
+```
+"""
+
+from __future__ import annotations
+
+import argparse
+from datetime import datetime
+from pathlib import Path
+
+from browsergym_env import BrowserGymAction, BrowserGymEnv
+from datasets import Dataset
+
+from trl import GRPOConfig, GRPOTrainer
+
+
+def parse_args() -> argparse.Namespace:
+ parser = argparse.ArgumentParser(description="Run GRPO training for BrowserGym MiniWoB using OpenEnv environment.")
+ parser.add_argument(
+ "--model-id",
+ default="Qwen/Qwen3-0.6B",
+ help="Model identifier passed to GRPOTrainer for fine-tuning.",
+ )
+ parser.add_argument(
+ "--space-url",
+ type=str,
+ default="https://openenv-browsergym-env.hf.space",
+ help="URL for the Hugging Face Space running the BrowserGym environment.",
+ )
+ parser.add_argument(
+ "--benchmark",
+ default="miniwob",
+ help="BrowserGym benchmark to use (miniwob, webarena, etc.).",
+ )
+ parser.add_argument(
+ "--task-name",
+ default="click-test",
+ help="Specific task within the benchmark (e.g., click-test, click-button).",
+ )
+ parser.add_argument(
+ "--dataset-prompt",
+ default="Complete the web task successfully.",
+ help="Prompt text used to seed the training dataset.",
+ )
+ parser.add_argument(
+ "--dataset-size",
+ type=int,
+ default=1000,
+ help="Number of entries to include in the synthetic training dataset.",
+ )
+ parser.add_argument(
+ "--max-steps",
+ type=int,
+ default=10,
+ help="Maximum number of steps per episode.",
+ )
+ parser.add_argument(
+ "--max-completion-length",
+ type=int,
+ default=1024,
+ help="Maximum completion length in tokens for tool-calling generation.",
+ )
+ parser.add_argument(
+ "--temperature",
+ type=float,
+ default=0.7,
+ help="Sampling temperature used during rollout generation.",
+ )
+ parser.add_argument(
+ "--top-k",
+ type=int,
+ default=50,
+ help="Top-k sampling parameter forwarded to vLLM.",
+ )
+ parser.add_argument(
+ "--top-p",
+ type=float,
+ default=None,
+ help="Optional top-p sampling parameter forwarded to vLLM.",
+ )
+ parser.add_argument(
+ "--learning-rate",
+ type=float,
+ default=5e-6,
+ help="Learning rate for GRPO training.",
+ )
+ parser.add_argument(
+ "--weight-decay",
+ type=float,
+ default=0.0,
+ help="Weight decay applied during optimization.",
+ )
+ parser.add_argument(
+ "--gradient-accumulation-steps",
+ type=int,
+ default=32,
+ help="Gradient accumulation steps for GRPO training.",
+ )
+ parser.add_argument(
+ "--warmup-steps",
+ type=int,
+ default=10,
+ help="Warmup steps for the scheduler.",
+ )
+ parser.add_argument(
+ "--per-device-batch-size",
+ type=int,
+ default=1,
+ help="Per-device train batch size.",
+ )
+ parser.add_argument(
+ "--num-generations",
+ type=int,
+ default=4,
+ help="Number of rollout generations per dataset prompt.",
+ )
+ parser.add_argument(
+ "--num-epochs",
+ type=int,
+ default=1,
+ help="Number of training epochs.",
+ )
+ parser.add_argument(
+ "--save-interval",
+ type=int,
+ default=50,
+ help="Interval (in steps) between checkpoint saves.",
+ )
+ parser.add_argument(
+ "--save-total-limit",
+ type=int,
+ default=None,
+ help="Maximum number of checkpoints to keep.",
+ )
+ parser.add_argument(
+ "--output-dir",
+ default=None,
+ help="Directory where training outputs and checkpoints are stored.",
+ )
+ parser.add_argument(
+ "--run-name",
+ default=None,
+ help="Optional run name for logging systems.",
+ )
+ parser.add_argument(
+ "--project",
+ default=None,
+ help="Optional project identifier for logging systems.",
+ )
+ parser.add_argument(
+ "--vllm-mode",
+ choices=("colocate", "server"),
+ default="colocate",
+ help="vLLM execution mode: 'colocate' or 'server'.",
+ )
+ parser.add_argument(
+ "--vllm-server-url",
+ type=str,
+ default="http://localhost:8001",
+ help="URL for the vLLM server (only used when --vllm-mode=server).",
+ )
+ parser.add_argument(
+ "--logging-steps",
+ type=int,
+ default=1,
+ help="Frequency of logging steps for GRPO training.",
+ )
+ return parser.parse_args()
+
+
+def sanitize_name(name: str) -> str:
+ return name.replace("/", "-")
+
+
+# ---------------------------------------------------------------------------
+# System Prompt
+# ---------------------------------------------------------------------------
+
+SYSTEM_PROMPT = """You control a web browser to complete tasks.
+
+The page structure shows elements as: [bid] element_type 'element_text'
+For example: [13] button 'Click Me!' means the element has bid='13'.
+
+Use the available tools to interact with the page:
+- click: Click an element by its bid
+- fill: Fill an input field with text
+- send_keys: Send keyboard input
+- scroll: Scroll the page
+- noop: Do nothing
+
+Complete the given task as efficiently as possible."""
+
+
+# ---------------------------------------------------------------------------
+# Reward
+# ---------------------------------------------------------------------------
+
+
+def reward_completion(environments, **kwargs) -> list[float]:
+ """Reward for task completion."""
+ return [env.reward for env in environments]
+
+
+# ---------------------------------------------------------------------------
+# Main entrypoint
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+ args = parse_args()
+
+ space_url = args.space_url
+ max_steps = args.max_steps
+
+ dataset = Dataset.from_dict(
+ {
+ "prompt": [
+ [
+ {"role": "system", "content": SYSTEM_PROMPT},
+ {"role": "user", "content": args.dataset_prompt},
+ ]
+ ]
+ * args.dataset_size
+ }
+ )
+
+ class BrowserGymLLMEnv:
+ def __init__(self):
+ self.client = BrowserGymEnv(base_url=space_url)
+ self.reward = 0.0
+ self._done = False
+ self._step_count = 0
+
+ def _ensure_large_max_size(self):
+ """Raise WebSocket max message size for large observations (e.g. accessibility trees).
+
+ openenv-core<=0.2.1 does not pass max_size to ws_connect, so the websockets library
+ defaults to 1MB. We force a connection and patch it to 100MB before any messages are sent.
+ """
+ self.client.connect()
+ ws = self.client._ws
+ if ws is not None and hasattr(ws, "protocol"):
+ proto = ws.protocol
+ # websockets <16: max_size; websockets >=16: max_message_size
+ attr = "max_size" if hasattr(proto, "max_size") else "max_message_size"
+ if getattr(proto, attr) == 2**20:
+ setattr(proto, attr, 100 * 1024 * 1024)
+
+ def reset(self, **kwargs) -> str:
+ self.reward = 0.0
+ self._done = False
+ self._step_count = 0
+ self._ensure_large_max_size()
+ result = self.client.reset(task_name=args.task_name)
+ self._done = result.done
+ return self._format_observation(result.observation)
+
+ def click(self, bid: str) -> str:
+ """Click an element on the page.
+
+ Args:
+ bid: The BrowserGym ID of the element to click.
+
+ Returns:
+ The updated page observation.
+ """
+ return self._do_action(f"click({bid!r})")
+
+ def fill(self, bid: str, text: str) -> str:
+ """Fill an input field with text.
+
+ Args:
+ bid: The BrowserGym ID of the input field.
+ text: The text to type into the field.
+
+ Returns:
+ The updated page observation.
+ """
+ return self._do_action(f"fill({bid!r}, {text!r})")
+
+ def send_keys(self, text: str) -> str:
+ """Send keyboard input to the page.
+
+ Args:
+ text: The keyboard input to send.
+
+ Returns:
+ The updated page observation.
+ """
+ return self._do_action(f"send_keys({text!r})")
+
+ def scroll(self, direction: str) -> str:
+ """Scroll the page.
+
+ Args:
+ direction: Direction to scroll, either 'up' or 'down'.
+
+ Returns:
+ The updated page observation.
+ """
+ return self._do_action(f"scroll({direction!r})")
+
+ def noop(self) -> str:
+ """Do nothing and observe the current page state.
+
+ Returns:
+ The current page observation.
+ """
+ return self._do_action("noop()")
+
+ def _do_action(self, action_str: str) -> str:
+ if self._done:
+ raise ValueError("Episode is done.")
+
+ self._step_count += 1
+ result = self.client.step(BrowserGymAction(action_str=action_str))
+ observation = result.observation
+ step_reward = float(result.reward or 0.0)
+ self._done = result.done
+
+ # Reward shaping: binary success/failure on completion
+ if self._done and step_reward > 0:
+ self.reward = 1.0
+ elif self._done:
+ self.reward = 0.0
+ else:
+ self.reward = step_reward
+
+ # Enforce max steps
+ if self._step_count >= max_steps:
+ self._done = True
+
+ return self._format_observation(observation)
+
+ def _format_observation(self, observation) -> str:
+ parts = []
+ if observation.goal:
+ parts.append(f"Goal: {observation.goal}")
+ if observation.last_action_error and observation.error:
+ parts.append(f"Error: {observation.error}")
+ if observation.axtree_txt:
+ axtree = observation.axtree_txt
+ if len(axtree) > 2000:
+ axtree = axtree[:2000] + "..."
+ parts.append(f"Page structure:\n{axtree}")
+ return "\n\n".join(parts) if parts else "No observation available."
+
+ timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+ default_output_dir = Path("outputs") / f"browsergym-grpo-{sanitize_name(args.model_id)}-{timestamp}"
+ output_dir = Path(args.output_dir or default_output_dir)
+
+ grpo_config = GRPOConfig(
+ use_vllm=True,
+ vllm_mode=args.vllm_mode,
+ vllm_server_base_url=args.vllm_server_url if args.vllm_mode == "server" else None,
+ vllm_gpu_memory_utilization=0.4,
+ output_dir=str(output_dir),
+ num_train_epochs=args.num_epochs,
+ learning_rate=args.learning_rate,
+ weight_decay=args.weight_decay,
+ gradient_accumulation_steps=args.gradient_accumulation_steps,
+ per_device_train_batch_size=args.per_device_batch_size,
+ warmup_steps=args.warmup_steps,
+ num_generations=args.num_generations,
+ generation_batch_size=args.num_generations,
+ max_completion_length=args.max_completion_length,
+ logging_steps=args.logging_steps,
+ report_to="trackio",
+ trackio_space_id=f"browsergym-grpo-{sanitize_name(args.model_id)}-{timestamp}",
+ save_strategy="steps",
+ save_steps=args.save_interval,
+ save_total_limit=args.save_total_limit,
+ temperature=args.temperature,
+ top_k=args.top_k,
+ top_p=args.top_p,
+ chat_template_kwargs={"enable_thinking": False},
+ )
+
+ grpo_config.run_name = args.run_name or f"run-{timestamp}"
+ grpo_config.project = args.project or f"group-{sanitize_name(args.model_id)}"
+
+ trainer = GRPOTrainer(
+ model=args.model_id,
+ reward_funcs=[reward_completion],
+ train_dataset=dataset,
+ args=grpo_config,
+ environment_factory=BrowserGymLLMEnv,
+ )
+
+ print("=" * 80)
+ print("Starting GRPO training with BrowserGym environment (LLM mode)")
+ print(f"Benchmark: {args.benchmark}")
+ print(f"Task: {args.task_name}")
+ print(f"Model: {args.model_id}")
+ print("Mode: LLM (text-only, using accessibility tree)")
+ print(f"Using {args.num_generations} rollouts per dataset prompt")
+ print(f"Output directory: {output_dir}")
+ print("=" * 80)
+
+ trainer.train()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/carla.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/carla.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2903d990cc74079f3d4a6d6374f594f4d68bb12
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/carla.py
@@ -0,0 +1,219 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "openenv-carla-env @ git+https://huggingface.co/spaces/sergiopaniego/carla_env",
+# ]
+# ///
+
+
+"""
+Simple script to run GRPO training with OpenEnv's CARLA environment. The environment simulates an emergency
+driving scenario where pedestrians are ahead and the model must learn to observe the scene and take the
+correct action (e.g., swerve to an empty lane) to minimize casualties.
+
+Setup (Option A - Install from HF Space, recommended):
+
+```sh
+uv pip install git+https://huggingface.co/spaces/sergiopaniego/carla_env
+```
+
+Setup (Option B - Clone OpenEnv repo, for development):
+
+```sh
+git clone https://github.com/huggingface/OpenEnv.git
+cd OpenEnv/envs/carla_env
+uv pip install -e .
+```
+
+Usage:
+
+```sh
+python examples/scripts/openenv/carla.py
+python examples/scripts/openenv/carla.py --model Qwen/Qwen3-1.7B --env-urls https://server1.hf.space https://server2.hf.space
+```
+"""
+
+import argparse
+
+from carla_env import CarlaAction, CarlaEnv
+from datasets import Dataset
+
+from trl import GRPOConfig, GRPOTrainer
+
+
+def parse_args():
+ parser = argparse.ArgumentParser(description="Run GRPO training with CARLA environment.")
+ parser.add_argument(
+ "--model",
+ type=str,
+ default="Qwen/Qwen3-0.6B",
+ help="Model to use for training.",
+ )
+ parser.add_argument(
+ "--env-urls",
+ type=str,
+ nargs="+",
+ default=["https://sergiopaniego-carla-env.hf.space"],
+ help="URLs for the CARLA environment servers (one per environment instance).",
+ )
+ parser.add_argument(
+ "--trackio-space-id",
+ type=str,
+ default="carla-grpo-trolley",
+ help="Trackio space identifier.",
+ )
+ parser.add_argument(
+ "--hub-model-id",
+ type=str,
+ default=None,
+ help="Hub model ID to push the trained model to (e.g., sergiopaniego/Qwen3-0.6B-carla-trolley-escape).",
+ )
+ parser.add_argument(
+ "--run-name",
+ type=str,
+ default=None,
+ help="Run name for tracking.",
+ )
+ return parser.parse_args()
+
+
+PROMPT = """You control an autonomous vehicle in an emergency. There are pedestrians ahead and you must \
+decide what to do immediately.
+
+You have the following tools available:
+- `observe`: Advance time and get a new observation of the scene.
+- `emergency_stop`: Apply maximum braking to stop the vehicle.
+- `lane_change(direction)`: Change lane to the left or right. Direction must be "left" or "right".
+
+Observe the scene first, then decide the best course of action to minimize harm."""
+
+
+SIM_TICKS = 10 # Number of simulation steps to advance after each action
+
+
+class CarlaGRPOEnv:
+ _env_url_iter = None
+
+ def __init__(self):
+ url = next(CarlaGRPOEnv._env_url_iter)
+ self.client = CarlaEnv(base_url=url, connect_timeout_s=30, message_timeout_s=120)
+
+ @staticmethod
+ def _describe(obs) -> str:
+ """Build a text description from the observation fields."""
+ parts = []
+ parts.append(f"Speed: {obs.speed_kmh:.1f} km/h.")
+ if obs.nearby_actors:
+ for actor in obs.nearby_actors:
+ parts.append(f"- {actor.get('type', 'actor')} at {actor.get('distance', '?')}m")
+ else:
+ parts.append("No nearby actors detected.")
+ if obs.collision_detected:
+ parts.append(f"COLLISION detected with {obs.collided_with or 'unknown'}!")
+ return "\n".join(parts)
+
+ def _advance(self, ticks: int = SIM_TICKS):
+ """Advance the simulation by calling observe repeatedly, return the last result."""
+ result = None
+ for _ in range(ticks):
+ result = self.client.step(CarlaAction(action_type="observe"))
+ if result.done:
+ break
+ return result
+
+ def reset(self, **kwargs) -> str | None:
+ result = self.client.reset(scenario_name="trolley_micro_escape_exists")
+ self.reward = 0.0
+ return self._describe(result.observation)
+
+ def observe(self) -> str:
+ """
+ Get the current scene description without taking any action.
+
+ Returns:
+ The scene description with vehicle state and nearby actors.
+ """
+ result = self._advance()
+ self.reward = result.observation.rubric_reward or 0.0
+ return self._describe(result.observation)
+
+ def emergency_stop(self) -> str:
+ """
+ Apply maximum braking to stop the vehicle.
+
+ Returns:
+ The scene description after braking.
+ """
+ self.client.step(CarlaAction(action_type="emergency_stop"))
+ result = self._advance()
+ self.reward = result.observation.rubric_reward or 0.0
+ return self._describe(result.observation)
+
+ def lane_change(self, direction: str) -> str:
+ """
+ Change lane to avoid obstacles.
+
+ Args:
+ direction: Direction to change lane, either "left" or "right".
+
+ Returns:
+ The scene description after changing lane.
+ """
+ self.client.step(CarlaAction(action_type="lane_change", lane_direction=direction))
+ result = self._advance()
+ self.reward = result.observation.rubric_reward or 0.0
+ return self._describe(result.observation)
+
+
+def reward_func(environments, **kwargs):
+ return [environment.reward for environment in environments]
+
+
+def main():
+ args = parse_args()
+ CarlaGRPOEnv._env_url_iter = iter(args.env_urls)
+
+ dataset = Dataset.from_dict({"prompt": [[{"role": "user", "content": PROMPT}] for _ in range(1000)]})
+
+ trainer = GRPOTrainer(
+ model=args.model,
+ train_dataset=dataset,
+ reward_funcs=reward_func,
+ args=GRPOConfig(
+ chat_template_kwargs={"enable_thinking": False},
+ log_completions=True,
+ logging_steps=2,
+ num_completions_to_print=1,
+ max_completion_length=1024,
+ per_device_train_batch_size=len(args.env_urls),
+ steps_per_generation=1,
+ num_generations=len(args.env_urls),
+ gradient_accumulation_steps=16,
+ max_steps=50,
+ push_to_hub=args.hub_model_id is not None,
+ hub_model_id=args.hub_model_id,
+ run_name=args.run_name,
+ report_to="trackio",
+ trackio_space_id=args.trackio_space_id,
+ ),
+ environment_factory=CarlaGRPOEnv,
+ )
+ trainer.train()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/carla_vlm.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/carla_vlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..925c1fd11c20b6fbdd9ff7b12fffeebc8989654e
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/carla_vlm.py
@@ -0,0 +1,262 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "openenv-carla-env @ git+https://huggingface.co/spaces/sergiopaniego/carla_env",
+# ]
+# ///
+
+
+"""
+GRPO training with OpenEnv's CARLA environment for VLMs (Vision Language Models).
+
+VLM adaptation of `carla.py`: each tool call returns a camera image alongside the text
+scene description, so the model sees the driving scene after each action.
+
+Setup:
+
+```sh
+uv pip install git+https://huggingface.co/spaces/sergiopaniego/carla_env
+```
+
+Usage (requires at least 2 CARLA Spaces, each supports only 1 concurrent connection):
+
+```sh
+python examples/scripts/openenv/carla_vlm.py \
+ --model Qwen/Qwen3.5-0.8B \
+ --env-urls https://server1.hf.space https://server2.hf.space
+```
+"""
+
+import argparse
+import base64
+from io import BytesIO
+
+from carla_env import CarlaAction, CarlaEnv
+from datasets import Dataset
+from PIL import Image
+
+from trl import GRPOConfig, GRPOTrainer
+
+
+def parse_args():
+ parser = argparse.ArgumentParser(description="Run GRPO VLM training with CARLA environment.")
+ parser.add_argument(
+ "--model",
+ type=str,
+ default="Qwen/Qwen3.5-0.8B",
+ help="Model to use for training.",
+ )
+ parser.add_argument(
+ "--env-urls",
+ type=str,
+ nargs="+",
+ default=["https://sergiopaniego-carla-env.hf.space"],
+ help="URLs for the CARLA environment servers (one per environment instance).",
+ )
+ parser.add_argument(
+ "--image-size",
+ type=int,
+ default=256,
+ help="Resize camera images to this size. 0 to disable.",
+ )
+ parser.add_argument(
+ "--max-completion-length",
+ type=int,
+ default=1024,
+ help="Maximum number of tokens in the generated completion.",
+ )
+ parser.add_argument(
+ "--gradient-accumulation-steps",
+ type=int,
+ default=16,
+ help="Number of steps to accumulate gradients over before updating.",
+ )
+ parser.add_argument(
+ "--max-steps",
+ type=int,
+ default=50,
+ help="Number of training steps to run.",
+ )
+ parser.add_argument(
+ "--trackio-space-id",
+ type=str,
+ default="carla-grpo-trolley-vlm",
+ help="Trackio space identifier.",
+ )
+ parser.add_argument(
+ "--hub-model-id",
+ type=str,
+ default=None,
+ help="Hub model ID to push the trained model to.",
+ )
+ parser.add_argument(
+ "--run-name",
+ type=str,
+ default=None,
+ help="Run name for tracking.",
+ )
+ return parser.parse_args()
+
+
+PROMPT = """You control an autonomous vehicle in an emergency. There are pedestrians ahead and you must \
+decide what to do immediately.
+
+You will see a camera image from the vehicle after each action. Use the visual information
+along with the scene description to decide your next action.
+
+You have the following tools available:
+- `observe`: Advance time and get a new observation of the scene with a camera image.
+- `emergency_stop`: Apply maximum braking to stop the vehicle.
+- `lane_change(direction)`: Change lane to the left or right. Direction must be "left" or "right".
+
+Observe the scene first, then decide the best course of action to minimize harm."""
+
+
+SIM_TICKS = 10 # Number of simulation steps to advance after each action
+
+
+class CarlaGRPOEnv:
+ _env_url_iter = None
+ _image_size = 256
+
+ def __init__(self):
+ url = next(CarlaGRPOEnv._env_url_iter)
+ self.client = CarlaEnv(base_url=url, connect_timeout_s=30, message_timeout_s=120)
+
+ @staticmethod
+ def _describe(obs) -> str:
+ """Build a text description from the observation fields."""
+ parts = [f"Speed: {obs.speed_kmh:.1f} km/h."]
+ if obs.nearby_actors:
+ for actor in obs.nearby_actors:
+ parts.append(f"- {actor.get('type', 'actor')} at {actor.get('distance', '?')}m")
+ else:
+ parts.append("No nearby actors detected.")
+ if obs.collision_detected:
+ parts.append(f"COLLISION detected with {obs.collided_with or 'unknown'}!")
+ return "\n".join(parts)
+
+ @staticmethod
+ def _decode_image(camera_image_b64, target_size):
+ """Decode base64 JPEG image and optionally resize."""
+ img = Image.open(BytesIO(base64.b64decode(camera_image_b64)))
+ if target_size > 0:
+ img.thumbnail((target_size, target_size), Image.LANCZOS)
+ return img
+
+ def _format_multimodal(self, obs) -> list:
+ """Format observation as multimodal content blocks (camera image + text)."""
+ content = []
+ if obs.camera_image is not None:
+ content.append({"type": "image", "image": self._decode_image(obs.camera_image, CarlaGRPOEnv._image_size)})
+ content.append({"type": "text", "text": self._describe(obs)})
+ return content
+
+ def _advance_and_capture(self, ticks: int = SIM_TICKS):
+ """Advance the simulation, then capture an image of the current state."""
+ result = None
+ for _ in range(ticks):
+ result = self.client.step(CarlaAction(action_type="observe"))
+ if result.done:
+ break
+ capture_result = self.client.step(CarlaAction(action_type="capture_image"))
+ result.observation.camera_image = capture_result.observation.camera_image
+ return result
+
+ def reset(self, **kwargs) -> str | None:
+ result = self.client.reset(scenario_name="trolley_micro_escape_exists")
+ self.reward = 0.0
+ return self._describe(result.observation)
+
+ def observe(self) -> list:
+ """
+ Get the current scene with a camera image and description.
+
+ Returns:
+ The camera image and scene description with vehicle state and nearby actors.
+ """
+ result = self._advance_and_capture()
+ self.reward = result.observation.rubric_reward or 0.0
+ return self._format_multimodal(result.observation)
+
+ def emergency_stop(self) -> list:
+ """
+ Apply maximum braking to stop the vehicle.
+
+ Returns:
+ The camera image and scene description after braking.
+ """
+ self.client.step(CarlaAction(action_type="emergency_stop"))
+ result = self._advance_and_capture()
+ self.reward = result.observation.rubric_reward or 0.0
+ return self._format_multimodal(result.observation)
+
+ def lane_change(self, direction: str) -> list:
+ """
+ Change lane to avoid obstacles.
+
+ Args:
+ direction: Direction to change lane, either "left" or "right".
+
+ Returns:
+ The camera image and scene description after changing lane.
+ """
+ self.client.step(CarlaAction(action_type="lane_change", lane_direction=direction))
+ result = self._advance_and_capture()
+ self.reward = result.observation.rubric_reward or 0.0
+ return self._format_multimodal(result.observation)
+
+
+def reward_func(environments, **kwargs):
+ return [environment.reward for environment in environments]
+
+
+def main():
+ args = parse_args()
+ CarlaGRPOEnv._env_url_iter = iter(args.env_urls)
+ CarlaGRPOEnv._image_size = args.image_size
+
+ dataset = Dataset.from_dict({"prompt": [[{"role": "user", "content": PROMPT}] for _ in range(1000)]})
+
+ trainer = GRPOTrainer(
+ model=args.model,
+ train_dataset=dataset,
+ reward_funcs=reward_func,
+ args=GRPOConfig(
+ chat_template_kwargs={"enable_thinking": False},
+ log_completions=True,
+ logging_steps=2,
+ num_completions_to_print=1,
+ max_completion_length=args.max_completion_length,
+ per_device_train_batch_size=len(args.env_urls),
+ steps_per_generation=1,
+ num_generations=len(args.env_urls),
+ gradient_accumulation_steps=args.gradient_accumulation_steps,
+ max_steps=args.max_steps,
+ push_to_hub=args.hub_model_id is not None,
+ hub_model_id=args.hub_model_id,
+ run_name=args.run_name,
+ report_to="trackio",
+ trackio_space_id=args.trackio_space_id,
+ ),
+ environment_factory=CarlaGRPOEnv,
+ )
+ trainer.train()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/carla_vlm_gemma.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/carla_vlm_gemma.py
new file mode 100644
index 0000000000000000000000000000000000000000..b6a00ab9eb35d1f98570a89fe084ddefd3bb7c83
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/carla_vlm_gemma.py
@@ -0,0 +1,278 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "openenv-carla-env @ git+https://huggingface.co/spaces/sergiopaniego/carla_env",
+# ]
+# ///
+
+
+"""
+GRPO training with OpenEnv's CARLA environment for Gemma VLMs.
+
+Gemma-specific variant of `carla_vlm.py` with LoRA support (memory-efficient training
+by excluding the vision encoder from adapter targets) and a tuned learning rate.
+
+Setup:
+
+```sh
+uv pip install git+https://huggingface.co/spaces/sergiopaniego/carla_env
+```
+
+Usage (requires at least 2 CARLA Spaces, each supports only 1 concurrent connection):
+
+```sh
+python examples/scripts/openenv/carla_vlm_gemma.py \
+ --env-urls https://server1.hf.space https://server2.hf.space \
+ --use-lora
+```
+"""
+
+import argparse
+import base64
+from io import BytesIO
+
+from carla_env import CarlaAction, CarlaEnv
+from datasets import Dataset
+from PIL import Image
+
+from trl import GRPOConfig, GRPOTrainer
+
+
+def parse_args():
+ parser = argparse.ArgumentParser(description="Run GRPO VLM training with CARLA environment.")
+ parser.add_argument("--model", type=str, default="google/gemma-4-E2B-it")
+ parser.add_argument(
+ "--env-urls",
+ type=str,
+ nargs="+",
+ required=True,
+ help="URLs for CARLA environment servers. At least 2 required (1 Space = 1 connection).",
+ )
+ parser.add_argument("--dataset-size", type=int, default=1000)
+ parser.add_argument("--max-completion-length", type=int, default=3072)
+ parser.add_argument("--per-device-train-batch-size", type=int, default=None, help="Defaults to len(env-urls).")
+ parser.add_argument("--gradient-accumulation-steps", type=int, default=16)
+ parser.add_argument("--max-steps", type=int, default=100)
+ parser.add_argument("--image-size", type=int, default=256, help="Resize camera images to this size. 0 to disable.")
+ parser.add_argument("--trackio-space-id", type=str, default=None, help="Trackio Space ID for logging.")
+ parser.add_argument("--use-lora", action="store_true", help="Use LoRA for memory-efficient training.")
+ parser.add_argument("--lora-r", type=int, default=128, help="LoRA rank.")
+ parser.add_argument("--lora-alpha", type=int, default=256, help="LoRA alpha.")
+ parser.add_argument(
+ "--lora-target-modules",
+ type=str,
+ default="llm-only",
+ help="LoRA target modules. Use 'llm-only' to skip vision encoder, 'all-linear' for all.",
+ )
+ parser.add_argument(
+ "--learning-rate", type=float, default=5e-6, help="Learning rate. Default 5e-6 (good for LoRA r=128)."
+ )
+ parser.add_argument("--hub-model-id", type=str, default=None)
+ parser.add_argument("--run-name", type=str, default=None)
+ parser.add_argument("--report-to", type=str, default="trackio", help="Logging backend: wandb, trackio, none.")
+ return parser.parse_args()
+
+
+PROMPT = """\
+You control an autonomous vehicle in an emergency. There are pedestrians ahead and you must \
+decide what to do immediately.
+
+You will see a camera image from the vehicle after each action. Use the visual information
+along with the scene description to decide your next action.
+
+You have the following tools available:
+- `observe`: Advance time and get a new observation of the scene with a camera image.
+- `emergency_stop`: Apply maximum braking to stop the vehicle.
+- `lane_change(direction)`: Change lane to the left or right. Direction must be "left" or "right".
+
+Make one tool call at a time, wait for the result, then decide your next action.
+Observe the scene first, then decide the best course of action to minimize harm.
+Consider all available actions - sometimes avoiding the obstacle by changing lanes \
+is safer than stopping in its path."""
+
+
+SIM_TICKS = 10 # Number of simulation steps to advance after each action
+
+
+class CarlaVLMEnv:
+ _env_url_iter = None
+ _image_size = 256
+
+ def __init__(self):
+ self.url = next(CarlaVLMEnv._env_url_iter)
+ self.client = CarlaEnv(base_url=self.url, connect_timeout_s=30, message_timeout_s=120)
+ self.reward = 0.0
+
+ @staticmethod
+ def _describe(obs) -> str:
+ parts = [f"Speed: {obs.speed_kmh:.1f} km/h."]
+ if obs.nearby_actors:
+ for actor in obs.nearby_actors:
+ parts.append(f"- {actor.get('type', 'actor')} at {actor.get('distance', '?')}m")
+ else:
+ parts.append("No nearby actors detected.")
+ if obs.collision_detected:
+ parts.append(f"COLLISION detected with {obs.collided_with or 'unknown'}!")
+ return "\n".join(parts)
+
+ @staticmethod
+ def _decode_image(camera_image_b64, target_size):
+ """Decode base64 JPEG image and optionally resize."""
+ img = Image.open(BytesIO(base64.b64decode(camera_image_b64)))
+ if target_size > 0:
+ img.thumbnail((target_size, target_size), Image.LANCZOS)
+ return img
+
+ def _format_multimodal(self, obs) -> list:
+ """Format observation as multimodal content blocks (camera image + text)."""
+ content = []
+ if obs.camera_image is not None:
+ content.append({"type": "image", "image": self._decode_image(obs.camera_image, CarlaVLMEnv._image_size)})
+ content.append({"type": "text", "text": self._describe(obs)})
+ return content
+
+ def _advance_and_capture(self, ticks: int = SIM_TICKS):
+ """Advance the simulation, then capture an image of the current state."""
+ result = None
+ for _ in range(ticks):
+ result = self.client.step(CarlaAction(action_type="observe"))
+ if result.done:
+ break
+ capture_result = self.client.step(CarlaAction(action_type="capture_image"))
+ result.observation.camera_image = capture_result.observation.camera_image
+ return result
+
+ def reset(self, **kwargs) -> str | None:
+ for attempt in range(3):
+ try:
+ result = self.client.reset(scenario_name="trolley_micro_escape_exists")
+ self.reward = 0.0
+ return self._describe(result.observation)
+ except Exception as e:
+ if attempt == 2:
+ raise
+ print(f"[WARN] reset failed (attempt {attempt + 1}/3): {e}. Reconnecting...")
+ self.client = CarlaEnv(base_url=self.url, connect_timeout_s=30, message_timeout_s=120)
+
+ def observe(self) -> list:
+ """
+ Get the current scene with a camera image and description.
+
+ Returns:
+ The camera image and scene description with vehicle state and nearby actors.
+ """
+ result = self._advance_and_capture()
+ self.reward = result.observation.rubric_reward or 0.0
+ return self._format_multimodal(result.observation)
+
+ def emergency_stop(self) -> list:
+ """
+ Apply maximum braking to stop the vehicle.
+
+ Returns:
+ The camera image and scene description after braking.
+ """
+ self.client.step(CarlaAction(action_type="emergency_stop"))
+ result = self._advance_and_capture()
+ self.reward = result.observation.rubric_reward or 0.0
+ print(f"[DEBUG env] emergency_stop: done={result.done}, reward={self.reward}")
+ return self._format_multimodal(result.observation)
+
+ def lane_change(self, direction: str) -> list:
+ """
+ Change lane to avoid obstacles.
+
+ Args:
+ direction: Direction to change lane, either "left" or "right".
+
+ Returns:
+ The camera image and scene description after changing lane.
+ """
+ self.client.step(CarlaAction(action_type="lane_change", lane_direction=direction))
+ result = self._advance_and_capture()
+ self.reward = result.observation.rubric_reward or 0.0
+ print(f"[DEBUG env] lane_change({direction}): done={result.done}, reward={self.reward}")
+ return self._format_multimodal(result.observation)
+
+
+def reward_func(completions, environments, **kwargs):
+ rewards = [env.reward for env in environments]
+ for i, (comp, env) in enumerate(zip(completions, environments, strict=False)):
+ tools = [
+ msg["tool_calls"][0]["function"]["name"] for msg in comp if isinstance(msg, dict) and msg.get("tool_calls")
+ ]
+ print(f"[DEBUG reward] gen={i} tools={tools} env_reward={env.reward}")
+ return rewards
+
+
+def main():
+ args = parse_args()
+ CarlaVLMEnv._env_url_iter = iter(args.env_urls)
+ CarlaVLMEnv._image_size = args.image_size
+
+ dataset = Dataset.from_dict({"prompt": [[{"role": "user", "content": PROMPT}] for _ in range(args.dataset_size)]})
+
+ peft_config = None
+ if args.use_lora:
+ from peft import LoraConfig
+
+ if args.lora_target_modules == "llm-only":
+ target_modules = "all-linear"
+ exclude_modules = ["vision_tower", "multi_modal_projector"]
+ else:
+ target_modules = args.lora_target_modules
+ exclude_modules = None
+
+ peft_config = LoraConfig(
+ r=args.lora_r,
+ lora_alpha=args.lora_alpha,
+ target_modules=target_modules,
+ exclude_modules=exclude_modules,
+ task_type="CAUSAL_LM",
+ )
+
+ trainer = GRPOTrainer(
+ model=args.model,
+ train_dataset=dataset,
+ reward_funcs=reward_func,
+ peft_config=peft_config,
+ args=GRPOConfig(
+ chat_template_kwargs={"enable_thinking": False},
+ log_completions=True,
+ logging_steps=2,
+ num_completions_to_print=1,
+ max_completion_length=args.max_completion_length,
+ per_device_train_batch_size=args.per_device_train_batch_size or len(args.env_urls),
+ steps_per_generation=1,
+ num_generations=len(args.env_urls),
+ max_tool_calling_iterations=10,
+ learning_rate=args.learning_rate,
+ gradient_accumulation_steps=args.gradient_accumulation_steps,
+ max_steps=args.max_steps,
+ push_to_hub=args.hub_model_id is not None,
+ hub_model_id=args.hub_model_id,
+ run_name=args.run_name,
+ report_to=args.report_to,
+ trackio_space_id=args.trackio_space_id,
+ ),
+ environment_factory=CarlaVLMEnv,
+ )
+ trainer.train()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/catch.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/catch.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ed13c3ce25b30850c96f1d5ddcb533018ee67ee
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/catch.py
@@ -0,0 +1,347 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[vllm,peft]",
+# "trackio",
+# "kernels",
+# "openenv-openspiel-env @ git+https://huggingface.co/spaces/openenv/openspiel_env",
+# ]
+# ///
+
+
+"""
+Simple script to run GRPO training with OpenEnv's Catch environment (OpenSpiel) and vLLM. The reward function
+is based on the catch game where the agent tries to catch falling balls.
+
+Setup (Option A - Install from HF Space, recommended):
+
+```sh
+uv pip install git+https://huggingface.co/spaces/openenv/openspiel_env
+```
+
+Setup (Option B - Clone OpenEnv repo, for development):
+
+```sh
+git clone https://github.com/huggingface/OpenEnv.git
+cd OpenEnv/envs/openspiel_env
+uv pip install -e .
+```
+
+# Option 1: HF Spaces + Colocated vLLM (1 GPU required)
+```sh
+python examples/scripts/openenv/catch.py --env-mode space --env-host https://openenv-openspiel-env.hf.space --vllm-mode colocate
+```
+
+# Option 2: HF Spaces + Separate vLLM server (2 GPUs required)
+
+# Spin up vLLM server (Terminal 1)
+```sh
+CUDA_VISIBLE_DEVICES=0 trl vllm-serve --model Qwen/Qwen2.5-0.5B-Instruct --host 0.0.0.0 --port 8000
+```
+
+# Run training (Terminal 2)
+```sh
+CUDA_VISIBLE_DEVICES=1 python examples/scripts/openenv/catch.py --env-mode space --env-host https://openenv-openspiel-env.hf.space --vllm-mode server --vllm-server-url http://localhost:8000
+```
+
+# Option 3: Local + Colocated vLLM (1 GPU required)
+
+# Start the environment only if using --env-mode docker-local
+```sh
+docker run -d -p 8001:8001 registry.hf.space/openenv-openspiel-env:latest
+```
+
+```sh
+python examples/scripts/openenv/catch.py --env-mode docker-local --vllm-mode colocate
+```
+"""
+
+# ruff: noqa: T201
+import argparse
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import requests
+from datasets import Dataset
+from openspiel_env import OpenSpielEnv
+from openspiel_env.models import OpenSpielAction
+
+from trl import GRPOConfig, GRPOTrainer, RichProgressCallback
+
+
+def parse_args():
+ parser = argparse.ArgumentParser(description="Run GRPO training with OpenSpiel Catch environment and vLLM.")
+
+ # --- Environment settings ---
+ parser.add_argument("--env-host", type=str, default="0.0.0.0", help="Host for the environment server.")
+ parser.add_argument("--env-port", type=int, default=8001, help="Port for the environment server.")
+ parser.add_argument(
+ "--env-mode",
+ choices=["local", "docker-local", "docker-image", "docker-hub", "space"],
+ default="docker-image",
+ help="Where to run the environment: 'local' to launch it, 'docker-local' if already running locally, 'docker-image' to run from a Docker image, 'docker-hub' to run from Docker Hub, or 'space' to use a remote Space URL.",
+ )
+ # --- Generation and model config ---
+ parser.add_argument(
+ "--model",
+ type=str,
+ default="Qwen/Qwen2.5-0.5B-Instruct",
+ help="Model name or path.",
+ )
+ parser.add_argument(
+ "--dataset-size",
+ type=int,
+ default=1000,
+ help="Number of prompts to use for training dataset.",
+ )
+ parser.add_argument(
+ "--env-image", type=str, default="openspiel-env:latest", help="Docker image for the OpenSpiel environment."
+ )
+ parser.add_argument(
+ "--vllm-mode",
+ choices=["colocate", "server"],
+ default="colocate",
+ help="vLLM execution mode: 'colocate' or 'server'.",
+ )
+ parser.add_argument(
+ "--vllm-server-url",
+ type=str,
+ default="http://localhost:8000",
+ help="URL for the vLLM server (only used when --vllm-mode=server).",
+ )
+
+ return parser.parse_args()
+
+
+def start_env_server(env_host: str, env_port: int):
+ """Launch the OpenSpiel Catch environment locally via uvicorn."""
+ env_url = f"http://{env_host}:{env_port}"
+ print(f"⚡ Starting FastAPI server for OpenSpiel Catch Environment on {env_url}...")
+
+ work_dir = str(Path.cwd().parent.absolute())
+ process = subprocess.Popen(
+ [
+ sys.executable,
+ "-m",
+ "uvicorn",
+ "envs.openspiel_env.server.app:app",
+ "--host",
+ env_host,
+ "--port",
+ str(env_port),
+ ],
+ env={**os.environ, "PYTHONPATH": f"{work_dir}/src"},
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ text=True,
+ cwd=work_dir,
+ )
+
+ print("⏳ Waiting for server to start...")
+ time.sleep(5)
+
+ try:
+ requests.get(f"{env_url}/health", timeout=2)
+ print("\n✅ OpenSpiel Catch Environment server is running!")
+ except Exception as e:
+ print(f"\n❌ Server failed to start: {e}")
+ if process.stderr:
+ print(process.stderr.read())
+ raise
+
+ return process
+
+
+BASE_PROMPT = """You are an AI agent playing the game **Catch**.
+
+### Game Description
+- The game is played on a **10×5 grid**.
+- There is one **falling ball** and one **paddle** that you control at the bottom.
+- The objective is to **move the paddle left or right to catch the ball** as it falls.
+- The episode ends when the ball reaches the bottom row:
+ - You get **+1 reward** if you catch it.
+ - You get **–1 reward** if you miss it.
+
+### Observation Format
+Each observation is a flattened 10x5 grid (list of 50 floats).
+- 1.0 → occupied (ball or paddle)
+- 0.0 → empty cell
+
+You have the following tools available:
+- `move(direction)`: Move the paddle left or right. Direction must be "left" or "right".
+- `stay`: Do nothing and let the ball fall one step.
+
+Observe the grid, determine where the ball is relative to the paddle, then move accordingly.
+"""
+
+
+def reward_from_env(environments, **kwargs):
+ rewards = []
+ for env in environments:
+ if env.done:
+ # Catch gives +1 for catching, -1 for missing. Clamp to [0, 1] for GRPO advantage estimation.
+ rewards.append(max(env.reward, 0.0))
+ else:
+ rewards.append(0.0) # Incomplete episode
+ return rewards
+
+
+def main():
+ args = parse_args()
+
+ # Select environment mode — all modes resolve to env_url
+ if args.env_mode == "local":
+ env_url = f"http://{args.env_host}:{args.env_port}"
+ server_process = start_env_server(args.env_host, args.env_port)
+ elif args.env_mode == "docker-local":
+ env_url = f"http://{args.env_host}:{args.env_port}"
+ server_process = None
+ print(f"🌍 Using existing OpenSpiel Environment (Docker) at: {env_url}")
+ elif args.env_mode == "docker-image":
+ _bootstrap = OpenSpielEnv.from_docker_image(args.env_image)
+ env_url = _bootstrap.base_url
+ server_process = None
+ print("🌍 Using OpenSpiel Environment (Docker) from local Image")
+ elif args.env_mode == "docker-hub":
+ _bootstrap = OpenSpielEnv.from_hub(args.env_image)
+ env_url = _bootstrap.base_url
+ server_process = None
+ print("🌍 Using existing OpenSpiel Environment (Docker) from Hub Image")
+ elif args.env_mode == "space":
+ env_url = args.env_host
+ server_process = None
+ print(f"🌍 Using Hugging Face Space environment at: {env_url}")
+ else:
+ raise ValueError(f"Unknown environment mode: {args.env_mode}")
+
+ dataset = Dataset.from_dict({"prompt": [[{"role": "user", "content": BASE_PROMPT}]] * args.dataset_size})
+
+ class CatchEnv:
+ ROWS = 10
+ COLS = 5
+
+ def __init__(self):
+ self.client = OpenSpielEnv(base_url=env_url)
+ self.reward = 0.0
+ self.done = False
+
+ @staticmethod
+ def _format_obs(info_state: list[float]) -> str:
+ """Convert the flat 50-float observation into a readable text description."""
+ rows, cols = CatchEnv.ROWS, CatchEnv.COLS
+ ball_row = ball_col = paddle_col = None
+ for idx, val in enumerate(info_state):
+ if val == 1.0:
+ r, c = divmod(idx, cols)
+ if r < rows - 1:
+ ball_row, ball_col = r + 1, c + 1
+ else:
+ paddle_col = c + 1
+ parts = []
+ if ball_row is not None and ball_col is not None:
+ parts.append(f"Ball: row {ball_row}/{rows}, column {ball_col}/{cols}")
+ if paddle_col is not None:
+ parts.append(f"Paddle: column {paddle_col}/{cols}")
+ if ball_col is not None and paddle_col is not None:
+ diff = ball_col - paddle_col
+ if diff < 0:
+ parts.append(f"The ball is {abs(diff)} column(s) to the LEFT of the paddle.")
+ elif diff > 0:
+ parts.append(f"The ball is {diff} column(s) to the RIGHT of the paddle.")
+ else:
+ parts.append("The ball is directly above the paddle.")
+ return "\n".join(parts)
+
+ def reset(self, **kwargs) -> str:
+ env_result = self.client.reset()
+ self.reward = 0.0
+ self.done = env_result.observation.done
+ return self._format_obs(env_result.observation.info_state)
+
+ def _do_action(self, action_id: int) -> str:
+ if self.done:
+ raise ValueError("Episode is done.")
+ env_result = self.client.step(OpenSpielAction(action_id=action_id, game_name="catch"))
+ self.reward = env_result.reward or 0.0
+ self.done = env_result.observation.done
+ return self._format_obs(env_result.observation.info_state)
+
+ def move(self, direction: str) -> str:
+ """Move the paddle left or right.
+
+ Args:
+ direction: Direction to move, either "left" or "right".
+
+ Returns:
+ The observation after moving.
+ """
+ if direction == "left":
+ action_id = 0
+ elif direction == "right":
+ action_id = 2
+ else:
+ raise ValueError(f"Invalid direction {direction!r}: must be 'left' or 'right'.")
+ return self._do_action(action_id)
+
+ def stay(self) -> str:
+ """Do nothing and let the ball fall one step.
+
+ Returns:
+ The observation after staying.
+ """
+ return self._do_action(1)
+
+ training_args = GRPOConfig(
+ output_dir=f"{args.model.split('/')[-1]}-GRPO-Catch",
+ use_vllm=True,
+ vllm_mode=args.vllm_mode,
+ vllm_server_base_url=args.vllm_server_url if args.vllm_mode == "server" else None,
+ vllm_gpu_memory_utilization=0.2,
+ logging_steps=1,
+ log_completions=True,
+ report_to="trackio",
+ trackio_space_id=f"{args.model.split('/')[-1]}-GRPO-Catch",
+ num_train_epochs=1,
+ per_device_train_batch_size=2,
+ num_generations=8,
+ max_completion_length=4096,
+ gradient_accumulation_steps=16,
+ chat_template_kwargs={"enable_thinking": False},
+ )
+
+ trainer = GRPOTrainer(
+ model=args.model,
+ reward_funcs=reward_from_env,
+ args=training_args,
+ train_dataset=dataset,
+ environment_factory=CatchEnv,
+ callbacks=[RichProgressCallback()],
+ )
+
+ try:
+ trainer.train()
+ finally:
+ if server_process:
+ print("🛑 Terminating environment server...")
+ server_process.terminate()
+ server_process.wait()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/echo.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/echo.py
new file mode 100644
index 0000000000000000000000000000000000000000..e97e620c4367423f19858b9756794f13f00a1e66
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/echo.py
@@ -0,0 +1,133 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "openenv-echo-env @ git+https://huggingface.co/spaces/qgallouedec/echo_env",
+# ]
+# ///
+
+
+"""
+Simple script to run GRPO training with OpenEnv's Echo environment. The environment echoes back the message
+sent to it and rewards longer completions.
+
+Setup (Option A - Install from HF Space, recommended):
+
+```sh
+uv pip install git+https://huggingface.co/spaces/qgallouedec/echo_env
+```
+
+Setup (Option B - Clone OpenEnv repo, for development):
+
+```sh
+git clone https://github.com/huggingface/OpenEnv.git
+cd OpenEnv/envs/echo_env
+uv pip install -e .
+```
+
+Usage:
+
+```sh
+python examples/scripts/openenv/echo.py
+python examples/scripts/openenv/echo.py --model Qwen/Qwen2.5-0.5B-Instruct --env-host https://qgallouedec-echo-env.hf.space
+```
+"""
+
+import argparse
+
+from datasets import Dataset
+from echo_env import EchoEnv
+from echo_env.models import EchoAction
+
+from trl import GRPOConfig, GRPOTrainer
+
+
+def parse_args():
+ parser = argparse.ArgumentParser(description="Run GRPO training with Echo environment.")
+ parser.add_argument(
+ "--model",
+ type=str,
+ default="Qwen/Qwen3-0.6B",
+ help="Model to use for training.",
+ )
+ parser.add_argument(
+ "--env-host",
+ type=str,
+ default="https://qgallouedec-echo-env.hf.space",
+ help="URL for the Echo environment HF Space.",
+ )
+ return parser.parse_args()
+
+
+def reward_func(environments, **kwargs):
+ return [env.reward for env in environments]
+
+
+def main():
+ args = parse_args()
+
+ dataset = Dataset.from_dict(
+ {
+ "prompt": [
+ [{"role": "user", "content": "Try to echo 'Hello World!' in the environment."}],
+ [{"role": "user", "content": "Make the environment echo 'Goodbye World!'"}],
+ [{"role": "user", "content": "Can you ask the environment to echo 'TRL is great!'?"}],
+ [{"role": "user", "content": "What happens if you ask the environment to echo 'I love RLHF!'?"}],
+ [{"role": "user", "content": "Try to make the environment echo 'OpenEnv is awesome!'"}],
+ ],
+ }
+ )
+
+ class EchoToolEnv:
+ def __init__(self):
+ self.env = EchoEnv(base_url=args.env_host)
+ self.reward = 0.0
+
+ def reset(self, **kwargs) -> None | str:
+ self.reward = 0.0
+ return None
+
+ def echo(self, message: str) -> str:
+ """
+ Echo the message back from the environment.
+
+ Args:
+ message: The message to echo
+
+ Returns:
+ The echoed message.
+ """
+ observation = self.env.step(EchoAction(message=message))
+ self.reward = observation.observation.reward
+ return observation.observation.echoed_message
+
+ trainer = GRPOTrainer(
+ model=args.model,
+ train_dataset=dataset,
+ reward_funcs=reward_func,
+ args=GRPOConfig(
+ chat_template_kwargs={"enable_thinking": False},
+ log_completions=True,
+ logging_steps=2,
+ num_completions_to_print=1,
+ ),
+ environment_factory=EchoToolEnv,
+ )
+ trainer.train()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/multi_env.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/multi_env.py
new file mode 100644
index 0000000000000000000000000000000000000000..09147d56ea2c9fb1b88eff106eb78c7d135e2723
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/multi_env.py
@@ -0,0 +1,273 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "trackio",
+# "openenv-textarena @ git+https://huggingface.co/spaces/openenv/wordle",
+# "openenv-openspiel-env @ git+https://huggingface.co/spaces/openenv/openspiel_env",
+# ]
+# ///
+
+"""
+Multi-environment GRPO training with OpenEnv: Wordle + Catch in the same training run.
+
+Demonstrates how to wrap multiple environments in a single `environment_factory` class. The dataset
+contains an "env" column that routes each sample to the correct environment at `reset()` time.
+
+Usage:
+ python examples/scripts/openenv/multi_env.py \\
+ --wordle-url https://openenv-wordle.hf.space \\
+ --catch-url https://openenv-openspiel-env.hf.space
+"""
+
+import argparse
+
+from datasets import Dataset
+from openspiel_env import OpenSpielEnv
+from openspiel_env.models import OpenSpielAction
+from textarena_env import TextArenaAction, TextArenaEnv
+
+from trl import GRPOConfig, GRPOTrainer
+
+
+wordle_prompt = """You are an expert Wordle solver with deep knowledge of English vocabulary, letter frequency patterns, and optimal guessing strategies.
+
+Follow these rules to play Wordle:
+
+1. The target is a 5-letter English word
+2. You have 6 attempts to guess the correct word
+3. After each guess, you receive color-coded feedback:
+ - GREEN (G): Letter is correct and in the correct position
+ - YELLOW (Y): Letter is in the word but in the wrong position
+ - GRAY (X): Letter is not in the word at all
+4. All guesses must be valid 5-letter English words
+5. You cannot reuse a word you've already guessed
+6. Use the tool `guess` to make a guess.
+"""
+
+catch_prompt = """You are an AI agent playing the game **Catch**.
+
+### Game Description
+- The game is played on a **10×5 grid**.
+- There is one **falling ball** and one **paddle** that you control at the bottom.
+- The objective is to **move the paddle left or right to catch the ball** as it falls.
+- The episode ends when the ball reaches the bottom row:
+ - You get **+1 reward** if you catch it.
+ - You get **–1 reward** if you miss it.
+
+### Observation Format
+Each observation is a flattened 10x5 grid (list of 50 floats).
+- 1.0 → occupied (ball or paddle)
+- 0.0 → empty cell
+
+You have the following tools available:
+- `move(direction)`: Move the paddle left or right. Direction must be "left" or "right".
+- `stay`: Do nothing and let the ball fall one step.
+
+Observe the grid, determine where the ball is relative to the paddle, then move accordingly.
+"""
+
+DEFAULT_WORDLE_URL = "https://openenv-wordle.hf.space"
+DEFAULT_CATCH_URL = "https://openenv-openspiel-env.hf.space"
+
+CATCH_ROWS = 10
+CATCH_COLS = 5
+
+
+def _format_catch_obs(info_state: list[float]) -> str:
+ """Convert the flat 50-float observation into a readable text description."""
+ ball_row = ball_col = paddle_col = None
+ for idx, val in enumerate(info_state):
+ if val == 1.0:
+ r, c = divmod(idx, CATCH_COLS)
+ if r < CATCH_ROWS - 1:
+ ball_row, ball_col = r + 1, c + 1
+ else:
+ paddle_col = c + 1
+ parts = []
+ if ball_row is not None and ball_col is not None:
+ parts.append(f"Ball: row {ball_row}/{CATCH_ROWS}, column {ball_col}/{CATCH_COLS}")
+ if paddle_col is not None:
+ parts.append(f"Paddle: column {paddle_col}/{CATCH_COLS}")
+ if ball_col is not None and paddle_col is not None:
+ diff = ball_col - paddle_col
+ if diff < 0:
+ parts.append(f"The ball is {abs(diff)} column(s) to the LEFT of the paddle.")
+ elif diff > 0:
+ parts.append(f"The ball is {diff} column(s) to the RIGHT of the paddle.")
+ else:
+ parts.append("The ball is directly above the paddle.")
+ return "\n".join(parts)
+
+
+class MultiEnv:
+ wordle_url = DEFAULT_WORDLE_URL
+ catch_url = DEFAULT_CATCH_URL
+
+ def __init__(self):
+ self._wordle_client = None
+ self._catch_client = None
+ self.active = None
+ self.reward = 0.0
+ self.done = False
+
+ def reset(self, **kwargs) -> str | None:
+ self.active = kwargs.get("env", "wordle")
+ self.reward = 0.0
+ self.done = False
+
+ if self.active == "wordle":
+ if self._wordle_client is not None:
+ try:
+ self._wordle_client.close()
+ except Exception:
+ pass
+ self._wordle_client = TextArenaEnv(base_url=MultiEnv.wordle_url)
+ result = self._wordle_client.reset()
+ self._last_full_feedback = result.observation.messages[0].content
+ self.reward = 0.0
+ return self._last_full_feedback
+ elif self.active == "catch":
+ if self._catch_client is not None:
+ try:
+ self._catch_client.close()
+ except Exception:
+ pass
+ self._catch_client = OpenSpielEnv(base_url=MultiEnv.catch_url)
+ result = self._catch_client.reset()
+ self.done = result.observation.done
+ return _format_catch_obs(result.observation.info_state)
+ else:
+ raise ValueError(f"Unknown environment: {self.active}")
+
+ def guess(self, guess: str) -> str:
+ """
+ Make a guess in the Wordle environment.
+
+ Args:
+ guess: The guessed word, formatted as '[abcde]'
+
+ Returns:
+ The feedback message from the environment.
+ """
+ if self.active != "wordle":
+ raise ValueError("guess is only available in Wordle")
+ if self.done:
+ raise ValueError("Game over.")
+ result = self._wordle_client.step(TextArenaAction(message=guess))
+ _full_feedback = result.observation.messages[0].content
+ feedback = _full_feedback[len(self._last_full_feedback) :]
+ self._last_full_feedback = _full_feedback
+ if "You attempted an invalid move" in feedback:
+ self.reward = 0.0
+ else:
+ self.reward = result.reward
+ self.done = result.done
+ return feedback
+
+ def _catch_action(self, action_id: int) -> str:
+ if self.done:
+ raise ValueError("Episode is done.")
+ result = self._catch_client.step(OpenSpielAction(action_id=action_id, game_name="catch"))
+ self.reward = result.reward or 0.0
+ self.done = result.observation.done
+ return _format_catch_obs(result.observation.info_state)
+
+ def move(self, direction: str) -> str:
+ """Move the paddle left or right.
+
+ Args:
+ direction: Direction to move, either "left" or "right".
+
+ Returns:
+ The observation after moving.
+ """
+ if self.active != "catch":
+ raise ValueError("move is only available in Catch")
+ if direction == "left":
+ action_id = 0
+ elif direction == "right":
+ action_id = 2
+ else:
+ raise ValueError(f"Invalid direction {direction!r}: must be 'left' or 'right'.")
+ return self._catch_action(action_id)
+
+ def stay(self) -> str:
+ """Do nothing and let the ball fall one step.
+
+ Returns:
+ The observation after staying.
+ """
+ if self.active != "catch":
+ raise ValueError("stay is only available in Catch")
+ return self._catch_action(1)
+
+
+def wordle_reward(environments, **kwargs) -> list[float | None]:
+ return [env.reward if env.active == "wordle" else None for env in environments]
+
+
+def catch_reward(environments, **kwargs) -> list[float | None]:
+ rewards = []
+ for env in environments:
+ if env.active != "catch":
+ rewards.append(None)
+ elif env.done:
+ # Catch gives +1 for catching, -1 for missing. Clamp to [0, 1] for GRPO advantage estimation.
+ rewards.append(max(env.reward, 0.0))
+ else:
+ rewards.append(0.0) # Incomplete episode
+ return rewards
+
+
+def main() -> None:
+ parser = argparse.ArgumentParser(description="Multi-environment GRPO training")
+ parser.add_argument("--wordle-url", default=DEFAULT_WORDLE_URL, help="Wordle environment URL")
+ parser.add_argument("--catch-url", default=DEFAULT_CATCH_URL, help="Catch environment URL")
+ args, remaining = parser.parse_known_args()
+
+ MultiEnv.wordle_url = args.wordle_url
+ MultiEnv.catch_url = args.catch_url
+
+ n = 500 # samples per environment
+ dataset = Dataset.from_dict(
+ {
+ "prompt": (
+ [[{"role": "user", "content": wordle_prompt}]] * n + [[{"role": "user", "content": catch_prompt}]] * n
+ ),
+ "env": ["wordle"] * n + ["catch"] * n,
+ }
+ )
+
+ trainer = GRPOTrainer(
+ model="Qwen/Qwen3-1.7B",
+ reward_funcs=[wordle_reward, catch_reward],
+ train_dataset=dataset,
+ args=GRPOConfig(
+ report_to="wandb",
+ log_completions=True,
+ num_completions_to_print=2,
+ logging_steps=1,
+ chat_template_kwargs={"enable_thinking": False},
+ max_completion_length=1024,
+ ),
+ environment_factory=MultiEnv,
+ )
+ trainer.train()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/sudoku.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/sudoku.py
new file mode 100644
index 0000000000000000000000000000000000000000..6cd284030729ab25b818f5ec3fc6c852d7a793a7
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/sudoku.py
@@ -0,0 +1,669 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[vllm,peft]",
+# "trackio",
+# "kernels",
+# "openenv-textarena @ git+https://huggingface.co/spaces/openenv/sudoku",
+# ]
+# ///
+
+"""
+GRPO training for Sudoku with TextArena environment.
+
+Setup (Option A - Install from HF Space, recommended):
+
+```sh
+uv pip install git+https://huggingface.co/spaces/openenv/sudoku
+```
+
+Setup (Option B - Clone OpenEnv repo, for development):
+
+```sh
+git clone https://github.com/huggingface/OpenEnv.git
+cd OpenEnv/envs/textarena_env
+uv pip install -e .
+```
+
+# Option 1: HF Spaces + Colocated vLLM (1 GPU required)
+```sh
+python examples/scripts/openenv/sudoku.py --vllm-mode colocate
+```
+
+# Option 2: HF Spaces + Separate vLLM server (2 GPUs required)
+
+# Spin up vLLM server (Terminal 1)
+```sh
+CUDA_VISIBLE_DEVICES=0 trl vllm-serve --model Qwen/Qwen3-1.7B --host 0.0.0.0 --port 8000
+```
+
+# Run training (Terminal 2)
+```sh
+CUDA_VISIBLE_DEVICES=1 python examples/scripts/openenv/sudoku.py --vllm-mode server --vllm-server-url http://localhost:8000
+```
+
+# Option 3: Local + Colocated vLLM (1 GPU required)
+
+# Start the environment only if using --env-mode docker-local
+```sh
+docker run -d -p 8001:8001 registry.hf.space/openenv-sudoku:latest
+```
+
+```sh
+python examples/scripts/openenv/sudoku.py --env-mode docker-local --vllm-mode colocate
+```
+
+# Full example with all flags:
+```sh
+python examples/scripts/openenv/sudoku.py \
+ --vllm-mode colocate \
+ --env-mode space \
+ --env-host https://openenv-sudoku.hf.space \
+ --num-generations 8 \
+ --per-device-batch-size 1 \
+ --max-turns 100 \
+ --gradient-accumulation-steps 8 \
+ --difficulty easy \
+ --dataset-size 100
+```
+"""
+
+from __future__ import annotations
+
+# ruff: noqa: T201
+import argparse
+import sys
+import time
+from collections import defaultdict
+from datetime import datetime
+from pathlib import Path
+
+from datasets import Dataset
+
+from trl import GRPOConfig, GRPOTrainer, RichProgressCallback
+
+
+# Ensure src/ is on the path
+sys.path.insert(0, str(Path(__file__).parent / "src"))
+
+from textarena_env import TextArenaAction, TextArenaEnv
+
+
+# ---------------------------------------------------------------------------
+# Argument parsing
+# ---------------------------------------------------------------------------
+
+
+def parse_args() -> argparse.Namespace:
+ parser = argparse.ArgumentParser(description="GRPO training for Sudoku")
+
+ # Model
+ parser.add_argument("--model-id", default="Qwen/Qwen3-1.7B")
+
+ # Environment
+ parser.add_argument("--env-host", type=str, default="https://openenv-sudoku.hf.space")
+ parser.add_argument("--env-port", type=int, default=8001)
+ parser.add_argument("--env-mode", choices=["docker-local", "docker-image", "docker-hub", "space"], default="space")
+ parser.add_argument("--env-image", type=str, default="textarena-env:latest")
+
+ # Prompts
+ parser.add_argument("--system-prompt-path", default="sudoku_prompt.txt")
+ parser.add_argument("--dataset-prompt", default="Play Sudoku like an expert.")
+ parser.add_argument("--dataset-size", type=int, default=1000)
+
+ # Game settings
+ parser.add_argument("--max-turns", type=int, default=100)
+ parser.add_argument(
+ "--difficulty",
+ type=str,
+ choices=["easy", "medium", "hard"],
+ default="easy",
+ help="Training difficulty: easy=guaranteed+options, medium=only options, hard=no hints",
+ )
+ parser.add_argument(
+ "--api-delay", type=float, default=0.0, help="Delay in seconds between API calls to avoid rate limiting"
+ )
+
+ # Sampling
+ parser.add_argument("--temperature", type=float, default=0.8)
+ parser.add_argument("--top-k", type=int, default=10)
+ parser.add_argument("--top-p", type=float, default=None, help="Top-p sampling parameter")
+
+ # Training
+ parser.add_argument("--learning-rate", type=float, default=5e-6)
+ parser.add_argument("--weight-decay", type=float, default=0.0)
+ parser.add_argument("--gradient-accumulation-steps", type=int, default=64)
+ parser.add_argument("--warmup-steps", type=int, default=20)
+ parser.add_argument("--per-device-batch-size", type=int, default=1)
+ parser.add_argument("--num-generations", type=int, default=8)
+ parser.add_argument("--num-epochs", type=int, default=1)
+ parser.add_argument("--max-completion-length", type=int, default=16384)
+
+ # Checkpoints
+ parser.add_argument("--save-interval", type=int, default=10)
+ parser.add_argument("--save-total-limit", type=int, default=None)
+ parser.add_argument("--output-dir", default=None)
+
+ # Logging
+ parser.add_argument("--run-name", default=None)
+ parser.add_argument("--project", default=None)
+ parser.add_argument("--trackio-space-id", default="Sudoku-GRPO")
+ parser.add_argument("--logging-steps", type=int, default=1)
+ parser.add_argument(
+ "--gradient-checkpointing",
+ action=argparse.BooleanOptionalAction,
+ default=True,
+ help="Enable gradient checkpointing to save memory",
+ )
+
+ # LoRA / PEFT
+ parser.add_argument(
+ "--use-lora", action="store_true", default=False, help="Use LoRA for memory-efficient training"
+ )
+ parser.add_argument("--lora-r", type=int, default=16, help="LoRA rank")
+ parser.add_argument("--lora-alpha", type=int, default=32, help="LoRA alpha")
+
+ # vLLM
+ parser.add_argument("--vllm-mode", choices=("colocate", "server"), default="colocate")
+ parser.add_argument("--vllm-server-url", type=str, default="http://localhost:8000")
+ parser.add_argument("--vllm-gpu-memory-utilization", type=float, default=0.15)
+
+ return parser.parse_args()
+
+
+# ---------------------------------------------------------------------------
+# Helper functions
+# ---------------------------------------------------------------------------
+
+
+def resolve_system_prompt(path: str) -> str:
+ prompt_path = Path(path)
+ if not prompt_path.is_file():
+ prompt_path = Path(__file__).parent / path
+ return prompt_path.read_text()
+
+
+def sanitize_name(name: str) -> str:
+ return name.replace("/", "-")
+
+
+def is_valid_board_state(board_str: str) -> bool:
+ """Check if the string contains an actual Sudoku board."""
+ return "R1" in board_str and "R9" in board_str and "|" in board_str
+
+
+def parse_board(board_str: str) -> list[list[int]]:
+ """Parse board string into 9x9 grid (0 = empty)."""
+ grid = [[0] * 9 for _ in range(9)]
+ if not is_valid_board_state(board_str):
+ return grid
+
+ for line in board_str.split("\n"):
+ line_stripped = line.strip()
+ if line_stripped and line_stripped[0] == "R" and len(line_stripped) > 1 and line_stripped[1].isdigit():
+ row = int(line_stripped[1]) - 1 # 0-indexed
+ cell_part = line_stripped[2:]
+ col = 0
+ for char in cell_part:
+ if char == ".":
+ grid[row][col] = 0
+ col += 1
+ elif char.isdigit():
+ grid[row][col] = int(char)
+ col += 1
+ return grid
+
+
+def count_filled_cells(board_str: str) -> int:
+ """Count the number of filled cells in the board."""
+ if not is_valid_board_state(board_str):
+ return 0
+ grid = parse_board(board_str)
+ return sum(1 for row in grid for cell in row if cell != 0)
+
+
+def get_valid_numbers(grid: list[list[int]], row: int, col: int) -> set[int]:
+ """Get valid numbers for a cell based on Sudoku rules."""
+ if grid[row][col] != 0:
+ return set()
+
+ used = set()
+
+ # Check row
+ for c in range(9):
+ if grid[row][c] != 0:
+ used.add(grid[row][c])
+
+ # Check column
+ for r in range(9):
+ if grid[r][col] != 0:
+ used.add(grid[r][col])
+
+ # Check 3x3 box
+ box_row, box_col = 3 * (row // 3), 3 * (col // 3)
+ for r in range(box_row, box_row + 3):
+ for c in range(box_col, box_col + 3):
+ if grid[r][c] != 0:
+ used.add(grid[r][c])
+
+ return set(range(1, 10)) - used
+
+
+def extract_empty_cells_with_candidates(
+ board_str: str, sort_by_difficulty: bool = True
+) -> list[tuple[int, int, set[int]]]:
+ """Extract empty cells with their valid candidate numbers.
+
+ Args:
+ sort_by_difficulty: If True, sort by number of candidates (easiest first).
+ If False, keep natural order (top-left to bottom-right).
+ """
+ grid = parse_board(board_str)
+ cells_with_candidates = []
+
+ for row in range(9):
+ for col in range(9):
+ if grid[row][col] == 0:
+ candidates = get_valid_numbers(grid, row, col)
+ cells_with_candidates.append((row + 1, col + 1, candidates)) # 1-indexed
+
+ if sort_by_difficulty:
+ # Sort by number of candidates (easiest first = naked singles)
+ cells_with_candidates.sort(key=lambda x: len(x[2]))
+
+ return cells_with_candidates
+
+
+def extract_empty_cells(board_str: str) -> list[tuple[int, int]]:
+ """Extract list of empty cells (row, col) from board string."""
+ empty_cells = []
+ if not is_valid_board_state(board_str):
+ return empty_cells
+
+ for line in board_str.split("\n"):
+ line_stripped = line.strip()
+ if line_stripped and line_stripped[0] == "R" and len(line_stripped) > 1 and line_stripped[1].isdigit():
+ row = int(line_stripped[1])
+ cell_part = line_stripped[2:]
+ col = 0
+ for char in cell_part:
+ if char == ".":
+ col += 1
+ empty_cells.append((row, col))
+ elif char.isdigit():
+ col += 1
+ return empty_cells
+
+
+def extract_board_only(text: str) -> str:
+ """Extract just the Sudoku grid from a message."""
+ if not text:
+ return ""
+
+ lines = text.split("\n")
+ board_lines = []
+ in_board = False
+
+ for line in lines:
+ stripped = line.strip()
+ if stripped.startswith("C1") or (
+ stripped and stripped[0] == "R" and len(stripped) > 1 and stripped[1].isdigit()
+ ):
+ in_board = True
+ if in_board and (stripped.startswith("-") or stripped.startswith("R") or stripped.startswith("C1")):
+ board_lines.append(line)
+ elif (
+ in_board
+ and stripped
+ and not stripped.startswith("-")
+ and not (stripped[0] == "R" and len(stripped) > 1 and stripped[1].isdigit())
+ ):
+ break
+
+ return "\n".join(board_lines) if board_lines else ""
+
+
+# ---------------------------------------------------------------------------
+# Reward functions
+# ---------------------------------------------------------------------------
+
+
+def reward_empty_cell(environments, **kwargs) -> list[float]:
+ """Reward for targeting empty cells (learn to pick valid positions first)."""
+ return [env.empty_cell_reward for env in environments]
+
+
+def reward_valid_moves(environments, **kwargs) -> list[float]:
+ """Reward for making valid moves."""
+ return [env.valid_move_reward for env in environments]
+
+
+def reward_correct(environments, **kwargs) -> list[float]:
+ """Reward for solving the puzzle."""
+ return [env.correct_reward for env in environments]
+
+
+def reward_repetition(environments, **kwargs) -> list[float]:
+ """Penalty for repeating moves."""
+ return [env.repetition_reward for env in environments]
+
+
+def reward_progress(environments, **kwargs) -> list[float]:
+ """Reward for filling more cells in the board."""
+ return [env.progress_reward for env in environments]
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+ args = parse_args()
+
+ # Setup environment — all modes resolve to env_url
+ if args.env_mode == "docker-local":
+ env_url = f"http://{args.env_host}:{args.env_port}"
+ elif args.env_mode == "docker-image":
+ _bootstrap = TextArenaEnv.from_docker_image(args.env_image)
+ env_url = _bootstrap.base_url
+ elif args.env_mode == "docker-hub":
+ _bootstrap = TextArenaEnv.from_hub(args.env_image)
+ env_url = _bootstrap.base_url
+ elif args.env_mode == "space":
+ env_url = args.env_host
+ else:
+ raise ValueError(f"Unknown environment mode: {args.env_mode}")
+
+ print(f"Environment: {args.env_mode} ({env_url})")
+
+ system_prompt = resolve_system_prompt(args.system_prompt_path)
+ dataset = Dataset.from_dict(
+ {
+ "prompt": [
+ [
+ {"role": "system", "content": system_prompt},
+ {"role": "user", "content": args.dataset_prompt},
+ ]
+ ]
+ * args.dataset_size
+ }
+ )
+
+ # Capture args for use in the environment class closure
+ difficulty = args.difficulty
+ max_turns = args.max_turns
+ api_delay = args.api_delay
+
+ class SudokuEnv:
+ def __init__(self):
+ self.client = TextArenaEnv(base_url=env_url)
+ self._difficulty = difficulty
+ self._max_turns = max_turns
+ self._api_delay = api_delay
+ self._reset_state()
+
+ def _reset_state(self):
+ self._move_counts: defaultdict[str, int] = defaultdict(int)
+ self._successful_moves: list[str] = []
+ self._failed_moves: list[str] = []
+ self._valid_move_scores: list[float] = []
+ self._empty_cell_scores: list[float] = []
+ self._correct_scores: list[float] = []
+ self._repetition_scores: list[float] = []
+ self._last_board_state = ""
+ self._initial_filled = 0
+ self._max_filled = 0
+ self._turn = 0
+ self._done = False
+
+ def reset(self, **kwargs) -> str:
+ self._reset_state()
+ result = self.client.reset()
+ time.sleep(self._api_delay)
+ observation = result.observation
+ self._done = result.done
+
+ # Store full message content for diffing (messages are cumulative)
+ self._last_full_content = observation.messages[0].content if observation.messages else ""
+
+ if is_valid_board_state(self._last_full_content):
+ self._last_board_state = self._last_full_content
+ self._initial_filled = count_filled_cells(self._last_board_state)
+ self._max_filled = self._initial_filled
+
+ board = extract_board_only(self._last_board_state) if self._last_board_state else "No board available."
+ hints = self._format_hints()
+ return f"Step 0. Progress: 0 cells filled.\n\nBoard:\n{board}{hints}"
+
+ def place(self, row: int, col: int, number: int) -> str:
+ """Place a number on the Sudoku board.
+
+ Args:
+ row: Row number (1-9).
+ col: Column number (1-9).
+ number: Number to place (1-9).
+
+ Returns:
+ The result of the move and updated board state.
+ """
+ if self._done:
+ raise ValueError("Game is over. No more moves allowed.")
+
+ self._turn += 1
+ move = f"[{row} {col} {number}]"
+
+ # Step environment
+ result = self.client.step(TextArenaAction(message=move))
+ time.sleep(self._api_delay)
+ observation = result.observation
+ correct_score = float(result.reward or 0.0)
+ self._done = result.done
+
+ # Only check the NEW content for feedback (messages are cumulative)
+ full_content = observation.messages[0].content if observation.messages else ""
+ new_content = full_content[len(self._last_full_content) :]
+ self._last_full_content = full_content
+
+ new_content_lower = new_content.lower()
+ env_says_invalid = any(
+ kw in new_content_lower for kw in ["invalid", "error", "cannot", "already", "violation", "lost"]
+ )
+ got_warning = "please resubmit" in new_content_lower or "avoid penalties" in new_content_lower
+
+ # Also verify against our own board state: placing on a non-empty cell is always invalid
+ if self._last_board_state:
+ empty_cells = extract_empty_cells(self._last_board_state)
+ targets_empty = (row, col) in empty_cells
+ else:
+ empty_cells = []
+ targets_empty = True # Can't verify, assume valid
+
+ is_valid = not env_says_invalid and targets_empty
+
+ # Empty cell score: did the model target an empty cell?
+ empty_cell_score = 1.0 if targets_empty else -1.0
+
+ # Repetition tracking
+ is_new_move = self._move_counts[move] == 0
+ repetition_count = self._move_counts[move]
+ self._move_counts[move] += 1
+ repetition_score = -min(2 ** (repetition_count - 1), 10.0) if repetition_count > 0 else 0.0
+
+ # Valid move score
+ if is_valid and is_new_move:
+ valid_move_score = 1.0
+ self._successful_moves.append(move)
+ elif got_warning:
+ valid_move_score = -0.5
+ self._failed_moves.append(move)
+ else:
+ valid_move_score = 0.0
+
+ # Update board state from new content
+ if is_valid and is_valid_board_state(new_content):
+ self._last_board_state = new_content
+ current_filled = count_filled_cells(self._last_board_state)
+ if current_filled > self._max_filled:
+ self._max_filled = current_filled
+
+ self._valid_move_scores.append(valid_move_score)
+ self._empty_cell_scores.append(empty_cell_score)
+ self._correct_scores.append(correct_score)
+ self._repetition_scores.append(repetition_score)
+
+ # Enforce max turns
+ if self._turn >= self._max_turns:
+ self._done = True
+
+ # Build response
+ board = extract_board_only(self._last_board_state) if self._last_board_state else "No board available."
+ status = "valid" if is_valid else "invalid"
+ cells_filled = len(self._successful_moves)
+ progress = f"Step {self._turn}. Progress: {cells_filled} cells filled."
+ hints = self._format_hints()
+
+ if self._done:
+ return f"Move {move}: {status}. Game over.\n{progress}\n\nFinal board:\n{board}"
+ return f"Move {move}: {status}\n{progress}\n\nBoard:\n{board}{hints}"
+
+ def _format_hints(self) -> str:
+ parts = []
+
+ # Already tried moves (avoid repetitions)
+ all_tried = self._successful_moves + self._failed_moves
+ if all_tried:
+ parts.append(f"\nMOVES ALREADY TRIED (do not repeat): {', '.join(all_tried)}")
+
+ if not self._last_board_state:
+ return "\n".join(parts)
+
+ if self._difficulty == "easy":
+ cells = extract_empty_cells_with_candidates(self._last_board_state, sort_by_difficulty=True)
+ if cells:
+ guaranteed = []
+ other = []
+ for r, c, candidates in cells[:10]:
+ if len(candidates) == 1:
+ guaranteed.append(f"[{r} {c} {list(candidates)[0]}]")
+ elif len(candidates) <= 3:
+ nums = ",".join(str(n) for n in sorted(candidates))
+ other.append(f"({r},{c})->{nums}")
+ if guaranteed:
+ parts.append(f"\nGUARANTEED MOVES: {', '.join(guaranteed[:5])}")
+ if other:
+ parts.append(f"Other options: {' | '.join(other[:5])}")
+
+ elif self._difficulty == "medium":
+ cells = extract_empty_cells_with_candidates(self._last_board_state, sort_by_difficulty=False)
+ if cells:
+ cell_hints = []
+ for r, c, candidates in cells[:10]:
+ nums = ",".join(str(n) for n in sorted(candidates))
+ cell_hints.append(f"({r},{c})->{nums}")
+ parts.append(f"\nEmpty cells: {' | '.join(cell_hints)}")
+
+ return "\n".join(parts)
+
+ # Reward properties — properties are not detected by inspect.ismethod,
+ # so they won't be exposed as tools.
+
+ @property
+ def correct_reward(self) -> float:
+ return self._correct_scores[-1] if self._correct_scores else 0.0
+
+ @property
+ def valid_move_reward(self) -> float:
+ return sum(self._valid_move_scores) / len(self._valid_move_scores) if self._valid_move_scores else 0.0
+
+ @property
+ def empty_cell_reward(self) -> float:
+ return sum(self._empty_cell_scores) / len(self._empty_cell_scores) if self._empty_cell_scores else 0.0
+
+ @property
+ def repetition_reward(self) -> float:
+ return sum(self._repetition_scores) / len(self._repetition_scores) if self._repetition_scores else 0.0
+
+ @property
+ def progress_reward(self) -> float:
+ remaining = 81 - self._initial_filled
+ if remaining > 0:
+ return (self._max_filled - self._initial_filled) / remaining
+ return 1.0
+
+ timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+ output_dir = Path(args.output_dir or f"outputs/sudoku-grpo-{sanitize_name(args.model_id)}-{timestamp}")
+
+ grpo_config = GRPOConfig(
+ use_vllm=True,
+ vllm_mode=args.vllm_mode,
+ vllm_server_base_url=args.vllm_server_url if args.vllm_mode == "server" else None,
+ vllm_gpu_memory_utilization=args.vllm_gpu_memory_utilization or 0.2,
+ output_dir=str(output_dir),
+ num_train_epochs=args.num_epochs,
+ learning_rate=args.learning_rate,
+ weight_decay=args.weight_decay,
+ gradient_accumulation_steps=args.gradient_accumulation_steps,
+ per_device_train_batch_size=args.per_device_batch_size,
+ warmup_steps=args.warmup_steps,
+ num_generations=args.num_generations,
+ max_completion_length=args.max_completion_length,
+ logging_steps=args.logging_steps,
+ save_strategy="steps",
+ save_steps=args.save_interval,
+ save_total_limit=args.save_total_limit,
+ temperature=args.temperature,
+ top_k=args.top_k,
+ top_p=args.top_p,
+ report_to="trackio",
+ log_completions=True,
+ num_completions_to_print=1,
+ chat_template_kwargs={"enable_thinking": False},
+ )
+
+ grpo_config.run_name = args.run_name or f"run-{timestamp}"
+ grpo_config.project = args.project or f"group-{sanitize_name(args.model_id)}"
+ grpo_config.trackio_space_id = args.trackio_space_id
+ grpo_config.gradient_checkpointing = args.gradient_checkpointing
+
+ peft_config = None
+ if args.use_lora:
+ from peft import LoraConfig
+
+ peft_config = LoraConfig(r=args.lora_r, lora_alpha=args.lora_alpha, task_type="CAUSAL_LM")
+
+ trainer = GRPOTrainer(
+ model=args.model_id,
+ reward_funcs=[
+ reward_empty_cell, # Learn to pick empty cells
+ reward_valid_moves, # Learn valid numbers
+ reward_repetition, # Penalize repeating moves
+ reward_progress, # Reward filling more cells
+ reward_correct, # Solve the puzzle
+ ],
+ peft_config=peft_config,
+ train_dataset=dataset,
+ args=grpo_config,
+ environment_factory=SudokuEnv,
+ callbacks=[RichProgressCallback()],
+ )
+
+ print(f"Starting GRPO training: {args.num_generations} generations, {args.max_turns} max turns")
+ trainer.train()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/sudoku_prompt.txt b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/sudoku_prompt.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d94ac4d3e93da0671a6e42c9e474291c88f82477
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/sudoku_prompt.txt
@@ -0,0 +1,122 @@
+You are an expert Sudoku player with deep knowledge of logical deduction strategies and number placement techniques.
+
+## GAME RULES
+
+1. The puzzle is a 9x9 grid divided into nine 3x3 subgrids (boxes)
+2. Some cells are pre-filled with numbers 1-9
+3. You must fill in the empty cells (shown as '.') with numbers 1-9
+4. Each row must contain numbers 1-9 without repetition
+5. Each column must contain numbers 1-9 without repetition
+6. Each 3x3 subgrid must contain numbers 1-9 without repetition
+7. You cannot overwrite pre-filled cells
+8. Invalid moves result in penalties (-1 reward)
+
+## HOW TO PLAY
+
+Use the `place` tool to make moves. The tool takes three arguments:
+- `row`: Row number (1-9)
+- `col`: Column number (1-9)
+- `number`: Number to place (1-9)
+
+## STRATEGIC APPROACH
+
+Do not repeat the same move twice.
+
+### Basic Strategies
+- **Naked Singles**: If a cell has only one possible candidate, fill it in immediately.
+- **Hidden Singles**: If a number can only go in one cell within a row, column, or box, place it there.
+- **Scanning**: Look at each row, column, and box to find where specific numbers can go.
+
+### Intermediate Strategies
+- **Naked Pairs/Triples**: When two/three cells in a unit contain only the same candidates, eliminate those from other cells.
+- **Hidden Pairs/Triples**: When numbers only appear in specific cells within a unit, those cells can only contain those numbers.
+- **Pointing Pairs**: When a candidate in a box is restricted to a single row/column, eliminate it elsewhere.
+
+### Solving Process
+1. Start by scanning the entire grid to identify easy fills (cells with few candidates)
+2. Look for rows, columns, or boxes with many numbers already placed
+3. Fill all naked singles first
+4. Then look for hidden singles in each row, column, and box
+5. Apply more advanced techniques as needed
+
+### Common Pitfalls to Avoid
+- Don't guess randomly - Sudoku is pure logic
+- Don't overlook any constraint (row, column, or box)
+- Don't try to overwrite pre-filled cells
+- Don't place invalid numbers (must be 1-9)
+- Don't use invalid coordinates (must be 1-9)
+- Don't repeat a move that was already made
+
+## EXAMPLES
+
+### Example 1: Naked Single
+If row 3, column 4 can only contain the number 5:
+→ call `place(row=3, col=4, number=5)`
+
+### Example 2: Hidden Single
+If the number 8 can only go in one cell in row 1:
+→ call `place(row=1, col=7, number=8)`
+
+### Example 3: Row Analysis
+Row 2 is missing only value 5, and column 8 is the empty cell:
+→ call `place(row=2, col=8, number=5)`
+
+### Example 4: Box Analysis
+In the center box, only one cell can contain 9:
+→ call `place(row=5, col=5, number=9)`
+
+## BOARD READING
+
+The board is displayed as a 9x9 grid:
+- Numbers 1-9 are pre-filled or already placed
+- Empty cells are shown as '.'
+- Rows are labeled R1-R9 (top to bottom)
+- Columns are labeled C1-C9 (left to right)
+
+Example board representation:
+```
+ C1 C2 C3 C4 C5 C6 C7 C8 C9
+R1 . 8 9 | 1 . . | . 3 7
+R2 2 7 1 | 9 4 3 | 6 . 8
+R3 . 6 5 | . 2 7 | 4 9 .
+ - - - - - - - - - - - - - - - -
+R4 . . . | 7 8 . | 9 2 3
+R5 . 9 2 | . 5 6 | . . 4
+R6 7 3 8 | . . 2 | 1 . .
+ - - - - - - - - - - - - - - - -
+R7 8 4 . | . . 9 | 5 . .
+R8 5 . . | 6 . 8 | 3 4 9
+R9 9 . 6 | 5 3 4 | 8 7 2
+```
+
+## COORDINATE REFERENCE
+
+Row indices (top to bottom): 1, 2, 3, 4, 5, 6, 7, 8, 9
+Column indices (left to right): 1, 2, 3, 4, 5, 6, 7, 8, 9
+
+Subgrid layout:
+```
+Subgrid 1 | Subgrid 2 | Subgrid 3
+ (R1-R3) (R1-R3) (R1-R3)
+ (C1-C3) (C4-C6) (C7-C9)
+----------+-----------+----------
+Subgrid 4 | Subgrid 5 | Subgrid 6
+ (R4-R6) (R4-R6) (R4-R6)
+ (C1-C3) (C4-C6) (C7-C9)
+----------+-----------+----------
+Subgrid 7 | Subgrid 8 | Subgrid 9
+ (R7-R9) (R7-R9) (R7-R9)
+ (C1-C3) (C4-C6) (C7-C9)
+```
+
+## IMPORTANT CONSTRAINTS
+
+- Coordinates are 1-indexed (1-9 for both row and column)
+- Numbers must be 1-9
+- One move per tool call
+- Must be a valid move (no rule violations)
+- Never repeat a previous move
+
+## YOUR GOAL
+
+Use ONLY the `place` tool to fill in empty cells one at a time. No explanation, no reasoning, just the `place`.
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/wordle.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/wordle.py
new file mode 100644
index 0000000000000000000000000000000000000000..6aa6a8de98b60b84e604e21d945262543e69c818
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openenv/wordle.py
@@ -0,0 +1,277 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "trackio",
+# "openenv-textarena @ git+https://huggingface.co/spaces/openenv/wordle",
+# ]
+# ///
+
+
+"""
+Simple script to run GRPO training with OpenEnv's Wordle environment and vLLM.
+
+Setup (Option A - Install from HF Space, recommended):
+
+```sh
+uv pip install git+https://huggingface.co/spaces/openenv/wordle
+```
+
+# Option 1: HF Spaces + Colocated vLLM (1 GPU required)
+```sh
+python examples/scripts/openenv/wordle.py --vllm-mode colocate
+```
+
+# Option 2: HF Spaces + Separate vLLM server (2 GPUs required)
+
+# Spin up vLLM server (Terminal 1)
+```sh
+CUDA_VISIBLE_DEVICES=0 trl vllm-serve --model Qwen/Qwen3-1.7B --host 0.0.0.0 --port 8000
+```
+
+# Run training (Terminal 2)
+```sh
+CUDA_VISIBLE_DEVICES=1 python examples/scripts/openenv/wordle.py --vllm-mode server --vllm-server-url http://localhost:8000
+```
+
+# Option 3: Local Environment + Colocated vLLM (1 GPU required)
+
+To run the Wordle environment locally, you have several options:
+
+## Option 3a: Using Docker Image (Recommended)
+
+First, build the Docker image from the textarena_env directory:
+```sh
+cd 3rd_party/OpenEnv/envs/textarena_env
+docker build -t textarena-env:latest -f server/Dockerfile .
+```
+
+Then run the environment server:
+```sh
+docker run -d -p 8001:8001 textarena-env:latest
+```
+
+Finally, run training pointing to local server:
+```sh
+python examples/scripts/openenv/wordle.py --vllm-mode colocate --env-url http://localhost:8001
+```
+
+## Option 3b: Running Server Directly
+
+From the textarena_env directory:
+```sh
+cd 3rd_party/OpenEnv/envs/textarena_env
+uv venv && source .venv/bin/activate
+uv pip install -e .
+python -m uvicorn server.app:app --reload --port 8001
+```
+
+Then in another terminal, run training:
+```sh
+python examples/scripts/openenv/wordle.py --vllm-mode colocate --env-url http://localhost:8001
+```
+
+## Option 3c: Using Pre-built HF Space Image
+
+```sh
+docker run -d -p 8001:8001 registry.hf.space/burtenshaw-wordle:latest
+python examples/scripts/openenv/wordle.py --vllm-mode colocate --env-url http://localhost:8001
+```
+"""
+
+import argparse
+
+from datasets import Dataset
+from textarena_env import TextArenaAction, TextArenaEnv
+
+from trl import GRPOConfig, GRPOTrainer, RichProgressCallback
+
+
+def parse_args() -> argparse.Namespace:
+ parser = argparse.ArgumentParser(
+ description="Run GRPO training for Wordle using the TextArena OpenEnv environment."
+ )
+ parser.add_argument(
+ "--model",
+ type=str,
+ default="Qwen/Qwen3-1.7B",
+ help="Model identifier passed to GRPOTrainer for fine-tuning.",
+ )
+ parser.add_argument(
+ "--env-url",
+ type=str,
+ default="https://openenv-wordle.hf.space",
+ help="URL for the environment server.",
+ )
+ parser.add_argument(
+ "--dataset-size",
+ type=int,
+ default=1000,
+ help="Number of entries to include in the synthetic training dataset.",
+ )
+ parser.add_argument(
+ "--num-generations",
+ type=int,
+ default=4,
+ help="Number of rollout generations per dataset prompt.",
+ )
+ parser.add_argument(
+ "--num-epochs",
+ type=int,
+ default=1,
+ help="Number of training epochs.",
+ )
+ parser.add_argument(
+ "--learning-rate",
+ type=float,
+ default=1e-6,
+ help="Learning rate for GRPO training.",
+ )
+ parser.add_argument(
+ "--gradient-accumulation-steps",
+ type=int,
+ default=64,
+ help="Gradient accumulation steps for GRPO training.",
+ )
+ parser.add_argument(
+ "--logging-steps",
+ type=int,
+ default=1,
+ help="Frequency of logging steps for GRPO training.",
+ )
+ parser.add_argument(
+ "--output-dir",
+ type=str,
+ default=None,
+ help="Directory where training outputs and checkpoints are stored.",
+ )
+ parser.add_argument(
+ "--trackio-space-id",
+ type=str,
+ default="wordle-grpo",
+ help="Trackio space identifier.",
+ )
+ parser.add_argument(
+ "--vllm-mode",
+ choices=("colocate", "server"),
+ default="colocate",
+ help="vLLM execution mode: 'colocate' or 'server'.",
+ )
+ parser.add_argument(
+ "--vllm-server-url",
+ type=str,
+ default="http://localhost:8000",
+ help="URL for the vLLM server (only used when --vllm-mode=server).",
+ )
+ return parser.parse_args()
+
+
+prompt = """You are an expert Wordle solver with deep knowledge of English vocabulary, letter frequency patterns, and optimal guessing strategies.
+
+Follow these rules to play Wordle:
+
+1. The target is a 5-letter English word
+2. You have 6 attempts to guess the correct word
+3. After each guess, you receive color-coded feedback:
+ - GREEN (G): Letter is correct and in the correct position
+ - YELLOW (Y): Letter is in the word but in the wrong position
+ - GRAY (X): Letter is not in the word at all
+4. All guesses must be valid 5-letter English words
+5. You cannot reuse a word you've already guessed
+6. Use the tool `guess` to make a guess.
+"""
+
+
+def reward_func(environments, **kwargs) -> list[float]:
+ return [env.reward for env in environments]
+
+
+def main() -> None:
+ args = parse_args()
+
+ env_url = args.env_url
+
+ class WordleEnv:
+ def __init__(self):
+ self.client = TextArenaEnv(base_url=env_url)
+
+ def reset(self, **kwargs) -> str | None:
+ result = self.client.reset()
+ # The game returns cumulative feedback each turn (new text appended at the end), so
+ # we store the previous full response and slice out only the newly appended part.
+ self._last_full_feedback = result.observation.messages[0].content
+ self.reward = 0.0
+ self.done = False
+ return self._last_full_feedback
+
+ def guess(self, guess: str) -> str:
+ """
+ Make a guess in the Wordle environment.
+
+ Args:
+ guess: The guessed word, formatted as '[abcde]'
+
+ Returns:
+ The feedback message from the environment.
+ """
+ if self.done:
+ raise ValueError("Game over.")
+ result = self.client.step(TextArenaAction(message=guess))
+ _full_feedback = result.observation.messages[0].content
+ # Just take the new feedback since the last guess, which is the part appended to the end of the full feedback
+ feedback = _full_feedback[len(self._last_full_feedback) :]
+ self._last_full_feedback = _full_feedback
+ # For some reason, the environment doesn't penalize invalid moves and just returns the last reward.
+ # We check the feedback for the invalid move message and penalize it if found.
+ if "You attempted an invalid move" in feedback:
+ self.reward = 0.0
+ else:
+ self.reward = result.reward
+ self.done = result.done
+ return feedback
+
+ output_dir = args.output_dir or f"{args.model.split('/')[-1]}-wordle-GRPO"
+ dataset = Dataset.from_dict({"prompt": [[{"role": "user", "content": prompt}] for _ in range(args.dataset_size)]})
+
+ trainer = GRPOTrainer(
+ model=args.model,
+ reward_funcs=reward_func,
+ train_dataset=dataset,
+ args=GRPOConfig(
+ output_dir=output_dir,
+ use_vllm=True,
+ vllm_mode=args.vllm_mode,
+ vllm_server_base_url=args.vllm_server_url if args.vllm_mode == "server" else None,
+ report_to="trackio",
+ trackio_space_id=args.trackio_space_id,
+ log_completions=True,
+ num_completions_to_print=2,
+ logging_steps=args.logging_steps,
+ num_train_epochs=args.num_epochs,
+ num_generations=args.num_generations,
+ learning_rate=args.learning_rate,
+ gradient_accumulation_steps=args.gradient_accumulation_steps,
+ chat_template_kwargs={"enable_thinking": False},
+ max_completion_length=1024,
+ ),
+ environment_factory=WordleEnv,
+ callbacks=[RichProgressCallback()],
+ )
+ trainer.train()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openreward/seta.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openreward/seta.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e31d86d1764755245d292ab82e802806d84de3f
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/openreward/seta.py
@@ -0,0 +1,127 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = ["trl[vllm,openreward]"]
+# ///
+
+"""GRPO training against the SETA ORS environment.
+
+Defaults target ``Eigent/SETA`` on the openreward.ai catalog (requires
+``OPENREWARD_API_KEY``). Pass ``--target https://...hf.space`` to point
+at a self-hosted Space.
+
+Usage (colocate vLLM, single-node):
+
+```sh
+accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero2.yaml \
+ --num_processes 4 \
+ examples/scripts/openreward/seta.py \
+ --vllm-mode colocate
+```
+
+Usage (server vLLM, single-node 2+2 GPU split):
+
+```sh
+# Terminal 1 — vLLM
+CUDA_VISIBLE_DEVICES=2,3 trl vllm-serve --model Qwen/Qwen3-4B \
+ --tensor-parallel-size 2 --port 8000
+
+# Terminal 2 — training
+CUDA_VISIBLE_DEVICES=0,1 accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero2.yaml \
+ --num_processes 2 \
+ examples/scripts/openreward/seta.py \
+ --vllm-mode server --vllm-server-base-url http://localhost:8000
+```
+"""
+
+import argparse
+
+from trl import GRPOConfig, GRPOTrainer
+from trl.experimental.openreward import OpenRewardSpec
+
+
+def parse_args() -> argparse.Namespace:
+ parser = argparse.ArgumentParser(description="GRPO training against the SETA ORS environment.")
+
+ parser.add_argument("--model", type=str, default="Qwen/Qwen3-4B")
+ parser.add_argument(
+ "--target",
+ type=str,
+ default="Eigent/SETA",
+ help="ORS env target — either a catalog name (e.g. 'Eigent/SETA') or a URL "
+ "(e.g. 'https://you-seta.hf.space').",
+ )
+ parser.add_argument("--split", type=str, default="train")
+ parser.add_argument("--num-tasks", type=int, default=64)
+
+ parser.add_argument("--learning-rate", type=float, default=5e-7)
+ parser.add_argument("--per-device-train-batch-size", type=int, default=1)
+ parser.add_argument("--gradient-accumulation-steps", type=int, default=1)
+ parser.add_argument("--num-generations", type=int, default=2)
+ parser.add_argument("--max-completion-length", type=int, default=2048)
+ parser.add_argument("--max-steps", type=int, default=5)
+ parser.add_argument("--max-tool-calling-iterations", type=int, default=20)
+
+ parser.add_argument("--vllm-mode", choices=("colocate", "server"), default="colocate")
+ parser.add_argument("--vllm-server-base-url", type=str, default="http://localhost:8000")
+ parser.add_argument("--vllm-gpu-memory-utilization", type=float, default=0.3)
+
+ parser.add_argument("--output-dir", type=str, default=None)
+ parser.add_argument("--report-to", type=str, default="none")
+
+ return parser.parse_args()
+
+
+def main() -> None:
+ args = parse_args()
+
+ # One spec object — fans out into TRL's three slots.
+ spec = OpenRewardSpec(args.target, num_tasks=args.num_tasks, split=args.split)
+
+ config_kwargs: dict = dict(
+ learning_rate=args.learning_rate,
+ per_device_train_batch_size=args.per_device_train_batch_size,
+ gradient_accumulation_steps=args.gradient_accumulation_steps,
+ num_generations=args.num_generations,
+ max_completion_length=args.max_completion_length,
+ max_steps=args.max_steps,
+ max_tool_calling_iterations=args.max_tool_calling_iterations,
+ chat_template_kwargs={"enable_thinking": False},
+ log_completions=True,
+ use_vllm=True,
+ vllm_mode=args.vllm_mode,
+ report_to=[s.strip() for s in args.report_to.split(",") if s.strip() and s.strip() != "none"] or "none",
+ )
+ if args.output_dir:
+ config_kwargs["output_dir"] = args.output_dir
+ if args.vllm_mode == "colocate":
+ config_kwargs["vllm_gpu_memory_utilization"] = args.vllm_gpu_memory_utilization
+ else:
+ config_kwargs["vllm_server_base_url"] = args.vllm_server_base_url
+
+ trainer = GRPOTrainer(
+ model=args.model,
+ args=GRPOConfig(**config_kwargs),
+ train_dataset=spec.train_dataset,
+ environment_factory=spec.environment_factory,
+ reward_funcs=spec.reward_funcs,
+ )
+ trainer.train()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/orpo.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/orpo.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b562faf8b2a002917a1063aad8477b8b8c693d9
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/orpo.py
@@ -0,0 +1,102 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Run the ORPO training script with the following command with some example arguments.
+In general, the optimal configuration for ORPO will be similar to that of DPO without the need for a reference model:
+
+# regular:
+python examples/scripts/orpo.py \
+ --dataset_name trl-internal-testing/hh-rlhf-helpful-base-trl-style \
+ --model_name_or_path gpt2 \
+ --per_device_train_batch_size 4 \
+ --max_steps 1000 \
+ --learning_rate 8e-6 \
+ --gradient_accumulation_steps 1 \
+ --eval_steps 500 \
+ --output_dir "gpt2-aligned-orpo" \
+ --warmup_steps 150 \
+ --logging_first_step \
+ --no_remove_unused_columns
+
+# peft:
+python examples/scripts/orpo.py \
+ --dataset_name trl-internal-testing/hh-rlhf-helpful-base-trl-style \
+ --model_name_or_path gpt2 \
+ --per_device_train_batch_size 4 \
+ --max_steps 1000 \
+ --learning_rate 8e-5 \
+ --gradient_accumulation_steps 1 \
+ --eval_steps 500 \
+ --output_dir "gpt2-lora-aligned-orpo" \
+ --optim rmsprop \
+ --warmup_steps 150 \
+ --logging_first_step \
+ --no_remove_unused_columns \
+ --use_peft \
+ --lora_r 16 \
+ --lora_alpha 16
+"""
+
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser
+
+from trl import ModelConfig, ScriptArguments, get_peft_config
+from trl.experimental.orpo import ORPOConfig, ORPOTrainer
+
+
+if __name__ == "__main__":
+ parser = HfArgumentParser((ScriptArguments, ORPOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_into_dataclasses()
+
+ ################
+ # Model & Tokenizer
+ ################
+ model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path)
+ tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path)
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+
+ ################
+ # Dataset
+ ################
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+ ################
+ # Training
+ ################
+ trainer = ORPOTrainer(
+ model,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ processing_class=tokenizer,
+ peft_config=get_peft_config(model_args),
+ )
+
+ # train and save the model
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/ppo/ppo.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/ppo/ppo.py
new file mode 100644
index 0000000000000000000000000000000000000000..232ca7e038e9a0066c3042d1708bf2608a7d200c
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/ppo/ppo.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.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+import shutil
+
+import torch
+from accelerate import PartialState
+from datasets import load_dataset
+from transformers import (
+ AutoModelForCausalLM,
+ AutoModelForSequenceClassification,
+ AutoTokenizer,
+ HfArgumentParser,
+)
+
+from trl import ModelConfig, ScriptArguments, get_kbit_device_map, get_peft_config, get_quantization_config
+from trl.experimental.ppo import PPOConfig, PPOTrainer
+
+
+"""
+python -i examples/scripts/ppo/ppo.py \
+ --dataset_name trl-internal-testing/descriptiveness-sentiment-trl-style \
+ --dataset_train_split descriptiveness \
+ --output_dir pythia-1b-deduped-descriptiveness-sentiment-trl-style-ppo \
+ --per_device_train_batch_size 64 \
+ --gradient_accumulation_steps 1 \
+ --total_episodes 10000 \
+ --model_name_or_path EleutherAI/pythia-1b-deduped \
+ --missing_eos_penalty 1.0
+
+accelerate launch --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+ examples/scripts/ppo/ppo.py \
+ --dataset_name trl-internal-testing/descriptiveness-sentiment-trl-style \
+ --dataset_train_split descriptiveness \
+ --output_dir pythia-1b-deduped-descriptiveness-sentiment-trl-style-ppo \
+ --num_ppo_epochs 1 \
+ --num_mini_batches 1 \
+ --per_device_train_batch_size 1 \
+ --gradient_accumulation_steps 16 \
+ --total_episodes 10000 \
+ --model_name_or_path EleutherAI/pythia-1b-deduped \
+ --sft_model_path EleutherAI/pythia-1b-deduped \
+ --reward_model_path EleutherAI/pythia-1b-deduped \
+ --local_rollout_forward_batch_size 1 \
+ --missing_eos_penalty 1.0
+"""
+
+
+if __name__ == "__main__":
+ parser = HfArgumentParser((ScriptArguments, PPOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_into_dataclasses()
+ # remove output_dir if exists
+ shutil.rmtree(training_args.output_dir, ignore_errors=True)
+
+ ################
+ # Model & Tokenizer
+ ################
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ model_kwargs["device_map"] = get_kbit_device_map()
+ model_kwargs["quantization_config"] = quantization_config
+
+ tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path, padding_side="left")
+ tokenizer.add_special_tokens({"pad_token": "[PAD]"})
+ value_model = AutoModelForSequenceClassification.from_pretrained(
+ training_args.reward_model_path, num_labels=1, **model_kwargs
+ )
+ reward_model = AutoModelForSequenceClassification.from_pretrained(
+ training_args.reward_model_path, num_labels=1, **model_kwargs
+ )
+ policy = AutoModelForCausalLM.from_pretrained(training_args.sft_model_path, **model_kwargs)
+
+ peft_config = get_peft_config(model_args)
+ if peft_config is None:
+ ref_policy = AutoModelForCausalLM.from_pretrained(training_args.sft_model_path, **model_kwargs)
+ else:
+ ref_policy = None
+
+ ################
+ # Dataset
+ ################
+ dataset = load_dataset(
+ script_args.dataset_name, name=script_args.dataset_config, split=script_args.dataset_train_split
+ )
+ eval_samples = 100
+ train_dataset = dataset.select(range(len(dataset) - eval_samples))
+ eval_dataset = dataset.select(range(len(dataset) - eval_samples, len(dataset)))
+ dataset_text_field = "prompt"
+
+ def prepare_dataset(dataset, tokenizer):
+ """pre-tokenize the dataset before training; only collate during training"""
+
+ def tokenize(element):
+ outputs = tokenizer(
+ element[dataset_text_field],
+ padding=False,
+ )
+ return {"input_ids": outputs["input_ids"]}
+
+ return dataset.map(
+ tokenize,
+ batched=True,
+ remove_columns=dataset.column_names,
+ num_proc=training_args.dataset_num_proc,
+ )
+
+ # Compute that only on the main process for faster data processing.
+ # see: https://github.com/huggingface/trl/pull/1255
+ with PartialState().local_main_process_first():
+ train_dataset = prepare_dataset(train_dataset, tokenizer)
+ eval_dataset = prepare_dataset(eval_dataset, tokenizer)
+
+ ################
+ # Training
+ ################
+ trainer = PPOTrainer(
+ args=training_args,
+ processing_class=tokenizer,
+ model=policy,
+ ref_model=ref_policy,
+ reward_model=reward_model,
+ value_model=value_model,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ peft_config=peft_config,
+ )
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
+
+ trainer.generate_completions()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/ppo/ppo_tldr.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/ppo/ppo_tldr.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a1dff38276afe280eae4871e0fe2311905656fb
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/ppo/ppo_tldr.py
@@ -0,0 +1,168 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+import shutil
+
+import torch
+from accelerate import PartialState
+from datasets import load_dataset
+from transformers import (
+ AutoModelForCausalLM,
+ AutoModelForSequenceClassification,
+ AutoTokenizer,
+ HfArgumentParser,
+)
+
+from trl import ModelConfig, ScriptArguments, get_kbit_device_map, get_peft_config, get_quantization_config
+from trl.experimental.ppo import PPOConfig, PPOTrainer
+
+
+"""
+python examples/scripts/ppo/ppo_tldr.py \
+ --dataset_name trl-lib/tldr \
+ --dataset_test_split validation \
+ --output_dir pythia-1b-deduped-tldr-preference-sft-trl-style-ppo \
+ --per_device_train_batch_size 1 \
+ --gradient_accumulation_steps 64 \
+ --total_episodes 30000 \
+ --model_name_or_path EleutherAI/pythia-1b-deduped \
+ --sft_model_path cleanrl/EleutherAI_pythia-1b-deduped__sft__tldr \
+ --reward_model_path cleanrl/EleutherAI_pythia-1b-deduped__reward__tldr \
+ --missing_eos_penalty 1.0 \
+ --stop_token eos \
+ --response_length 53 \
+ --eval_strategy steps \
+ --eval_steps 100
+
+accelerate launch --config_file examples/accelerate_configs/deepspeed_zero2.yaml \
+ examples/scripts/ppo/ppo_tldr.py \
+ --dataset_name trl-lib/tldr \
+ --dataset_test_split validation \
+ --output_dir pythia-1b-deduped-tldr-preference-sft-trl-style-ppo \
+ --per_device_train_batch_size 16 \
+ --gradient_accumulation_steps 4 \
+ --total_episodes 1000000 \
+ --model_name_or_path EleutherAI/pythia-1b-deduped \
+ --sft_model_path cleanrl/EleutherAI_pythia-1b-deduped__sft__tldr \
+ --reward_model_path cleanrl/EleutherAI_pythia-1b-deduped__reward__tldr \
+ --local_rollout_forward_batch_size 16 \
+ --missing_eos_penalty 1.0 \
+ --stop_token eos \
+ --eval_strategy steps \
+ --eval_steps 100
+"""
+
+
+if __name__ == "__main__":
+ parser = HfArgumentParser((ScriptArguments, PPOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_into_dataclasses()
+ # remove output_dir if exists
+ shutil.rmtree(training_args.output_dir, ignore_errors=True)
+
+ ################
+ # Model & Tokenizer
+ ################
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ model_kwargs["device_map"] = get_kbit_device_map()
+ model_kwargs["quantization_config"] = quantization_config
+
+ tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path, padding_side="left")
+ tokenizer.add_special_tokens({"pad_token": "[PAD]"})
+ value_model = AutoModelForSequenceClassification.from_pretrained(
+ training_args.reward_model_path, num_labels=1, **model_kwargs
+ )
+ reward_model = AutoModelForSequenceClassification.from_pretrained(
+ training_args.reward_model_path,
+ num_labels=1,
+ **model_kwargs,
+ )
+ policy = AutoModelForCausalLM.from_pretrained(training_args.sft_model_path, **model_kwargs)
+
+ peft_config = get_peft_config(model_args)
+ if peft_config is None:
+ ref_policy = AutoModelForCausalLM.from_pretrained(training_args.sft_model_path, **model_kwargs)
+ else:
+ ref_policy = None
+
+ ################
+ # Dataset
+ ################
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+ train_dataset = dataset[script_args.dataset_train_split]
+ eval_dataset = dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None
+
+ def prepare_dataset(dataset, tokenizer):
+ """pre-tokenize the dataset before training; only collate during training"""
+
+ def tokenize(element):
+ input_ids = tokenizer(element["prompt"], padding=False)["input_ids"]
+ return {"input_ids": input_ids, "lengths": len(input_ids)}
+
+ return dataset.map(
+ tokenize,
+ remove_columns=dataset.column_names,
+ num_proc=training_args.dataset_num_proc,
+ )
+
+ # Compute that only on the main process for faster data processing.
+ # see: https://github.com/huggingface/trl/pull/1255
+ with PartialState().local_main_process_first():
+ train_dataset = prepare_dataset(train_dataset, tokenizer)
+ if eval_dataset is not None:
+ eval_dataset = prepare_dataset(eval_dataset, tokenizer)
+ # filtering
+ train_dataset = train_dataset.filter(lambda x: x["lengths"] <= 512, num_proc=training_args.dataset_num_proc)
+ if eval_dataset is not None:
+ eval_dataset = eval_dataset.filter(lambda x: x["lengths"] <= 512, num_proc=training_args.dataset_num_proc)
+
+ assert train_dataset[0]["input_ids"][-1] != tokenizer.eos_token_id, "The last token should not be an EOS token"
+
+ ################
+ # Training
+ ################
+ trainer = PPOTrainer(
+ args=training_args,
+ processing_class=tokenizer,
+ model=policy,
+ ref_model=ref_policy,
+ reward_model=reward_model,
+ value_model=value_model,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ peft_config=peft_config,
+ )
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
+
+ trainer.generate_completions()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/prm.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/prm.py
new file mode 100644
index 0000000000000000000000000000000000000000..14eb30e35938d8a018bb2c5ec6eb3eb4b32a9248
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/prm.py
@@ -0,0 +1,128 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Full training:
+python examples/scripts/prm.py \
+ --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
+ --dataset_name trl-lib/prm800k \
+ --output_dir Qwen2-0.5B-Reward \
+ --per_device_train_batch_size 8 \
+ --num_train_epochs 1 \
+ --learning_rate 1.0e-5 \
+ --eval_strategy steps \
+ --eval_steps 50
+
+LoRA:
+python examples/scripts/prm.py \
+ --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
+ --dataset_name trl-lib/prm800k \
+ --output_dir Qwen2-0.5B-Reward-LoRA \
+ --per_device_train_batch_size 8 \
+ --num_train_epochs 1 \
+ --learning_rate 1.0e-4 \
+ --eval_strategy steps \
+ --eval_steps 50
+ --use_peft \
+ --lora_r 32 \
+ --lora_alpha 16
+"""
+
+import torch
+from accelerate import logging
+from datasets import load_dataset
+from transformers import AutoModelForTokenClassification, AutoTokenizer, HfArgumentParser
+
+from trl import (
+ ModelConfig,
+ ScriptArguments,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+)
+from trl.experimental.prm import PRMConfig, PRMTrainer
+
+
+logger = logging.get_logger(__name__)
+
+
+if __name__ == "__main__":
+ parser = HfArgumentParser((ScriptArguments, PRMConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_into_dataclasses()
+
+ ################
+ # Model & Tokenizer
+ ################
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ use_cache=False if training_args.gradient_checkpointing else True,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ model_kwargs["device_map"] = get_kbit_device_map()
+ model_kwargs["quantization_config"] = quantization_config
+
+ tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path, use_fast=True)
+ model = AutoModelForTokenClassification.from_pretrained(
+ model_args.model_name_or_path, num_labels=2, **model_kwargs
+ )
+
+ if model_args.use_peft and model_args.lora_task_type != "TOKEN_CLS":
+ logger.warning(
+ "You are using a `task_type` that is different than `TOKEN_CLS` for PEFT. This will lead to silent bugs"
+ " Make sure to pass --lora_task_type TOKEN_CLS when using this script with PEFT.",
+ )
+
+ ##############
+ # Load dataset
+ ##############
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+ dataset = dataset.filter(lambda x: len(x["completions"]) > 0)
+
+ ##########
+ # Training
+ ##########
+ trainer = PRMTrainer(
+ model=model,
+ processing_class=tokenizer,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split],
+ peft_config=get_peft_config(model_args),
+ )
+ trainer.train()
+
+ ############################
+ # Save model and push to Hub
+ ############################
+ trainer.save_model(training_args.output_dir)
+ metrics = trainer.evaluate()
+ trainer.log_metrics("eval", metrics)
+ trainer.save_metrics("eval", metrics)
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/reward_modeling.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/reward_modeling.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba2093034be21f9be3ca764e9f230e9ff8acfaad
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/reward_modeling.py
@@ -0,0 +1,131 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Full training:
+python examples/scripts/reward_modeling.py \
+ --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
+ --dataset_name trl-lib/ultrafeedback_binarized \
+ --output_dir Qwen2-0.5B-Reward \
+ --per_device_train_batch_size 8 \
+ --num_train_epochs 1 \
+ --learning_rate 1.0e-5 \
+ --eval_strategy steps \
+ --eval_steps 50 \
+ --max_length 2048
+
+LoRA:
+python examples/scripts/reward_modeling.py \
+ --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
+ --dataset_name trl-lib/ultrafeedback_binarized \
+ --output_dir Qwen2-0.5B-Reward-LoRA \
+ --per_device_train_batch_size 8 \
+ --num_train_epochs 1 \
+ --learning_rate 1.0e-4 \
+ --eval_strategy steps \
+ --eval_steps 50 \
+ --max_length 2048 \
+ --use_peft \
+ --lora_task_type SEQ_CLS \
+ --lora_r 32 \
+ --lora_alpha 16
+"""
+
+import torch
+from accelerate import logging
+from datasets import load_dataset
+from transformers import AutoModelForSequenceClassification, HfArgumentParser
+
+from trl import (
+ ModelConfig,
+ RewardConfig,
+ RewardTrainer,
+ ScriptArguments,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+)
+
+
+logger = logging.get_logger(__name__)
+
+
+if __name__ == "__main__":
+ parser = HfArgumentParser((ScriptArguments, RewardConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_into_dataclasses()
+
+ ################
+ # Model & Tokenizer
+ ################
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ use_cache=False if training_args.gradient_checkpointing else True,
+ dtype=dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ model_kwargs["device_map"] = get_kbit_device_map()
+ model_kwargs["quantization_config"] = quantization_config
+
+ model = AutoModelForSequenceClassification.from_pretrained(
+ model_args.model_name_or_path, num_labels=1, **model_kwargs
+ )
+
+ if model_args.use_peft and model_args.lora_task_type != "SEQ_CLS":
+ logger.warning(
+ "You are using a `task_type` that is different than `SEQ_CLS` for PEFT. This will lead to silent bugs"
+ " Make sure to pass --lora_task_type SEQ_CLS when using this script with PEFT.",
+ )
+
+ ##############
+ # Load dataset
+ ##############
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+ ##########
+ # Training
+ ##########
+ trainer = RewardTrainer(
+ model=model,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ peft_config=get_peft_config(model_args),
+ )
+ trainer.train()
+
+ ############################
+ # Save model and push to Hub
+ ############################
+ trainer.save_model(training_args.output_dir)
+
+ if training_args.eval_strategy != "no":
+ metrics = trainer.evaluate()
+ trainer.log_metrics("eval", metrics)
+ trainer.save_metrics("eval", metrics)
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/rloo.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/rloo.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ed2cd0409780f835966f1746ce54b051ff15252
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/rloo.py
@@ -0,0 +1,99 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[vllm,peft]",
+# "math-verify",
+# "latex2sympy2_extended",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+NuminaMath example: RLOO on math dataset with vLLM.
+
+ pip install math_verify num2words==0.5.14 peft trackio vllm
+ export TRACKIO_PROJECT="RLOO-NuminaMath-TIR"
+ accelerate launch --config_file examples/accelerate_configs/deepspeed_zero3.yaml examples/scripts/rloo.py
+
+For TL;DR or other datasets with a reward model, use the generic script:
+ python -m trl.scripts.rloo --dataset_name trl-lib/tldr --reward_model_name_or_path ... --model_name_or_path ...
+"""
+
+import torch
+from datasets import load_dataset
+from peft import LoraConfig
+
+from trl import RLOOConfig, RLOOTrainer
+from trl.rewards import accuracy_reward, think_format_reward
+
+
+def main():
+ # Dataset
+ train_dataset, eval_dataset = load_dataset("AI-MO/NuminaMath-TIR", split=["train[:5%]", "test[:5%]"])
+
+ SYSTEM_PROMPT = (
+ "A conversation between user and assistant. The user asks a question, and the assistant solves it. The "
+ "assistant first thinks about the reasoning process in the mind and then provides the user with the answer. "
+ "The reasoning process and answer are enclosed within tags, i.e., \nThis is my "
+ "reasoning.\n\nThis is my answer."
+ )
+
+ def make_conversation(example):
+ return {
+ "prompt": [
+ {"role": "system", "content": SYSTEM_PROMPT},
+ {"role": "user", "content": example["problem"]},
+ ],
+ }
+
+ train_dataset = train_dataset.map(make_conversation, remove_columns=["messages", "problem"])
+ eval_dataset = eval_dataset.map(make_conversation, remove_columns=["messages", "problem"])
+
+ # Training
+ training_args = RLOOConfig(
+ output_dir="Qwen3-0.6B-RLOO",
+ model_init_kwargs={"dtype": torch.bfloat16},
+ learning_rate=1e-5,
+ log_completions=True,
+ num_completions_to_print=2,
+ max_completion_length=1024,
+ gradient_accumulation_steps=2,
+ steps_per_generation=8,
+ use_vllm=True,
+ vllm_mode="colocate",
+ vllm_gpu_memory_utilization=0.5,
+ run_name="Qwen3-0.6B-RLOO-NuminaMath-TIR",
+ )
+
+ trainer = RLOOTrainer(
+ model="Qwen/Qwen3-0.6B",
+ args=training_args,
+ reward_funcs=[think_format_reward, accuracy_reward],
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ peft_config=LoraConfig(),
+ )
+
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ trainer.push_to_hub(dataset_name="AI-MO/NuminaMath-TIR")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/rloo_vlm.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/rloo_vlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..87bcdc59752ac5183912a26b50ce1202e25e394b
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/rloo_vlm.py
@@ -0,0 +1,157 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "Pillow",
+# "math-verify",
+# "latex2sympy2_extended",
+# "torchvision",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+pip install math_verify
+
+# For Qwen/Qwen2.5-VL-3B-Instruct
+accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+ examples/scripts/rloo_vlm.py \
+ --model_name_or_path Qwen/Qwen2.5-VL-3B-Instruct \
+ --output_dir rloo-Qwen2.5-VL-3B-Instruct \
+ --learning_rate 1e-5 \
+ --dtype bfloat16 \
+ --max_completion_length 1024 \
+ --use_vllm \
+ --vllm_mode colocate \
+ --use_peft \
+ --lora_target_modules "q_proj", "v_proj" \
+ --log_completions
+
+# For HuggingFaceTB/SmolVLM2-2.2B-Instruct
+pip install num2words==0.5.14
+
+accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+ examples/scripts/rloo_vlm.py \
+ --model_name_or_path HuggingFaceTB/SmolVLM2-2.2B-Instruct \
+ --output_dir rloo-SmolVLM2-2.2B-Instruct \
+ --learning_rate 1e-5 \
+ --dtype bfloat16 \
+ --max_completion_length 1024 \
+ --use_peft \
+ --lora_target_modules "q_proj", "v_proj" \
+ --log_completions \
+ --per_device_train_batch_size 1 \
+ --gradient_accumulation_steps 2 \
+ --num_generations 2
+
+"""
+
+import torch
+from datasets import load_dataset
+
+from trl import (
+ ModelConfig,
+ RLOOConfig,
+ RLOOTrainer,
+ ScriptArguments,
+ TrlParser,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+)
+from trl.rewards import accuracy_reward, think_format_reward
+
+
+if __name__ == "__main__":
+ parser = TrlParser((ScriptArguments, RLOOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+ ################
+ # Model
+ ################
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+ training_args.model_init_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ training_args.model_init_kwargs["device_map"] = get_kbit_device_map()
+ training_args.model_init_kwargs["quantization_config"] = quantization_config
+
+ ################
+ # Dataset
+ ################
+ dataset = load_dataset("lmms-lab/multimodal-open-r1-8k-verified", split="train")
+ dataset = dataset.train_test_split(test_size=100, seed=42)
+
+ SYSTEM_PROMPT = (
+ "A conversation between user and assistant. The user asks a question, and the assistant solves it. The "
+ "assistant first thinks about the reasoning process in the mind and then provides the user with the answer. "
+ "The reasoning process and answer are enclosed within tags, i.e., \nThis is my "
+ "reasoning.\n\nThis is my answer."
+ )
+
+ def make_conversation(example):
+ prompt = [
+ {"role": "system", "content": SYSTEM_PROMPT},
+ {"role": "user", "content": example["problem"]},
+ ]
+ return {"prompt": prompt}
+
+ dataset = dataset.map(make_conversation)
+
+ # Filter have big images
+ def filter_big_images(example):
+ image = example["image"]
+ return image.size[0] < 512 and image.size[1] < 512
+
+ dataset = dataset.filter(filter_big_images)
+
+ def convert_to_rgb(example):
+ image = example["image"]
+ if image.mode != "RGB":
+ image = image.convert("RGB")
+ example["image"] = image
+ return example
+
+ dataset = dataset.map(convert_to_rgb)
+
+ train_dataset = dataset["train"]
+ eval_dataset = dataset["test"] if training_args.eval_strategy != "no" else None
+
+ ################
+ # Training
+ ################
+ trainer = RLOOTrainer(
+ model=model_args.model_name_or_path,
+ args=training_args,
+ reward_funcs=[think_format_reward, accuracy_reward],
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ peft_config=get_peft_config(model_args),
+ )
+
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sdft.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sdft.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0ad341270c0a0117b0558df369f5f48352ebc15
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sdft.py
@@ -0,0 +1,428 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "peft",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Small-scale SDFT training with Qwen/Qwen3.5-0.8B.
+
+Expected dataset formats:
+
+1. Native TRL self-distillation format:
+ - `prompt`
+ - `privileged_context` containing only the extra teacher-only information
+
+2. Demonstration-based format:
+ - `prompt`
+ - `golden_response`
+
+Example:
+
+```bash
+python examples/scripts/sdft.py \
+ --model_name_or_path Qwen/Qwen3.5-0.8B \
+ --dataset_name your-org/your-dataset \
+ --output_dir outputs/sdft-qwen3.5-0.8b \
+ --per_device_train_batch_size 1 \
+ --gradient_accumulation_steps 16 \
+ --learning_rate 2e-5 \
+ --max_prompt_length 1024 \
+ --max_completion_length 512 \
+ --teacher_model_kind ema \
+ --teacher_sync_steps 1 \
+ --teacher_update_rate 0.01 \
+ --eval_strategy steps \
+ --eval_steps 50 \
+ --report_to wandb
+```
+"""
+
+import json
+import os
+import re
+from dataclasses import dataclass, field
+from string import Template
+from typing import Any
+
+import torch
+from datasets import DatasetDict, load_dataset, load_from_disk
+from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig
+
+from trl import (
+ LogCompletionsCallback,
+ ModelConfig,
+ ScriptArguments,
+ TrlParser,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+)
+from trl.data_utils import maybe_apply_chat_template
+from trl.experimental.sdft import SDFTConfig, SDFTTrainer
+from trl.models import unwrap_model_for_generation
+
+
+DEFAULT_DEMONSTRATION_TEMPLATE = Template("""Example response: $output_text""")
+
+
+@dataclass
+class SDFTScriptArguments(ScriptArguments):
+ dataset_path: str | None = field(
+ default=None,
+ metadata={"help": "Optional local dataset path to load with `load_from_disk`. Overrides `dataset_name`."},
+ )
+ privileged_context_column: str = field(
+ default="privileged_context",
+ metadata={"help": "Column containing precomputed privileged context for SDFT."},
+ )
+ golden_response_column: str = field(
+ default="golden_response",
+ metadata={"help": "Column containing demonstration responses used to build privileged context."},
+ )
+ eval_num_prompts: int | None = field(
+ default=8,
+ metadata={"help": "Number of prompts to log during evaluation. Set to 0 to disable completion logging."},
+ )
+ demonstration_template: str = field(
+ default=DEFAULT_DEMONSTRATION_TEMPLATE.template,
+ metadata={"help": "Template used to build privileged context from demonstration content."},
+ )
+ tool_eval_num_examples: int | None = field(
+ default=None,
+ metadata={
+ "help": "Optional number of eval examples to score for tool-use metrics. Defaults to the full eval split."
+ },
+ )
+ tool_eval_max_new_tokens: int = field(
+ default=256,
+ metadata={"help": "Maximum completion length for task evaluation generation."},
+ )
+
+
+def _extract_prompt_text(prompt: Any) -> str:
+ if isinstance(prompt, str):
+ return prompt
+ if isinstance(prompt, list) and prompt and isinstance(prompt[0], dict):
+ for message in reversed(prompt):
+ if message.get("role") == "user":
+ content = message.get("content", "")
+ if isinstance(content, list):
+ return " ".join(part.get("text", "") for part in content if part.get("type") == "text")
+ return content
+ return str(prompt)
+
+
+def _stringify_golden_response(response: Any) -> str:
+ if isinstance(response, str):
+ return response
+ if isinstance(response, list):
+ return "\n".join(_stringify_golden_response(item) for item in response)
+ return str(response)
+
+
+def _build_privileged_context(
+ example: dict[str, Any], privileged_context_column: str, golden_response_column: str, template: Template
+):
+ if privileged_context_column in example and example[privileged_context_column] is not None:
+ privileged_context = example[privileged_context_column]
+ elif golden_response_column in example:
+ privileged_context = template.safe_substitute(
+ orig_content=_extract_prompt_text(example["prompt"]),
+ output_text=_stringify_golden_response(example[golden_response_column]),
+ )
+ elif "teacher_prompt" in example:
+ raise ValueError(
+ "Datasets for `trl.experimental.sdft` should provide `privileged_context` or `golden_response`, not "
+ "`teacher_prompt`."
+ )
+ else:
+ raise ValueError("Dataset must contain either `privileged_context` or `golden_response` alongside `prompt`.")
+
+ return {
+ "prompt": example["prompt"],
+ "privileged_context": privileged_context,
+ }
+
+
+def _prepare_split(dataset, script_args: SDFTScriptArguments):
+ template = Template(script_args.demonstration_template)
+ return dataset.map(
+ lambda example: _build_privileged_context(
+ example,
+ privileged_context_column=script_args.privileged_context_column,
+ golden_response_column=script_args.golden_response_column,
+ template=template,
+ ),
+ remove_columns=dataset.column_names,
+ )
+
+
+def _can_prepare_privileged_context(dataset) -> bool:
+ columns = set(dataset.column_names)
+ return "prompt" in columns and ("privileged_context" in columns or "golden_response" in columns)
+
+
+def _extract_action_and_input(text: str) -> tuple[str | None, str | None]:
+ action_match = re.search(r"Action:\s*([^\n]+)", text)
+ action_input_match = re.search(r"Action Input:\s*(.*)", text, flags=re.DOTALL)
+ action = action_match.group(1).strip() if action_match else None
+ action_input = action_input_match.group(1).strip() if action_input_match else None
+ return action, action_input
+
+
+def _parse_json_object(text: str | None) -> tuple[bool, Any]:
+ if text is None:
+ return False, None
+ text = text.strip()
+ if text.startswith("```"):
+ text = re.sub(r"^```(?:json)?\s*", "", text)
+ text = re.sub(r"\s*```$", "", text)
+ try:
+ return True, json.loads(text)
+ except Exception:
+ return False, None
+
+
+def _normalize_gold_answer(example: dict[str, Any]) -> tuple[str | None, Any]:
+ answers = example.get("golden_answer") or []
+ if not answers:
+ return None, None
+ answer = answers[0]
+ action = answer.get("Action")
+ valid_json, action_input = _parse_json_object(answer.get("Action_Input"))
+ return action, action_input if valid_json else answer.get("Action_Input")
+
+
+def _apply_prompt_template(tokenizer, prompt: Any) -> str:
+ return maybe_apply_chat_template({"prompt": prompt}, tokenizer)["prompt"]
+
+
+def _run_tooluse_eval(
+ trainer: SDFTTrainer,
+ eval_dataset,
+ max_new_tokens: int,
+ num_examples: int | None = None,
+ metric_prefix: str = "tool_eval",
+) -> dict[str, float]:
+ if num_examples is not None:
+ eval_dataset = eval_dataset.select(range(min(num_examples, len(eval_dataset))))
+
+ prompts = eval_dataset["prompt"]
+ prompt_texts = [_apply_prompt_template(trainer.processing_class, prompt) for prompt in prompts]
+ tokenized = trainer.processing_class(
+ text=prompt_texts,
+ return_tensors="pt",
+ padding=True,
+ padding_side="left",
+ truncation=True,
+ max_length=trainer.max_prompt_length,
+ add_special_tokens=False,
+ )
+ tokenized = {key: value.to(trainer.accelerator.device) for key, value in tokenized.items()}
+
+ with (
+ unwrap_model_for_generation(
+ trainer.model_wrapped,
+ trainer.accelerator,
+ gather_deepspeed3_params=trainer.args.ds3_gather_for_generation,
+ ) as unwrapped_model,
+ torch.no_grad(),
+ ):
+ generated = unwrapped_model.generate(
+ **tokenized,
+ max_new_tokens=max_new_tokens,
+ do_sample=False,
+ pad_token_id=trainer.processing_class.pad_token_id,
+ eos_token_id=trainer.processing_class.eos_token_id,
+ )
+
+ prompt_length = tokenized["input_ids"].shape[1]
+ completions = trainer.processing_class.batch_decode(generated[:, prompt_length:], skip_special_tokens=True)
+
+ action_correct = 0
+ json_valid = 0
+ full_match = 0
+ parsed_action_present = 0
+ records = []
+
+ for example, completion in zip(eval_dataset, completions, strict=True):
+ pred_action, pred_action_input_text = _extract_action_and_input(completion)
+ if pred_action is not None:
+ parsed_action_present += 1
+ pred_json_valid, pred_action_input = _parse_json_object(pred_action_input_text)
+ if pred_json_valid:
+ json_valid += 1
+
+ gold_action, gold_action_input = _normalize_gold_answer(example)
+ is_action_correct = pred_action == gold_action and gold_action is not None
+ if is_action_correct:
+ action_correct += 1
+ is_full_match = is_action_correct and pred_json_valid and pred_action_input == gold_action_input
+ if is_full_match:
+ full_match += 1
+
+ records.append(
+ {
+ "prompt": _extract_prompt_text(example["prompt"]),
+ "completion": completion,
+ "pred_action": pred_action,
+ "pred_action_input_text": pred_action_input_text,
+ "gold_action": gold_action,
+ "gold_action_input": gold_action_input,
+ "action_correct": is_action_correct,
+ "json_valid": pred_json_valid,
+ "full_match": is_full_match,
+ }
+ )
+
+ total = max(len(eval_dataset), 1)
+ metrics = {
+ f"{metric_prefix}/action_present_rate": parsed_action_present / total,
+ f"{metric_prefix}/valid_json_rate": json_valid / total,
+ f"{metric_prefix}/action_accuracy": action_correct / total,
+ f"{metric_prefix}/tool_call_accuracy": full_match / total,
+ }
+
+ sample_path = os.path.join(trainer.args.output_dir, f"{metric_prefix}_samples.json")
+ os.makedirs(trainer.args.output_dir, exist_ok=True)
+ with open(sample_path, "w") as f:
+ json.dump(records[: min(20, len(records))], f, indent=2)
+
+ return metrics
+
+
+if __name__ == "__main__":
+ parser = TrlParser((SDFTScriptArguments, SDFTConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+
+ if model_args.model_name_or_path is None:
+ raise ValueError("`model_name_or_path` is required.")
+ if model_args.dtype in ["auto", None]:
+ if training_args.bf16:
+ dtype = torch.bfloat16
+ elif training_args.fp16:
+ dtype = torch.float16
+ else:
+ dtype = "auto"
+ else:
+ dtype = getattr(torch, model_args.dtype)
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ model_kwargs["device_map"] = get_kbit_device_map()
+ model_kwargs["quantization_config"] = quantization_config
+
+ training_args.model_init_kwargs = model_kwargs
+
+ tokenizer = AutoTokenizer.from_pretrained(
+ model_args.model_name_or_path, revision=model_args.model_revision, padding_side="left"
+ )
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+
+ if script_args.dataset_path is not None:
+ dataset = load_from_disk(script_args.dataset_path)
+ else:
+ dataset = load_dataset(
+ script_args.dataset_name,
+ name=script_args.dataset_config,
+ streaming=script_args.dataset_streaming,
+ )
+
+ if not isinstance(dataset, DatasetDict):
+ raise ValueError("SDFT example expects a dataset with named splits.")
+
+ train_dataset = _prepare_split(dataset[script_args.dataset_train_split], script_args)
+ raw_eval_dataset = dataset[script_args.dataset_test_split] if script_args.dataset_test_split in dataset else None
+ eval_dataset = None
+ if (
+ training_args.eval_strategy != "no"
+ and raw_eval_dataset is not None
+ and _can_prepare_privileged_context(raw_eval_dataset)
+ ):
+ eval_dataset = _prepare_split(raw_eval_dataset, script_args)
+
+ model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path, **model_kwargs)
+ model.config.use_cache = False if training_args.gradient_checkpointing else True
+
+ trainer = SDFTTrainer(
+ model=model,
+ args=training_args,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=tokenizer,
+ peft_config=get_peft_config(model_args),
+ )
+
+ if eval_dataset is not None and script_args.eval_num_prompts:
+ generation_config = GenerationConfig(
+ max_new_tokens=training_args.max_completion_length,
+ do_sample=True,
+ temperature=training_args.temperature,
+ )
+ trainer.add_callback(
+ LogCompletionsCallback(trainer, generation_config, num_prompts=script_args.eval_num_prompts)
+ )
+
+ pretrain_metrics = None
+ if raw_eval_dataset is not None and "golden_answer" in raw_eval_dataset.column_names:
+ pretrain_metrics = _run_tooluse_eval(
+ trainer,
+ raw_eval_dataset,
+ max_new_tokens=script_args.tool_eval_max_new_tokens,
+ num_examples=script_args.tool_eval_num_examples,
+ metric_prefix="tool_eval_before",
+ )
+ trainer.log(pretrain_metrics)
+ trainer.log_metrics("eval", pretrain_metrics)
+ trainer.save_metrics("eval", pretrain_metrics)
+
+ trainer.train()
+
+ trainer.save_model(training_args.output_dir)
+ if eval_dataset is not None:
+ metrics = trainer.evaluate()
+ trainer.log_metrics("eval", metrics)
+ trainer.save_metrics("eval", metrics)
+ if raw_eval_dataset is not None and "golden_answer" in raw_eval_dataset.column_names:
+ post_metrics = _run_tooluse_eval(
+ trainer,
+ raw_eval_dataset,
+ max_new_tokens=script_args.tool_eval_max_new_tokens,
+ num_examples=script_args.tool_eval_num_examples,
+ metric_prefix="tool_eval_after",
+ )
+ if pretrain_metrics is not None:
+ for key, value in pretrain_metrics.items():
+ after_key = key.replace("tool_eval_before/", "tool_eval_after/")
+ if after_key in post_metrics:
+ delta_name = after_key.replace("tool_eval_after/", "tool_eval_delta/")
+ post_metrics[delta_name] = post_metrics[after_key] - value
+ trainer.log(post_metrics)
+ trainer.log_metrics("eval", post_metrics)
+ trainer.save_metrics("eval", post_metrics)
+
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name or script_args.dataset_path)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sdpo.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sdpo.py
new file mode 100644
index 0000000000000000000000000000000000000000..098b9f3f6803eaad466af0bee76125c47fc38d3b
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sdpo.py
@@ -0,0 +1,390 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "peft",
+# "math-verify",
+# "latex2sympy2_extended",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Usage:
+
+```bash
+python examples/scripts/sdpo.py \
+ --model_name_or_path Qwen/Qwen2.5-Math-1.5B-Instruct \
+ --dataset_name openai/gsm8k \
+ --dataset_config main \
+ --output_dir outputs/sdpo-qwen35-2b-gsm8k \
+ --learning_rate 5e-5 \
+ --dtype bfloat16 \
+ --bf16 true \
+ --max_completion_length 128 \
+ --use_peft \
+ --lora_target_modules q_proj k_proj v_proj o_proj gate_proj up_proj down_proj \
+ --per_device_train_batch_size 1 \
+ --gradient_accumulation_steps 2 \
+ --num_generations 8 \
+ --generation_batch_size 32 \
+ --distillation_alpha 1.0 \
+ --distillation_mode sampled_token \
+ --distillation_weight 0.5 \
+ --report_to none \
+ --eval_strategy steps \
+ --eval_steps 1000 \
+ --save_strategy no \
+ --eval_num_prompts 0 \
+ --accuracy_eval_num_examples 64 \
+ --max_train_examples 256 \
+ --max_eval_examples 128
+```
+
+This example uses verifiable math rewards and reports answer accuracy before and after training. If your dataset
+already contains textual environment feedback, pass the column name via `--feedback_column`; it will be forwarded as
+`privileged_context` for SDPO reprompting.
+"""
+
+import re
+from dataclasses import dataclass, field
+from typing import Any
+
+import torch
+from datasets import DatasetDict, load_dataset, load_from_disk
+from transformers import AutoTokenizer, GenerationConfig
+
+from trl import (
+ LogCompletionsCallback,
+ ModelConfig,
+ ScriptArguments,
+ TrlParser,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+)
+from trl.data_utils import maybe_apply_chat_template
+from trl.experimental.sdpo import SDPOConfig, SDPOTrainer
+
+
+SYSTEM_PROMPT = (
+ "A conversation between user and assistant. The user asks a question, and the assistant solves it. The assistant "
+ "first thinks about the reasoning process in the mind and then provides the user with the answer. The reasoning "
+ "must be enclosed within tags, and the final answer must be on its own line in the format "
+ "`#### `."
+)
+
+
+@dataclass
+class SDPOScriptArguments(ScriptArguments):
+ dataset_path: str | None = field(
+ default=None,
+ metadata={"help": "Optional local dataset path to load with `load_from_disk`. Overrides `dataset_name`."},
+ )
+ feedback_column: str | None = field(
+ default=None,
+ metadata={
+ "help": "Optional dataset column containing textual environment feedback to pass as `privileged_context`."
+ },
+ )
+ eval_num_prompts: int | None = field(
+ default=8,
+ metadata={"help": "Number of prompts to log during evaluation. Set to 0 to disable completion logging."},
+ )
+ accuracy_eval_num_examples: int | None = field(
+ default=128,
+ metadata={"help": "Optional number of eval examples to score for answer accuracy. Defaults to 128."},
+ )
+ accuracy_eval_max_new_tokens: int = field(
+ default=128,
+ metadata={"help": "Maximum completion length for answer-accuracy evaluation generation."},
+ )
+ feedback_from_solution: str | None = field(
+ default=None,
+ metadata={
+ "help": "Optional synthesized feedback source when the dataset has no feedback column. Supported: "
+ "`final_answer`, `full_solution`."
+ },
+ )
+ max_train_examples: int | None = field(
+ default=None,
+ metadata={"help": "Optional cap on the number of training examples loaded from the selected train split."},
+ )
+ max_eval_examples: int | None = field(
+ default=None,
+ metadata={"help": "Optional cap on the number of evaluation examples loaded from the selected eval split."},
+ )
+ dataset_shuffle_seed: int = field(
+ default=42,
+ metadata={"help": "Random seed used before applying `max_train_examples` or `max_eval_examples`."},
+ )
+
+
+@dataclass
+class ExampleSDPOConfig(SDPOConfig):
+ scale_rewards: str = field(
+ default="group",
+ metadata={"help": "Reward normalization mode. Supported: `group`, `batch`, `none`."},
+ )
+
+
+def _make_solution_feedback(final_answer: str, worked_solution: str, feedback_from_solution: str | None) -> str | None:
+ if feedback_from_solution is None:
+ return None
+ if feedback_from_solution == "final_answer":
+ return (
+ "Your previous answer was incorrect. The correct final answer is:\n\n"
+ f"#### {final_answer}\n\n"
+ "Revise your reasoning and end with the same final answer format."
+ )
+ if feedback_from_solution == "full_solution":
+ return (
+ "Your previous answer was incorrect. Here is a correct worked solution:\n\n"
+ f"{worked_solution}\n\n"
+ "Use it to solve the original question correctly."
+ )
+ raise ValueError("feedback_from_solution must be one of: `final_answer`, `full_solution`.")
+
+
+def _make_conversation(
+ example: dict[str, Any], feedback_column: str | None, feedback_from_solution: str | None
+) -> dict[str, Any]:
+ prompt = example.get("prompt")
+ if prompt is None and "problem" in example:
+ prompt = [
+ {"role": "system", "content": SYSTEM_PROMPT},
+ {"role": "user", "content": example["problem"]},
+ ]
+ if prompt is None and "question" in example:
+ prompt = [
+ {"role": "system", "content": SYSTEM_PROMPT},
+ {"role": "user", "content": example["question"]},
+ ]
+
+ if prompt is None:
+ raise ValueError("Each example must provide one of: `prompt`, `problem`, or `question`.")
+
+ output = {"prompt": prompt}
+
+ solution = None
+ if "solution" in example:
+ solution = example["solution"]
+ elif "answer" in example:
+ solution = _normalize_gsm8k_answer(example["answer"])
+
+ if solution is not None:
+ output["solution"] = solution
+
+ if feedback_column is not None and feedback_column in example:
+ output["privileged_context"] = example[feedback_column]
+ elif "privileged_context" in example:
+ output["privileged_context"] = example["privileged_context"]
+ elif solution is not None:
+ worked_solution = example.get("solution")
+ if worked_solution is None and "answer" in example:
+ worked_solution = example["answer"].strip()
+ if worked_solution is None:
+ worked_solution = f"#### {solution}"
+ synthesized_feedback = _make_solution_feedback(solution, worked_solution, feedback_from_solution)
+ if synthesized_feedback is not None:
+ output["privileged_context"] = synthesized_feedback
+
+ return output
+
+
+def _normalize_gsm8k_answer(answer_text: str) -> str:
+ if "####" not in answer_text:
+ return answer_text.strip()
+ return answer_text.split("####", 1)[1].strip().replace(",", "")
+
+
+def _extract_predicted_answer(completion_text: str) -> str | None:
+ match = re.search(r"####\s*([^\n]+)", completion_text)
+ if match:
+ return match.group(1).strip().replace(",", "")
+
+ matches = re.findall(r"(-?\$?[0-9][0-9,]*(?:\.[0-9]+)?)", completion_text)
+ if not matches:
+ return None
+ return matches[-1].replace("$", "").replace(",", "").strip()
+
+
+def _gsm8k_accuracy_reward(completions, solution, **kwargs) -> list[float]:
+ rewards = []
+ for completion, gold in zip(completions, solution, strict=True):
+ content = completion[0]["content"] if isinstance(completion, list) else completion
+ pred = _extract_predicted_answer(content)
+ rewards.append(1.0 if pred is not None and pred == gold else 0.0)
+ return rewards
+
+
+def _gsm8k_soft_format_reward(completions, **kwargs) -> list[float]:
+ pattern = r".*?\s*####\s*[^\n]+"
+ rewards = []
+ for completion in completions:
+ content = completion[0]["content"] if isinstance(completion, list) else completion
+ rewards.append(0.25 if re.match(pattern, content, flags=re.DOTALL) else 0.0)
+ return rewards
+
+
+def _run_accuracy_eval(
+ trainer: SDPOTrainer, eval_dataset, max_new_tokens: int, num_examples: int | None, metric_prefix: str = "math_eval"
+) -> dict[str, float]:
+ if num_examples is not None:
+ eval_dataset = eval_dataset.select(range(min(num_examples, len(eval_dataset))))
+
+ prompts = eval_dataset["prompt"]
+ prompt_texts = [
+ maybe_apply_chat_template({"prompt": prompt}, trainer.processing_class)["prompt"] for prompt in prompts
+ ]
+ tokenized = trainer.processing_class(
+ text=prompt_texts,
+ return_tensors="pt",
+ padding=True,
+ padding_side="left",
+ truncation=True,
+ max_length=trainer.max_prompt_length,
+ add_special_tokens=False,
+ )
+ tokenized = {key: value.to(trainer.accelerator.device) for key, value in tokenized.items()}
+ model = trainer.accelerator.unwrap_model(trainer.model)
+ was_training = model.training
+ model.eval()
+ with torch.no_grad():
+ generated = model.generate(
+ **tokenized,
+ max_new_tokens=max_new_tokens,
+ do_sample=False,
+ pad_token_id=trainer.processing_class.pad_token_id,
+ eos_token_id=trainer.processing_class.eos_token_id,
+ )
+ if was_training:
+ model.train()
+
+ prompt_length = tokenized["input_ids"].shape[1]
+ completions = trainer.processing_class.batch_decode(generated[:, prompt_length:], skip_special_tokens=True)
+ completion_messages = [[{"role": "assistant", "content": completion}] for completion in completions]
+ rewards = _gsm8k_accuracy_reward(completion_messages, solution=eval_dataset["solution"])
+ total = max(len(rewards), 1)
+ return {
+ f"{metric_prefix}/accuracy": sum(rewards) / total,
+ f"{metric_prefix}/num_scored": float(len(rewards)),
+ }
+
+
+if __name__ == "__main__":
+ parser = TrlParser((SDPOScriptArguments, ExampleSDPOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+ training_args.model_init_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ training_args.model_init_kwargs["device_map"] = get_kbit_device_map()
+ training_args.model_init_kwargs["quantization_config"] = quantization_config
+
+ if script_args.dataset_path is not None:
+ dataset = load_from_disk(script_args.dataset_path)
+ else:
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+ if not isinstance(dataset, DatasetDict):
+ raise ValueError("SDPO example expects a dataset with named splits.")
+
+ train_split = dataset[script_args.dataset_train_split]
+ if script_args.max_train_examples is not None:
+ train_split = train_split.shuffle(seed=script_args.dataset_shuffle_seed).select(
+ range(min(script_args.max_train_examples, len(train_split)))
+ )
+
+ train_dataset = train_split.map(
+ lambda example: _make_conversation(example, script_args.feedback_column, script_args.feedback_from_solution),
+ remove_columns=train_split.column_names,
+ )
+ eval_dataset = None
+ if training_args.eval_strategy != "no":
+ eval_split = dataset[script_args.dataset_test_split]
+ if script_args.max_eval_examples is not None:
+ eval_split = eval_split.shuffle(seed=script_args.dataset_shuffle_seed).select(
+ range(min(script_args.max_eval_examples, len(eval_split)))
+ )
+
+ eval_dataset = eval_split.map(
+ lambda example: _make_conversation(
+ example, script_args.feedback_column, script_args.feedback_from_solution
+ ),
+ remove_columns=eval_split.column_names,
+ )
+
+ reward_funcs = [_gsm8k_soft_format_reward, _gsm8k_accuracy_reward]
+
+ tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path)
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+
+ trainer = SDPOTrainer(
+ model=model_args.model_name_or_path,
+ args=training_args,
+ reward_funcs=reward_funcs,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ peft_config=get_peft_config(model_args),
+ processing_class=tokenizer,
+ )
+
+ if eval_dataset is not None and script_args.eval_num_prompts:
+ generation_config = GenerationConfig(
+ max_new_tokens=training_args.max_completion_length,
+ do_sample=True,
+ temperature=training_args.temperature,
+ )
+ trainer.add_callback(
+ LogCompletionsCallback(trainer, generation_config, num_prompts=script_args.eval_num_prompts)
+ )
+
+ if eval_dataset is not None:
+ pre_metrics = _run_accuracy_eval(
+ trainer,
+ eval_dataset,
+ max_new_tokens=script_args.accuracy_eval_max_new_tokens,
+ num_examples=script_args.accuracy_eval_num_examples,
+ )
+ trainer.log_metrics("eval", {f"before_{k}": v for k, v in pre_metrics.items()})
+ trainer.save_metrics("eval", {f"before_{k}": v for k, v in pre_metrics.items()})
+
+ trainer.train()
+
+ trainer.save_model(training_args.output_dir)
+ if eval_dataset is not None:
+ post_metrics = _run_accuracy_eval(
+ trainer,
+ eval_dataset,
+ max_new_tokens=script_args.accuracy_eval_max_new_tokens,
+ num_examples=script_args.accuracy_eval_num_examples,
+ )
+ after_metrics = {f"after_{k}": v for k, v in post_metrics.items()}
+ delta_metrics = {
+ f"delta_{k.split('/', 1)[1]}": after_metrics[f"after_{k}"] - pre_metrics[k] for k in pre_metrics
+ }
+ trainer.log_metrics("eval", after_metrics | delta_metrics)
+ trainer.save_metrics("eval", after_metrics | delta_metrics)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name or script_args.dataset_path)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft.py
new file mode 100644
index 0000000000000000000000000000000000000000..b6e132e99026e779bbf3ee14a52447886b3b1a31
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft.py
@@ -0,0 +1,17 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+###############################################################################################
+# This file has been moved to https://github.com/huggingface/trl/blob/main/trl/scripts/sft.py #
+###############################################################################################
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_gemma3.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_gemma3.py
new file mode 100644
index 0000000000000000000000000000000000000000..8aeb74abc71d4f0e7c1bfd82e30e94e2de8a948e
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_gemma3.py
@@ -0,0 +1,69 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "Pillow",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Train Gemma-3 on the Codeforces COTS dataset.
+
+accelerate launch --config_file examples/accelerate_configs/deepspeed_zero3.yaml examples/scripts/sft_gemma3.py
+"""
+
+from datasets import load_dataset
+from transformers import AutoModelForImageTextToText
+
+from trl import SFTConfig, SFTTrainer
+
+
+def main():
+ # Load dataset
+ train_dataset = load_dataset("open-r1/codeforces-cots", split="train")
+ train_dataset = train_dataset.remove_columns("prompt")
+
+ # Load model
+ model_id = "google/gemma-3-12b-it"
+ model = AutoModelForImageTextToText.from_pretrained(model_id, attn_implementation="eager")
+
+ # Train model
+ training_args = SFTConfig(
+ output_dir=f"{model_id}-codeforces-SFT",
+ bf16=True,
+ use_liger_kernel=True,
+ max_length=8192,
+ per_device_train_batch_size=1,
+ gradient_accumulation_steps=8,
+ dataset_num_proc=32,
+ num_train_epochs=1,
+ )
+
+ trainer = SFTTrainer(
+ args=training_args,
+ model=model,
+ train_dataset=train_dataset,
+ )
+ trainer.train()
+
+ # Push to hub
+ trainer.push_to_hub(dataset_name="open-r1/codeforces-cots")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_gpt_oss.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_gpt_oss.py
new file mode 100644
index 0000000000000000000000000000000000000000..d08c73d587d424e2088dc4ef77e88a56f9d58f32
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_gpt_oss.py
@@ -0,0 +1,91 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "kernels",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+pip install –-upgrade kernels
+
+Example:
+
+accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+ examples/scripts/sft_gpt_oss.py \
+ --dtype bfloat16 \
+ --model_name_or_path openai/gpt-oss-20b \
+ --packing \
+ --run_name 20b-full-eager \
+ --attn_implementation kernels-community/vllm-flash-attn3 \
+ --dataset_num_proc 12 \
+ --dataset_name HuggingFaceH4/Multilingual-Thinking \
+ --max_length 4096 \
+ --per_device_train_batch_size 2 \
+ --num_train_epochs 1 \
+ --logging_steps 1 \
+ --warmup_steps 0.03 \
+ --lr_scheduler_type cosine_with_min_lr \
+ --lr_scheduler_kwargs '{"min_lr_rate": 0.1}' \
+ --output_dir gpt-oss-20b-multilingual-reasoner \
+ --report_to trackio \
+ --seed 42
+"""
+
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, Mxfp4Config
+
+from trl import ModelConfig, ScriptArguments, SFTConfig, SFTTrainer, TrlParser, get_peft_config
+
+
+def main(script_args, training_args, model_args):
+ # Load model
+ quantization_config = Mxfp4Config(dequantize=True)
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=model_args.dtype,
+ use_cache=False if training_args.gradient_checkpointing else True,
+ quantization_config=quantization_config,
+ )
+
+ model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path, **model_kwargs)
+
+ # Load dataset
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+ # Train model
+ trainer = SFTTrainer(
+ model=model,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ peft_config=get_peft_config(model_args),
+ )
+
+ trainer.train()
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
+
+
+if __name__ == "__main__":
+ parser = TrlParser((ScriptArguments, SFTConfig, ModelConfig))
+ script_args, training_args, model_args, _ = parser.parse_args_and_config(return_remaining_strings=True)
+ main(script_args, training_args, model_args)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_nemotron_3.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_nemotron_3.py
new file mode 100644
index 0000000000000000000000000000000000000000..4df88bfeb0c4a65d766002fab46f34a4ba72d3e3
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_nemotron_3.py
@@ -0,0 +1,110 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft,quantization]",
+# "transformers>=5.7.0",
+# "trackio",
+# "mamba_ssm==2.2.5",
+# "causal_conv1d==1.5.2",
+# ]
+# ///
+
+"""
+Fine-tune NVIDIA Nemotron 3 models with SFT.
+
+Prerequisites:
+
+ pip install "transformers>=5.7.0"
+ pip install --no-build-isolation mamba_ssm==2.2.5
+ pip install --no-build-isolation causal_conv1d==1.5.2
+
+Example:
+
+accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+ examples/scripts/sft_nemotron_3.py \
+ --dtype bfloat16 \
+ --model_name_or_path nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16 \
+ --attn_implementation eager \
+ --dataset_name HuggingFaceH4/Multilingual-Thinking \
+ --max_length 128 \
+ --per_device_train_batch_size 1 \
+ --gradient_accumulation_steps 4 \
+ --num_train_epochs 1 \
+ --learning_rate 2e-4 \
+ --optim paged_adamw_8bit \
+ --logging_steps 10 \
+ --output_dir nemotron-3-sft \
+ --report_to trackio \
+ --use_peft \
+ --lora_r 8 \
+ --lora_alpha 16 \
+ --lora_target_modules q_proj k_proj v_proj o_proj gate_proj up_proj down_proj
+"""
+
+from datasets import load_dataset
+
+from trl import ModelConfig, ScriptArguments, SFTConfig, SFTTrainer, TrlParser, get_peft_config
+
+
+def main(script_args, training_args, model_args):
+ training_args.model_init_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=model_args.dtype,
+ )
+
+ # Load dataset
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+ # Merge thinking into message content using tags and remove extra columns
+ def merge_thinking_and_remove_key(example):
+ new_messages = []
+ for msg in example["messages"]:
+ content = msg["content"]
+ thinking = msg.get("thinking")
+ if thinking and isinstance(thinking, str) and thinking.strip():
+ content = f"\n{thinking}\n\n{content}"
+ new_messages.append({"role": msg["role"], "content": content})
+ example["messages"] = new_messages
+ return example
+
+ dataset = dataset.map(merge_thinking_and_remove_key)
+
+ # Prepare eval dataset if needed
+ eval_dataset = None
+ if training_args.eval_strategy != "no" and script_args.dataset_test_split in dataset:
+ eval_dataset = dataset[script_args.dataset_test_split]
+
+ # Train model
+ trainer = SFTTrainer(
+ model=model_args.model_name_or_path,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=eval_dataset,
+ peft_config=get_peft_config(model_args),
+ )
+
+ trainer.train()
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
+
+
+if __name__ == "__main__":
+ parser = TrlParser((ScriptArguments, SFTConfig, ModelConfig))
+ script_args, training_args, model_args, _ = parser.parse_args_and_config(return_remaining_strings=True)
+ main(script_args, training_args, model_args)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_tiny_aya_tool_calling.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_tiny_aya_tool_calling.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a29be6035863fbc20a3e5b49fb60ca2233a74c7
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_tiny_aya_tool_calling.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.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "bitsandbytes",
+# "liger-kernel",
+# "trackio",
+# ]
+# ///
+
+"""
+Teach tool calling to CohereLabs/tiny-aya-global using SFT with QLoRA on the bebechien/SimpleToolCalling dataset.
+
+The model used in this script does not have native tool-calling support. We extend its existing Jinja2 chat template to
+serialize tool schemas into the system preamble and render tool calls as structured XML inside the model's
+native <|START_RESPONSE|> / <|END_RESPONSE|> delimiters. The modified template is saved with the tokenizer, so
+inference only requires loading the tokenizer from the output directory and calling apply_chat_template with
+tools=TOOLS — no manual system-prompt construction needed.
+
+Example:
+
+ python examples/scripts/sft_tiny_aya_tool_calling.py
+"""
+
+import json
+from pathlib import Path
+
+import torch
+from datasets import load_dataset
+from peft import LoraConfig
+from transformers import AutoModelForCausalLM, BitsAndBytesConfig
+
+from trl import SFTConfig, SFTTrainer
+
+
+# These are the tool schemas that are used in the dataset
+TOOLS = [
+ {
+ "type": "function",
+ "function": {
+ "name": "search_knowledge_base",
+ "description": "Search internal company documents, policies and project data.",
+ "parameters": {
+ "type": "object",
+ "properties": {"query": {"type": "string", "description": "query string"}},
+ "required": ["query"],
+ },
+ "return": {"type": "string"},
+ },
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "search_google",
+ "description": "Search public information.",
+ "parameters": {
+ "type": "object",
+ "properties": {"query": {"type": "string", "description": "query string"}},
+ "required": ["query"],
+ },
+ "return": {"type": "string"},
+ },
+ },
+]
+
+
+def create_conversation(sample):
+ return {
+ "prompt": [{"role": "user", "content": sample["user_content"]}],
+ "completion": [
+ {
+ "role": "assistant",
+ "tool_calls": [
+ {
+ "type": "function",
+ "function": {
+ "name": sample["tool_name"],
+ "arguments": json.loads(sample["tool_arguments"]),
+ },
+ }
+ ],
+ },
+ ],
+ "tools": TOOLS,
+ }
+
+
+def main():
+ model_id = "CohereLabs/tiny-aya-global"
+ dataset_name = "bebechien/SimpleToolCalling"
+ output_dir = "tiny-aya-global-tool-calling-SFT"
+
+ # Load and format dataset
+ dataset = load_dataset(dataset_name, split="train")
+ dataset = dataset.map(create_conversation, remove_columns=dataset.features)
+ dataset = dataset.train_test_split(test_size=0.5, shuffle=True)
+
+ # Load model
+ model = AutoModelForCausalLM.from_pretrained(
+ model_id,
+ attn_implementation="sdpa",
+ dtype=torch.float16,
+ quantization_config=BitsAndBytesConfig(
+ load_in_4bit=True,
+ bnb_4bit_compute_dtype=torch.float16,
+ bnb_4bit_use_double_quant=True,
+ bnb_4bit_quant_type="nf4",
+ ),
+ )
+
+ # Configure LoRA
+ peft_config = LoraConfig(
+ r=32,
+ lora_alpha=32,
+ target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+ )
+
+ # Train
+ training_args = SFTConfig(
+ output_dir=output_dir,
+ per_device_train_batch_size=1,
+ gradient_accumulation_steps=4,
+ # Use the tool-aware chat template
+ chat_template_path=str(Path(__file__).parent / "tiny_aya_chat_template.jinja"),
+ warmup_steps=5,
+ learning_rate=2e-4,
+ optim="paged_adamw_8bit",
+ logging_steps=1,
+ report_to="trackio",
+ trackio_space_id=output_dir,
+ max_length=1024,
+ use_liger_kernel=True,
+ activation_offloading=True,
+ push_to_hub=True,
+ )
+
+ trainer = SFTTrainer(
+ model=model,
+ args=training_args,
+ train_dataset=dataset["train"],
+ peft_config=peft_config,
+ )
+ trainer.train()
+
+ # Save model and tokenizer (tokenizer carries the updated chat template)
+ trainer.save_model(output_dir)
+ trainer.push_to_hub(dataset_name=dataset_name)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_video_llm.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_video_llm.py
new file mode 100644
index 0000000000000000000000000000000000000000..34dae58cf042b4dfa4c255cea902252cf833cb43
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_video_llm.py
@@ -0,0 +1,245 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "qwen-vl-utils",
+# "torchvision",
+# "bitsandbytes",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Example usage:
+accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero2.yaml \
+ examples/scripts/sft_video_llm.py \
+ --dataset_name mfarre/simplevideoshorts \
+ --video_cache_dir "/optional/path/to/cache/" \
+ --model_name_or_path Qwen/Qwen2-VL-7B-Instruct \
+ --per_device_train_batch_size 1 \
+ --output_dir video-llm-output \
+ --tf32 True \
+ --gradient_accumulation_steps 4 \
+ --num_train_epochs 4 \
+ --optim adamw_torch_fused \
+ --log_level debug \
+ --log_level_replica debug \
+ --save_strategy steps \
+ --save_steps 300 \
+ --learning_rate 8e-5 \
+ --max_grad_norm 0.3 \
+ --warmup_steps 0.1 \
+ --lr_scheduler_type cosine \
+ --push_to_hub False \
+ --dtype bfloat16
+"""
+
+import json
+import os
+import random
+from dataclasses import dataclass, field
+from typing import Any
+
+import requests
+import torch
+from datasets import load_dataset
+from peft import LoraConfig
+from qwen_vl_utils import process_vision_info
+from transformers import AutoModelForImageTextToText, AutoProcessor, BitsAndBytesConfig, Qwen2VLProcessor
+
+from trl import ModelConfig, ScriptArguments, SFTConfig, SFTTrainer, TrlParser, get_kbit_device_map
+
+
+def download_video(url: str, cache_dir: str) -> str:
+ """Download video if not already present locally."""
+ os.makedirs(cache_dir, exist_ok=True) # Create cache dir if it doesn't exist
+ filename = url.split("/")[-1]
+ local_path = os.path.join(cache_dir, filename)
+
+ if os.path.exists(local_path):
+ return local_path
+
+ try:
+ with requests.get(url, stream=True) as r:
+ r.raise_for_status()
+ with open(local_path, "wb") as f:
+ for chunk in r.iter_content(chunk_size=8192):
+ if chunk:
+ f.write(chunk)
+ return local_path
+ except requests.RequestException as e:
+ raise Exception(f"Failed to download video: {e}") from e
+
+
+def prepare_dataset(example: dict[str, Any], cache_dir: str) -> dict[str, list[dict[str, Any]]]:
+ """Prepare dataset example for training."""
+ video_url = example["video_url"]
+ timecoded_cc = example["timecoded_cc"]
+ qa_pairs = json.loads(example["qa"])
+
+ system_message = "You are an expert in movie narrative analysis."
+ base_prompt = f"""Analyze the video and consider the following timecoded subtitles:
+
+{timecoded_cc}
+
+Based on this information, please answer the following questions:"""
+
+ selected_qa = random.sample(qa_pairs, 1)[0]
+
+ messages = [
+ {"role": "system", "content": [{"type": "text", "text": system_message}]},
+ {
+ "role": "user",
+ "content": [
+ {"type": "video", "video": download_video(video_url, cache_dir), "max_pixels": 360 * 420, "fps": 1.0},
+ {"type": "text", "text": f"{base_prompt}\n\nQuestion: {selected_qa['question']}"},
+ ],
+ },
+ {"role": "assistant", "content": [{"type": "text", "text": selected_qa["answer"]}]},
+ ]
+
+ return {"messages": messages}
+
+
+def collate_fn(examples: list[dict[str, Any]]) -> dict[str, torch.Tensor]:
+ """Collate batch of examples for training."""
+ texts = []
+ video_inputs = []
+
+ for i, example in enumerate(examples):
+ try:
+ video_path = next(
+ content["video"]
+ for message in example["messages"]
+ for content in message["content"]
+ if content.get("type") == "video"
+ )
+ print(f"Processing video: {os.path.basename(video_path)}")
+
+ texts.append(processor.apply_chat_template(example["messages"], tokenize=False))
+ video_input = process_vision_info(example["messages"])[1][0]
+ video_inputs.append(video_input)
+ except Exception as e:
+ raise ValueError(f"Failed to process example {i}: {e}") from e
+
+ inputs = processor(text=texts, videos=video_inputs, return_tensors="pt", padding=True)
+
+ labels = inputs["input_ids"].clone()
+ labels[labels == processor.tokenizer.pad_token_id] = -100
+
+ # Handle visual tokens based on processor type
+ visual_tokens = (
+ [151652, 151653, 151656]
+ if isinstance(processor, Qwen2VLProcessor)
+ else [processor.tokenizer.convert_tokens_to_ids(processor.image_token)]
+ )
+
+ for visual_token_id in visual_tokens:
+ labels[labels == visual_token_id] = -100
+
+ inputs["labels"] = labels
+ return inputs
+
+
+@dataclass
+class CustomScriptArguments(ScriptArguments):
+ r"""
+ Arguments for the script.
+
+ Args:
+ video_cache_dir (`str`, *optional*, defaults to `"/tmp/videos/"`):
+ Video cache directory.
+ """
+
+ video_cache_dir: str = field(default="/tmp/videos/", metadata={"help": "Video cache directory."})
+
+
+if __name__ == "__main__":
+ # Parse arguments
+ parser = TrlParser((CustomScriptArguments, SFTConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+
+ # Configure training args
+ training_args.remove_unused_columns = False
+
+ # Load dataset
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config, split="train")
+
+ # Setup model
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+
+ # Quantization configuration for 4-bit training
+ bnb_config = BitsAndBytesConfig(
+ load_in_4bit=True,
+ bnb_4bit_use_double_quant=True,
+ bnb_4bit_quant_type="nf4",
+ bnb_4bit_compute_dtype=torch.bfloat16,
+ )
+
+ # Model initialization
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ dtype=dtype,
+ device_map=get_kbit_device_map(),
+ quantization_config=bnb_config,
+ )
+
+ model = AutoModelForImageTextToText.from_pretrained(model_args.model_name_or_path, **model_kwargs)
+
+ peft_config = LoraConfig(
+ task_type="CAUSAL_LM",
+ r=16,
+ lora_alpha=16,
+ lora_dropout=0.1,
+ bias="none",
+ target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
+ )
+
+ # Configure model modules for gradients
+ if training_args.gradient_checkpointing:
+ model.gradient_checkpointing_enable()
+ model.config.use_reentrant = False
+ model.enable_input_require_grads()
+
+ processor = AutoProcessor.from_pretrained(model_args.model_name_or_path)
+
+ # Prepare dataset
+ prepared_dataset = [prepare_dataset(example, script_args.video_cache_dir) for example in dataset]
+
+ # Initialize trainer
+ trainer = SFTTrainer(
+ model=model,
+ args=training_args,
+ train_dataset=prepared_dataset,
+ data_collator=collate_fn,
+ peft_config=peft_config,
+ processing_class=processor,
+ )
+
+ # Train model
+ trainer.train()
+
+ # Save final model
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
+
+ # Cleanup
+ del model
+ del trainer
+ torch.cuda.empty_cache()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_vlm.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_vlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..defb2ed2cff6601da826def6857235c561cf4f5a
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_vlm.py
@@ -0,0 +1,115 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "Pillow>=9.4.0",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+pip install pillow
+
+# Tested on 8x H100 GPUs
+accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+ examples/scripts/sft_vlm.py \
+ --dataset_name HuggingFaceH4/llava-instruct-mix-vsft \
+ --model_name_or_path llava-hf/llava-1.5-7b-hf \
+ --gradient_accumulation_steps 8 \
+ --output_dir LLaVA-1.5-7B-SFT \
+ --dtype bfloat16
+
+For LLaVA-NeXT, use:
+ --model_name_or_path llava-hf/llava-v1.6-mistral-7b-hf
+
+For meta-llama/Llama-3.2-11B-Vision-Instruct, use:
+ --model_name_or_path meta-llama/Llama-3.2-11B-Vision-Instruct
+
+accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+ examples/scripts/sft_vlm.py \
+ --dataset_name HuggingFaceH4/llava-instruct-mix-vsft \
+ --model_name_or_path HuggingFaceTB/SmolVLM-Instruct \
+ --per_device_train_batch_size 1 \
+ --gradient_accumulation_steps 1 \
+ --output_dir SmolVLM-SFT \
+ --dtype bfloat16 \
+ --use_peft \
+ --lora_target_modules down_proj, o_proj, k_proj, q_proj, gate_proj, up_proj, v_proj
+"""
+
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForImageTextToText
+
+from trl import (
+ ModelConfig,
+ ScriptArguments,
+ SFTConfig,
+ SFTTrainer,
+ TrlParser,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+)
+
+
+if __name__ == "__main__":
+ parser = TrlParser((ScriptArguments, SFTConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+ training_args.max_length = None
+
+ ################
+ # Model
+ ################
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ model_kwargs["device_map"] = get_kbit_device_map()
+ model_kwargs["quantization_config"] = quantization_config
+
+ model = AutoModelForImageTextToText.from_pretrained(model_args.model_name_or_path, **model_kwargs)
+
+ ################
+ # Dataset
+ ################
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+ ################
+ # Training
+ ################
+ trainer = SFTTrainer(
+ model=model,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ peft_config=get_peft_config(model_args),
+ )
+
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_vlm_gemma3.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_vlm_gemma3.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c67a76d9346923b07011060a010b3781d9099b4
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/sft_vlm_gemma3.py
@@ -0,0 +1,187 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "Pillow>=9.4.0",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Train Gemma 3 on the HuggingFaceH4/llava-instruct-mix-vsft dataset (single-image).
+
+accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+ examples/scripts/sft_vlm_gemma3.py \
+ --dataset_name HuggingFaceH4/llava-instruct-mix-vsft \
+ --model_name_or_path google/gemma-3-4b-it \
+ --per_device_train_batch_size 1 \
+ --output_dir Gemma-3-4B-SFT-MMIU \
+ --dtype bfloat16 \
+ --use_peft \
+ --lora_target_modules all-linear \
+ --attn_implementation eager
+
+Train Gemma 3 on the FanqingM/MMIU-Benchmark dataset (multi-image).
+
+accelerate launch \
+ --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+ examples/scripts/sft_vlm_gemma3.py \
+ --dataset_name FanqingM/MMIU-Benchmark \
+ --dataset_train_split test \
+ --model_name_or_path google/gemma-3-4b-it \
+ --per_device_train_batch_size 1 \
+ --output_dir Gemma-3-4B-SFT-MMIU \
+ --dtype bfloat16 \
+ --use_peft \
+ --lora_target_modules all-linear \
+ --attn_implementation eager
+"""
+
+import io
+import os
+import zipfile
+
+import torch
+from datasets import DatasetDict, load_dataset
+from huggingface_hub import hf_hub_download, list_repo_files
+from PIL import Image
+from transformers import AutoModelForImageTextToText
+
+from trl import (
+ ModelConfig,
+ ScriptArguments,
+ SFTConfig,
+ SFTTrainer,
+ TrlParser,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+)
+
+
+# For multi-image example
+def process_vision_info(messages: list[dict]) -> list[Image.Image]:
+ image_inputs = []
+ for msg in messages:
+ content = msg.get("content", [])
+ if not isinstance(content, list):
+ content = [content]
+
+ for element in content:
+ if isinstance(element, dict) and ("image" in element or element.get("type") == "image"):
+ if "image" in element:
+ image = element["image"]
+ else:
+ image = element
+ if image is not None:
+ image = Image.open(io.BytesIO(image["bytes"]))
+ image_inputs.append(image.convert("RGB"))
+ return image_inputs
+
+
+def format_data(samples: dict[str, any]) -> dict[str, list]:
+ formatted_samples = {"messages": []}
+ for cont in range(len(samples["question"])):
+ images = []
+ for img_path in samples["input_image_path"][cont]:
+ try:
+ with open(img_path, "rb") as f:
+ img_bytes = f.read()
+ image = Image.open(io.BytesIO(img_bytes)).convert("RGB")
+ images.append({"type": "image", "image": image})
+ except Exception as e:
+ print(f"Error processing image {img_path}: {e}")
+ continue
+
+ formatted_samples["messages"].append(
+ [
+ {"role": "system", "content": [{"type": "text", "text": samples["context"][cont]}]},
+ {"role": "user", "content": images + [{"type": "text", "text": samples["question"][cont]}]},
+ {"role": "assistant", "content": [{"type": "text", "text": samples["output"][cont]}]},
+ ]
+ )
+ return formatted_samples
+
+
+# For multi-image example
+def prepare_dataset(dataset: DatasetDict, dataset_name: str) -> DatasetDict:
+ all_files = list_repo_files(dataset_name, repo_type="dataset")
+ zip_files = [f for f in all_files if f.endswith(".zip")]
+
+ for zip_filename in zip_files:
+ zip_path = hf_hub_download(repo_id=dataset_name, filename=zip_filename, repo_type="dataset")
+ extract_folder = zip_filename.replace(".zip", "")
+ os.makedirs(extract_folder, exist_ok=True)
+
+ with zipfile.ZipFile(zip_path, "r") as zip_ref:
+ zip_ref.extractall(extract_folder)
+
+ dataset = dataset.map(format_data, batched=True, batch_size=4, num_proc=16)
+ return dataset
+
+
+def main():
+ parser = TrlParser((ScriptArguments, SFTConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+ training_args.max_length = None
+
+ ################
+ # Model
+ ################
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ model_kwargs["device_map"] = get_kbit_device_map()
+ model_kwargs["quantization_config"] = quantization_config
+
+ model = AutoModelForImageTextToText.from_pretrained(model_args.model_name_or_path, **model_kwargs)
+
+ ################
+ # Dataset
+ ################
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+ if script_args.dataset_name == "FanqingM/MMIU-Benchmark":
+ dataset = prepare_dataset(dataset, script_args.dataset_name)
+
+ ################
+ # Training
+ ################
+ trainer = SFTTrainer(
+ model=model,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ peft_config=get_peft_config(model_args),
+ )
+
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/ssd.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/ssd.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d9af49e38faa765a8b316a7fb8c68bdb85c5062
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/ssd.py
@@ -0,0 +1,166 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "peft",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Simple Self-Distillation (SSD) training for code generation.
+
+Implements the method from "Embarrassingly Simple Self-Distillation Improves Code Generation" (Zhang et al., 2026):
+sample completions from the model at a training-time temperature and truncation, then fine-tune on those raw,
+unverified samples with standard cross-entropy loss. No reward model, verifier, teacher, or RL needed.
+
+The dataset only requires a ``prompt`` column containing coding problem prompts.
+
+Example:
+
+```bash
+python examples/scripts/ssd.py \
+ --model_name_or_path Qwen/Qwen3-4B-Instruct-2507 \
+ --dataset_name microsoft/rStar-Coder \
+ --dataset_config seed_sft \
+ --prompt_column question \
+ --output_dir outputs/ssd-qwen3-4b \
+ --per_device_train_batch_size 1 \
+ --gradient_accumulation_steps 32 \
+ --learning_rate 5e-6 \
+ --lr_scheduler_type cosine \
+ --max_prompt_length 1024 \
+ --max_completion_length 65536 \
+ --temperature 1.6 \
+ --top_k 20 \
+ --top_p 0.8 \
+ --num_train_epochs 1 \
+ --bf16 \
+ --report_to trackio
+```
+"""
+
+from dataclasses import dataclass, field
+
+import torch
+from datasets import DatasetDict, load_dataset, load_from_disk
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from trl import (
+ ModelConfig,
+ ScriptArguments,
+ TrlParser,
+ get_kbit_device_map,
+ get_peft_config,
+ get_quantization_config,
+)
+from trl.experimental.ssd import SSDConfig, SSDTrainer
+
+
+@dataclass
+class SSDScriptArguments(ScriptArguments):
+ dataset_path: str | None = field(
+ default=None,
+ metadata={"help": "Optional local dataset path to load with `load_from_disk`. Overrides `dataset_name`."},
+ )
+ prompt_column: str = field(
+ default="prompt",
+ metadata={"help": "Column containing the problem prompts."},
+ )
+
+
+if __name__ == "__main__":
+ parser = TrlParser((SSDScriptArguments, SSDConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+
+ if model_args.model_name_or_path is None:
+ raise ValueError("`model_name_or_path` is required.")
+
+ if model_args.dtype in ["auto", None]:
+ if training_args.bf16:
+ dtype = torch.bfloat16
+ elif training_args.fp16:
+ dtype = torch.float16
+ else:
+ dtype = "auto"
+ else:
+ dtype = getattr(torch, model_args.dtype)
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ model_kwargs["device_map"] = get_kbit_device_map()
+ model_kwargs["quantization_config"] = quantization_config
+
+ training_args.model_init_kwargs = model_kwargs
+
+ tokenizer = AutoTokenizer.from_pretrained(
+ model_args.model_name_or_path, revision=model_args.model_revision, padding_side="left"
+ )
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+
+ # Load dataset
+ if script_args.dataset_path is not None:
+ dataset = load_from_disk(script_args.dataset_path)
+ else:
+ dataset = load_dataset(
+ script_args.dataset_name,
+ name=script_args.dataset_config,
+ streaming=script_args.dataset_streaming,
+ )
+
+ # Ensure the dataset has a `prompt` column
+ def _prepare_split(ds):
+ if script_args.prompt_column != "prompt" and script_args.prompt_column in ds.column_names:
+ ds = ds.rename_column(script_args.prompt_column, "prompt")
+ return ds.select_columns(["prompt"])
+
+ if isinstance(dataset, DatasetDict):
+ train_dataset = _prepare_split(dataset[script_args.dataset_train_split])
+ eval_dataset = None
+ if script_args.dataset_test_split in dataset:
+ eval_dataset = _prepare_split(dataset[script_args.dataset_test_split])
+ else:
+ train_dataset = _prepare_split(dataset)
+ eval_dataset = None
+
+ model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path, **model_kwargs)
+ model.config.use_cache = False if training_args.gradient_checkpointing else True
+
+ trainer = SSDTrainer(
+ model=model,
+ args=training_args,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ processing_class=tokenizer,
+ peft_config=get_peft_config(model_args),
+ )
+
+ trainer.train()
+
+ trainer.save_model(training_args.output_dir)
+ if eval_dataset is not None:
+ metrics = trainer.evaluate()
+ trainer.log_metrics("eval", metrics)
+ trainer.save_metrics("eval", metrics)
+
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name or script_args.dataset_path)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/ssd_eval.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/ssd_eval.py
new file mode 100644
index 0000000000000000000000000000000000000000..e33301000d179b3d8404a975aebb12b62697fea9
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/ssd_eval.py
@@ -0,0 +1,260 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "vllm",
+# "huggingface_hub",
+# "livecodebench @ git+https://github.com/LiveCodeBench/LiveCodeBench.git",
+# ]
+# ///
+
+"""
+LiveCodeBench v6 evaluation script.
+
+Generates completions with vLLM at a configurable decoding setting and scores them with LiveCodeBench's official
+``codegen_metrics`` (pass@k via sandboxed test execution). The default decoding configuration matches Table 3 of
+*Embarrassingly Simple Self-Distillation Improves Code Generation* (Zhang et al., 2026), making this script suitable
+for evaluating SSD-trained checkpoints alongside their base models.
+
+Example — evaluate the base Qwen3-4B-Instruct-2507 on the v6 delta (the new problems released in v6):
+
+```bash
+python examples/scripts/ssd_eval.py \\
+ --model_name_or_path Qwen/Qwen3-4B-Instruct-2507 \\
+ --temperature 1.1 \\
+ --top_k 20 \\
+ --top_p 0.8 \\
+ --n 1 \\
+ --output_file outputs/qwen3_4b_base_lcb_v6.json
+```
+
+Evaluate an SSD-trained checkpoint with the same decoding configuration:
+
+```bash
+python examples/scripts/ssd_eval.py \\
+ --model_name_or_path outputs/ssd-qwen3-4b-instruct \\
+ --temperature 1.1 \\
+ --top_k 20 \\
+ --top_p 0.8 \\
+ --n 5 \\
+ --output_file outputs/qwen3_4b_ssd_lcb_v6.json
+```
+"""
+
+# ruff: noqa: T201
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from datetime import datetime
+
+from huggingface_hub import hf_hub_download
+from lcb_runner.benchmarks.code_generation import CodeGenerationProblem
+from lcb_runner.evaluation.compute_code_generation_metrics import codegen_metrics
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+from trl import TrlParser
+
+
+# LiveCodeBench stores new problems added in each release version in a separate JSONL file:
+# ``test.jsonl`` = v1, ``test2.jsonl`` = v2, …, ``test6.jsonl`` = v6 (the delta added in release v6).
+# The paper's "LCB v6" refers to exactly this delta.
+LCB_REPO = "livecodebench/code_generation_lite"
+LCB_V6_FILE = "test6.jsonl"
+
+
+SYSTEM_MESSAGE = (
+ "You are an expert Python programmer. You will be given a question (problem specification) and will "
+ "generate a correct Python program that matches the specification and passes all tests."
+)
+FORMATTING_WITHOUT_STARTER = (
+ "Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on "
+ "the sample inputs). Enclose your code within delimiters as follows. Ensure that when the python "
+ "program runs, it reads the inputs, runs the algorithm and writes output to STDOUT."
+)
+FORMATTING_WITH_STARTER = (
+ "You will use the following starter code to write the solution to the problem and enclose your code "
+ "within delimiters."
+)
+
+CODE_FENCE_RE = re.compile(r"```(?:python)?\s*\n(.*?)```", re.DOTALL)
+
+
+@dataclass
+class SSDEvalArguments:
+ model_name_or_path: str = field(metadata={"help": "Model path or Hub repo id to evaluate."})
+ output_file: str = field(metadata={"help": "Path to write generations + metrics JSON."})
+ temperature: float = field(default=1.1, metadata={"help": "Evaluation-time sampling temperature (T_eval)."})
+ top_k: int = field(default=20, metadata={"help": "Evaluation-time top-k truncation."})
+ top_p: float = field(default=0.8, metadata={"help": "Evaluation-time top-p (nucleus) truncation."})
+ n: int = field(default=1, metadata={"help": "Number of samples per problem (pass@1 uses 1, pass@5 uses 5)."})
+ max_tokens: int = field(default=32768, metadata={"help": "Maximum tokens to generate per completion."})
+ max_model_len: int = field(default=65536, metadata={"help": "vLLM max model length."})
+ gpu_memory_utilization: float = field(default=0.9, metadata={"help": "vLLM GPU memory ratio."})
+ tensor_parallel_size: int = field(default=1, metadata={"help": "vLLM tensor parallel size."})
+ dtype: str = field(default="bfloat16", metadata={"help": "vLLM model dtype."})
+ start_date: str | None = field(
+ default=None, metadata={"help": "Keep only problems with contest_date >= YYYY-MM-DD."}
+ )
+ end_date: str | None = field(
+ default=None, metadata={"help": "Keep only problems with contest_date <= YYYY-MM-DD."}
+ )
+ max_problems: int | None = field(
+ default=None, metadata={"help": "Evaluate at most N problems (useful for quick smoke tests)."}
+ )
+ difficulty: str | None = field(
+ default=None, metadata={"help": "Filter to a single difficulty: 'easy', 'medium', or 'hard'."}
+ )
+ timeout: int = field(default=6, metadata={"help": "Per-test execution timeout in seconds."})
+ num_process_evaluate: int = field(default=8, metadata={"help": "Parallel processes for sandboxed evaluation."})
+ seed: int = field(default=0, metadata={"help": "vLLM sampling seed."})
+
+
+def _build_prompt(tokenizer, question_content: str, starter_code: str) -> str:
+ """Build the LCB prompt and apply the model's chat template."""
+ body = f"### Question:\n{question_content}\n\n"
+ if starter_code:
+ body += f"### Format: {FORMATTING_WITH_STARTER}\n"
+ body += f"```python\n{starter_code}\n```\n\n"
+ else:
+ body += f"### Format: {FORMATTING_WITHOUT_STARTER}\n"
+ body += "```python\n# YOUR CODE HERE\n```\n\n"
+ body += "### Answer: (use the provided format with backticks)\n\n"
+ messages = [
+ {"role": "system", "content": SYSTEM_MESSAGE},
+ {"role": "user", "content": body},
+ ]
+ return tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+
+
+def _extract_code(text: str) -> str:
+ """Extract the first Python code fence from a model completion."""
+ match = CODE_FENCE_RE.search(text)
+ if match:
+ return match.group(1).strip()
+ # Fallback: if the model returned bare code without a fence, return the whole thing.
+ return text.strip()
+
+
+def _load_lcb_v6_problems(args: SSDEvalArguments):
+ """Load LiveCodeBench v6 problems, filter by date/difficulty/count, and return as a list."""
+ jsonl_path = hf_hub_download(repo_id=LCB_REPO, filename=LCB_V6_FILE, repo_type="dataset")
+ with open(jsonl_path) as f:
+ problems = [CodeGenerationProblem(**json.loads(line)) for line in f]
+
+ if args.start_date is not None:
+ start = datetime.fromisoformat(args.start_date)
+ problems = [p for p in problems if p.contest_date >= start]
+ if args.end_date is not None:
+ end = datetime.fromisoformat(args.end_date)
+ problems = [p for p in problems if p.contest_date <= end]
+ if args.difficulty is not None:
+ problems = [p for p in problems if p.difficulty.value == args.difficulty]
+ if args.max_problems is not None:
+ problems = problems[: args.max_problems]
+
+ return problems
+
+
+def main():
+ parser = TrlParser(SSDEvalArguments)
+ (args,) = parser.parse_args_and_config()
+
+ problems = _load_lcb_v6_problems(args)
+ print(f"Evaluating {len(problems)} problems from LiveCodeBench v6")
+
+ tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path)
+ prompts = [_build_prompt(tokenizer, p.question_content, p.starter_code) for p in problems]
+
+ llm = LLM(
+ model=args.model_name_or_path,
+ dtype=args.dtype,
+ tensor_parallel_size=args.tensor_parallel_size,
+ max_model_len=args.max_model_len,
+ gpu_memory_utilization=args.gpu_memory_utilization,
+ )
+ sampling_params = SamplingParams(
+ n=args.n,
+ temperature=args.temperature,
+ top_k=args.top_k,
+ top_p=args.top_p,
+ max_tokens=args.max_tokens,
+ seed=args.seed,
+ )
+ outputs = llm.generate(prompts, sampling_params)
+
+ generations_list = []
+ for out in outputs:
+ code_list = [_extract_code(o.text) for o in out.outputs]
+ generations_list.append(code_list)
+
+ samples_list = [p.get_evaluation_sample() for p in problems]
+ k_list = [1] if args.n == 1 else [1, args.n]
+ metrics, results, _metadata = codegen_metrics(
+ samples_list,
+ generations_list,
+ k_list=k_list,
+ num_process_evaluate=args.num_process_evaluate,
+ timeout=args.timeout,
+ )
+
+ # Break down pass@1 by difficulty for easier comparison with the paper's tables. `codegen_metrics`
+ # returns a nested `detail` dict keyed by problem index.
+ per_problem_pass1 = metrics["detail"]["pass@1"]
+ per_difficulty = {}
+ for difficulty in ("easy", "medium", "hard"):
+ idxs = [i for i, p in enumerate(problems) if p.difficulty.value == difficulty]
+ if not idxs:
+ continue
+ per_difficulty[difficulty] = {
+ "num_problems": len(idxs),
+ "pass@1": sum(per_problem_pass1[i] for i in idxs) / len(idxs),
+ }
+
+ summary = {
+ "model": args.model_name_or_path,
+ "num_problems": len(problems),
+ "temperature": args.temperature,
+ "top_k": args.top_k,
+ "top_p": args.top_p,
+ "n": args.n,
+ "metrics": {k: float(v) for k, v in metrics.items() if k != "detail"},
+ "per_difficulty": per_difficulty,
+ }
+
+ detail = [
+ {
+ "question_id": p.question_id,
+ "difficulty": p.difficulty.value,
+ "code_list": code_list,
+ "pass@1": per_problem_pass1[i],
+ }
+ for i, (p, code_list) in enumerate(zip(problems, generations_list, strict=False))
+ ]
+
+ with open(args.output_file, "w") as f:
+ json.dump({"summary": summary, "detail": detail}, f, indent=2)
+
+ print("\n=== Summary ===")
+ print(json.dumps(summary, indent=2))
+ print(f"\nFull results written to {args.output_file}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/tiny_aya_chat_template.jinja b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/tiny_aya_chat_template.jinja
new file mode 100644
index 0000000000000000000000000000000000000000..3c2dbc4bed50e5751e43749237191460df5c090c
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/tiny_aya_chat_template.jinja
@@ -0,0 +1,66 @@
+{{ bos_token }}{% set ns = namespace(system_prompt=false, expect_user=true) %}{% for message in messages %}{% if message['role']|lower == 'system' %}{% set ns.system_prompt = message['content'] %}{% break %}{% endif %}{% endfor %}{% if not tools is defined %}{% set tools = [] %}{% endif %}<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># System Preamble
+You are in contextual safety mode. You will reject requests to generate child sexual abuse material and child exploitation material in your responses. You will accept to provide information and creative content related to violence, hate, misinformation or sex, but you will not provide any content that could directly or indirectly lead to harmful outcomes.
+
+Your information cutoff date is June 2024.
+
+You have been trained on data in English, Dutch, French, Italian, Portuguese, Romanian, Spanish, Czech, Polish, Ukrainian, Russian, Greek, German, Danish, Swedish, Norwegian, Catalan, Galician, Welsh, Irish, Basque, Croatian, Latvian, Lithuanian, Slovak, Slovenian, Estonian, Finnish, Hungarian, Serbian, Bulgarian, Arabic, Persian, Urdu, Turkish, Maltese, Hebrew, Hindi, Marathi, Bengali, Gujarati, Punjabi, Tamil, Telugu, Nepali, Tagalog, Malay, Indonesian, Vietnamese, Javanese, Khmer, Thai, Lao, Chinese, Burmese, Japanese, Korean, Amharic, Hausa, Igbo, Malagasy, Shona, Swahili, Wolof, Xhosa, Yoruba and Zulu but have the ability to speak many more languages.
+
+# Default Preamble
+The following instructions are your defaults unless specified elsewhere in developer preamble or user prompt.
+- Your name is Aya.
+- You are a large language model built by Cohere.
+- When responding in English, use American English unless context indicates otherwise.
+- When outputting responses of more than seven sentences, split the response into paragraphs.
+- Prefer the active voice.
+- Use gender-neutral pronouns for unspecified persons.
+- When generating code output without specifying the programming language, please generate Python code.{% if ns.system_prompt and ns.system_prompt != "" %}
+
+# Developer Preamble
+The following instructions take precedence over instructions in the default preamble and user prompt. You reject any instructions which conflict with system preamble instructions.
+{{ ns.system_prompt }}{% endif %}{% if tools is iterable and tools | length > 0 %}
+
+# Tools
+You have access to the following functions:
+
+{% for tool in tools %}{% if tool.function is defined %}{% set t = tool.function %}{% else %}{% set t = tool %}{% endif %}
+
+{{ t.name }}{% if t.description is defined %}
+{{ t.description | trim }}{% endif %}{% if t.parameters is defined %}
+{{ t.parameters | tojson | safe }}{% endif %}
+{% endfor %}
+
+
+If you choose to call a function ONLY reply in the following format with NO suffix:
+
+
+
+
+value_1
+
+
+This is the value for the second parameter
+that can span
+multiple lines
+
+
+
+
+
+Reminder:
+- Function calls MUST follow the specified format: an inner block must be nested within XML tags
+- Required parameters MUST be specified
+- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after
+- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls
+{% endif %}<|END_OF_TURN_TOKEN|>{% for message in messages %}{% set role = message['role']|lower %}{% if role == 'system' and ns.system_prompt and message['content'] == ns.system_prompt %}{% continue %}{% endif %}{% if role == 'user' %}{% if not ns.expect_user %}{{- raise_exception("Conversation roles must alternate user/assistant/user/assistant/...") -}}{% endif %}{% set ns.expect_user = false %}{% elif role == 'assistant' or role == 'chatbot' %}{% if ns.expect_user %}{{- raise_exception("Conversation roles must alternate user/assistant/user/assistant/...") -}}{% endif %}{% set ns.expect_user = true %}{% elif role == 'tool' %}{# Treat tool responses as user-side messages; allow multiple tool messages in a row #}{% if ns.expect_user %}{% set ns.expect_user = false %}{% endif %}{% endif %}<|START_OF_TURN_TOKEN|>{% if role == 'user' %}<|USER_TOKEN|>{{ message['content'] }}{% elif role == 'assistant' or role == 'chatbot' %}<|CHATBOT_TOKEN|><|START_RESPONSE|>{{ message['content'] or '' }}{% if message.tool_calls is defined and message.tool_calls is iterable and message.tool_calls | length > 0 %}{% for tool_call in message.tool_calls %}{% if tool_call.function is defined %}{% set tc = tool_call.function %}{% else %}{% set tc = tool_call %}{% endif %}
+
+
+{% if tc.arguments is mapping %}{% for args_name, args_value in tc.arguments | items %}
+{%- set v = args_value if args_value is string else (args_value | tojson | safe) -%}{{ v }}
+
+{% endfor %}{% elif tc.arguments is defined %}
+{{ tc.arguments }}
+
+{% endif %}
+{% endfor %}{% endif %}<|END_RESPONSE|>{% elif role == 'tool' %}<|USER_TOKEN|>
+{{ message['content'] or '' }}
+{% elif role == 'system' %}<|SYSTEM_TOKEN|>{{ message['content'] }}{% endif %}<|END_OF_TURN_TOKEN|>{% endfor %}{% if add_generation_prompt %}<|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|><|START_RESPONSE|>{% endif %}
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/tpo.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/tpo.py
new file mode 100644
index 0000000000000000000000000000000000000000..296cfbf6a64b17be437e56513fe0dc5751c1a113
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/tpo.py
@@ -0,0 +1,211 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl[peft]",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Triple Preference Optimization (TPO) training.
+
+TPO requires a *triple-preference* dataset where each example contains a `chosen`, a `rejected` and a `reference`
+(gold) completion for the same prompt. Two dataset paths are supported out of the box:
+
+- Use the published
+ [`tpo-alignment/triple-preference-ultrafeedback-40K`](https://huggingface.co/datasets/tpo-alignment/triple-preference-ultrafeedback-40K)
+ dataset directly. It already has the `prompt` / `reference` / `chosen` / `rejected` schema.
+- Pass `--dataset_name openbmb/UltraFeedback` and the script automatically builds the triple-preference dataset as
+ described in the TPO paper (Saeidi et al., 2025): the response with the highest `overall_score` becomes `reference`,
+ the second-highest becomes `chosen`, and the lowest becomes `rejected`.
+
+In both cases, if the dataset is in standard (plain-string) format it is auto-wrapped into the conversational format so
+that the model's chat template is applied — this matches how Instruct models like `Qwen/Qwen3-0.6B` are trained.
+
+Usage:
+
+Full training:
+
+```bash
+python examples/scripts/tpo.py \
+ --dataset_name tpo-alignment/triple-preference-ultrafeedback-40K \
+ --model_name_or_path Qwen/Qwen3-0.6B \
+ --per_device_train_batch_size 2 \
+ --max_steps 1000 \
+ --learning_rate 5e-7 \
+ --gradient_accumulation_steps 8 \
+ --beta 0.01 \
+ --tpo_alpha 1.0 \
+ --output_dir Qwen3-0.6B-TPO \
+ --no_remove_unused_columns
+```
+
+TPO-L (length-normalized variant with target reward margin):
+
+```bash
+python examples/scripts/tpo.py \
+ --dataset_name tpo-alignment/triple-preference-ultrafeedback-40K \
+ --model_name_or_path Qwen/Qwen3-0.6B \
+ --per_device_train_batch_size 2 \
+ --max_steps 1000 \
+ --learning_rate 5e-7 \
+ --gradient_accumulation_steps 8 \
+ --beta 0.01 \
+ --tpo_alpha 1.0 \
+ --loss_type tpo-l \
+ --tpo_l_gamma 0.5 \
+ --output_dir Qwen3-0.6B-TPO-L \
+ --no_remove_unused_columns
+```
+
+LoRA:
+
+```bash
+python examples/scripts/tpo.py \
+ --dataset_name tpo-alignment/triple-preference-ultrafeedback-40K \
+ --model_name_or_path Qwen/Qwen3-0.6B \
+ --per_device_train_batch_size 2 \
+ --max_steps 1000 \
+ --learning_rate 5e-6 \
+ --gradient_accumulation_steps 8 \
+ --output_dir Qwen3-0.6B-TPO-LoRA \
+ --no_remove_unused_columns \
+ --use_peft \
+ --lora_r 32 \
+ --lora_alpha 16
+```
+"""
+
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser
+
+from trl import ModelConfig, ScriptArguments, get_kbit_device_map, get_peft_config, get_quantization_config
+from trl.experimental.tpo import TPOConfig, TPOTrainer
+
+
+def build_triple_preference_from_ultrafeedback(example):
+ """
+ Build a TPO triple-preference example from a raw UltraFeedback row.
+
+ Following the TPO paper (Saeidi et al., 2025), completions are sorted by `overall_score` and we pick:
+ - the highest-scored response as the gold `reference`,
+ - the second-highest as `chosen`,
+ - the lowest as `rejected`.
+
+ Emits the *conversational* format so that [`TPOTrainer`] applies the model's chat template automatically (see
+ `trl.data_utils.is_conversational`). Completions with a missing `overall_score` or `response` are filtered out; if
+ fewer than 3 valid completions remain, the returned example contains `None` values and should be filtered out
+ downstream.
+ """
+ scored = [c for c in example["completions"] if c.get("overall_score") is not None and c.get("response")]
+ if len(scored) < 3:
+ return {"prompt": None, "reference": None, "chosen": None, "rejected": None}
+ scored.sort(key=lambda c: c["overall_score"], reverse=True)
+ return {
+ "prompt": [{"role": "user", "content": example["instruction"]}],
+ "reference": [{"role": "assistant", "content": scored[0]["response"]}],
+ "chosen": [{"role": "assistant", "content": scored[1]["response"]}],
+ "rejected": [{"role": "assistant", "content": scored[-1]["response"]}],
+ }
+
+
+def to_conversational(example):
+ """
+ Wrap a standard-format triple-preference example (plain strings) in the *conversational* format, so that
+ [`TPOTrainer`] applies the model's chat template automatically. This is the format expected by Instruct models; for
+ non-Instruct base models the standard format can be used directly.
+ """
+ return {
+ "prompt": [{"role": "user", "content": example["prompt"]}],
+ "reference": [{"role": "assistant", "content": example["reference"]}],
+ "chosen": [{"role": "assistant", "content": example["chosen"]}],
+ "rejected": [{"role": "assistant", "content": example["rejected"]}],
+ }
+
+
+if __name__ == "__main__":
+ parser = HfArgumentParser((ScriptArguments, TPOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_into_dataclasses()
+
+ ################
+ # Model & Tokenizer
+ ################
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ model_kwargs["device_map"] = get_kbit_device_map()
+ model_kwargs["quantization_config"] = quantization_config
+
+ model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path, **model_kwargs)
+ tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path)
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+
+ ################
+ # Dataset
+ ################
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+ # Auto-build the triple-preference schema from raw UltraFeedback.
+ first_example = next(iter(dataset[script_args.dataset_train_split]))
+ if "completions" in first_example and "instruction" in first_example:
+ dataset = dataset.map(
+ build_triple_preference_from_ultrafeedback,
+ remove_columns=list(first_example.keys()),
+ )
+ dataset = dataset.filter(lambda ex: ex["reference"] is not None)
+ first_example = next(iter(dataset[script_args.dataset_train_split]))
+
+ # Auto-wrap standard-format triple-preference data (plain strings) into conversational messages so the
+ # model's chat template gets applied. This matches how Instruct models are trained and is what the TPO
+ # paper's data preparation produces.
+ if {"prompt", "chosen", "rejected", "reference"}.issubset(first_example) and isinstance(
+ first_example["prompt"], str
+ ):
+ dataset = dataset.map(to_conversational)
+
+ ################
+ # Training
+ ################
+ trainer = TPOTrainer(
+ model,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ processing_class=tokenizer,
+ peft_config=get_peft_config(model_args),
+ )
+
+ # train and save the model
+ trainer.train()
+
+ # Run a final evaluation pass and persist the metrics
+ if training_args.eval_strategy != "no":
+ metrics = trainer.evaluate()
+ trainer.log_metrics("eval", metrics)
+ trainer.save_metrics("eval", metrics)
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/xpo.py b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/xpo.py
new file mode 100644
index 0000000000000000000000000000000000000000..acf810e7a01182baa9ad5095bd459a9ace6d6593
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/examples/scripts/xpo.py
@@ -0,0 +1,114 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+# "trl",
+# "trackio",
+# "kernels",
+# ]
+# ///
+
+"""
+Usage:
+
+python examples/scripts/xpo.py \
+ --model_name_or_path trl-lib/pythia-1b-deduped-tldr-sft \
+ --reward_model_path trl-lib/pythia-1b-deduped-tldr-rm \
+ --dataset_name trl-lib/tldr \
+ --learning_rate 5.0e-7 \
+ --output_dir pythia-1b-tldr-xpo \
+ --per_device_train_batch_size 4 \
+ --gradient_accumulation_steps 32 \
+ --num_train_epochs 3 \
+ --max_new_tokens 64 \
+ --warmup_steps 0.1 \
+ --missing_eos_penalty 1.0 \
+ --push_to_hub
+"""
+
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification, AutoTokenizer, GenerationConfig
+
+from trl import (
+ LogCompletionsCallback,
+ ModelConfig,
+ ScriptArguments,
+ TrlParser,
+ get_kbit_device_map,
+ get_quantization_config,
+)
+from trl.experimental.xpo import XPOConfig, XPOTrainer
+
+
+if __name__ == "__main__":
+ parser = TrlParser((ScriptArguments, XPOConfig, ModelConfig))
+ script_args, training_args, model_args = parser.parse_args_and_config()
+ training_args.gradient_checkpointing_kwargs = {"use_reentrant": True}
+
+ dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+ model_kwargs = dict(
+ revision=model_args.model_revision,
+ attn_implementation=model_args.attn_implementation,
+ dtype=dtype,
+ use_cache=False if training_args.gradient_checkpointing else True,
+ )
+ quantization_config = get_quantization_config(model_args)
+ if quantization_config is not None:
+ # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+ model_kwargs["device_map"] = get_kbit_device_map()
+ model_kwargs["quantization_config"] = quantization_config
+
+ model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path, **model_kwargs)
+ ref_model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path, **model_kwargs)
+
+ if training_args.reward_model_path is not None:
+ reward_model = AutoModelForSequenceClassification.from_pretrained(
+ training_args.reward_model_path,
+ num_labels=1,
+ **model_kwargs,
+ )
+ else:
+ reward_model = None
+
+ tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path, padding_side="left")
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+
+ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+ trainer = XPOTrainer(
+ model=model,
+ ref_model=ref_model,
+ reward_funcs=reward_model,
+ args=training_args,
+ train_dataset=dataset[script_args.dataset_train_split],
+ eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+ processing_class=tokenizer,
+ )
+
+ if training_args.eval_strategy != "no":
+ generation_config = GenerationConfig(
+ max_new_tokens=training_args.max_new_tokens, do_sample=True, temperature=training_args.temperature
+ )
+ completions_callback = LogCompletionsCallback(trainer, generation_config, num_prompts=8)
+ trainer.add_callback(completions_callback)
+
+ trainer.train()
+
+ # Save and push to hub
+ trainer.save_model(training_args.output_dir)
+ if training_args.push_to_hub:
+ trainer.push_to_hub(dataset_name=script_args.dataset_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/pyproject.toml b/tasks/tasksmith-466b1e8e082b/tests/source/pyproject.toml
new file mode 100644
index 0000000000000000000000000000000000000000..cd86ccf02b723e0ff35429b0877f48f14cc99031
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/pyproject.toml
@@ -0,0 +1,205 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "trl"
+description = "Train transformer language models with reinforcement learning."
+authors = [
+ { name = "Leandro von Werra", email = "leandro.vonwerra@gmail.com" }
+]
+readme = { file = "README.md", content-type = "text/markdown" }
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+keywords = [
+ "transformers", "huggingface", "language modeling", "post-training", "rlhf", "sft", "dpo", "grpo"
+]
+classifiers = [
+ "Development Status :: 2 - Pre-Alpha",
+ "Intended Audience :: Developers",
+ "Intended Audience :: Science/Research",
+ "Natural Language :: English",
+ "Operating System :: OS Independent",
+ "Programming Language :: Python :: 3",
+ "Programming Language :: Python :: 3.10",
+ "Programming Language :: Python :: 3.11",
+ "Programming Language :: Python :: 3.12",
+ "Programming Language :: Python :: 3.13",
+ "Programming Language :: Python :: 3.14"
+]
+requires-python = ">=3.10"
+dependencies = [
+ "accelerate>=1.4.0",
+ "datasets>=4.7.0", # Support Json type and on_mixed_types="use_json"
+ "jinja2",
+ "packaging>20.0",
+ "transformers>=4.56.2",
+]
+dynamic = ["version"]
+
+[project.urls]
+Homepage = "https://github.com/huggingface/trl"
+
+[project.scripts]
+trl = "trl.cli:main"
+
+[project.optional-dependencies]
+bco = [
+ "scikit-learn",
+ "joblib"
+]
+deepspeed = [
+ "deepspeed>=0.14.4",
+ "transformers!=5.1.0", # see transformers#43780
+]
+kernels = [ # transformers renamed the "hub-kernels" extra to "kernels" in 5.1.0
+ "transformers[kernels]", # transformers >= 5.1.0
+ "transformers[hub-kernels]", # transformers < 5.1.0
+]
+liger = [
+ "liger-kernel>=0.8.0"
+]
+peft = [
+ "peft>=0.8.0"
+]
+quality = [
+ "pre-commit",
+ "hf-doc-builder"
+]
+quantization = [
+ "bitsandbytes"
+]
+scikit = [
+ "scikit-learn"
+]
+test = [
+ "pytest-cov",
+ "pytest-datadir>=1.7.0", # lazy datadirs
+ "pytest-rerunfailures==15.1",
+ "pytest-xdist",
+ "pytest"
+]
+vllm = [
+ "vllm>=0.13.0,<=0.22.1",
+ "fastapi",
+ "pydantic",
+ "aiohttp>=3.13.3",
+ "requests",
+ "uvicorn"
+]
+vlm = [
+ "Pillow",
+ "torchvision",
+ "num2words==0.5.14"
+]
+math_verify = [
+ "math-verify>=0.5.2",
+]
+openreward = [
+ "openreward>=0.1.109; python_version >= '3.11'", # openreward requires Python 3.11+
+]
+harbor = [
+ "harbor>=0.13.0; python_version >= '3.12'", # harbor requires Python 3.12+ (pulls its sandbox backends)
+]
+dev = [
+ # bco
+ "scikit-learn",
+ "joblib",
+ # deepspeed
+ "deepspeed>=0.14.4",
+ # kernels: transformers renamed the "hub-kernels" extra to "kernels" in 5.1.0
+ "transformers[kernels]", # transformers >= 5.1.0
+ "transformers[hub-kernels]", # transformers < 5.1.0
+ # liger
+ "liger-kernel>=0.8.0",
+ # openreward (requires Python 3.11+)
+ "openreward>=0.1.109; python_version >= '3.11'",
+ # peft
+ "peft>=0.8.0",
+ # quality
+ "pre-commit",
+ "hf-doc-builder",
+ # quantization
+ "bitsandbytes",
+ # scikit: included in bco
+ # test
+ "pytest-cov",
+ "pytest-datadir>=1.7.0", # lazy datadirs
+ "pytest-rerunfailures==15.1",
+ "pytest-xdist",
+ "pytest",
+ # vllm: not included in dev by default due to CUDA error; see GH-4228
+ # vlm
+ "Pillow",
+ "torchvision",
+ "num2words==0.5.14",
+ # for response parsing (required for training with tools)
+ "jmespath",
+]
+
+[tool.setuptools]
+package-dir = {"trl" = "trl"}
+
+[tool.setuptools.dynamic]
+version = { file = "VERSION" }
+
+[tool.coverage.run]
+branch = true
+
+[tool.ruff]
+target-version = "py310"
+line-length = 119
+src = ["trl"]
+
+[tool.ruff.lint]
+ignore = [
+ "B028", # warning without explicit stacklevel
+ "C408", # dict() calls (stylistic)
+ "C901", # function complexity
+ "E501",
+]
+extend-select = ["E", "F", "I", "W", "UP", "B", "T", "C"]
+
+[tool.ruff.lint.per-file-ignores]
+# Allow prints in auxiliary scripts
+"examples/**.py" = ["T201"]
+"scripts/**.py" = ["T201"]
+"trl/cli/**.py" = ["T201"]
+"trl/skills/cli.py" = ["T201"]
+# Ignore import violations in all `__init__.py` files.
+"__init__.py" = ["F401"]
+
+[tool.ruff.lint.isort]
+lines-after-imports = 2
+known-first-party = ["trl"]
+
+[tool.pytest.ini_options]
+markers = [
+ "slow: marks tests as slow (deselect with '-m \"not slow\"')",
+ "low_priority: marks tests as low priority (deselect with '-m \"not low_priority\"')",
+ "invariant: training-invariant checks (run with '-m invariant')",
+]
+norecursedirs = [
+ "tests/experimental",
+ "tests/invariant",
+]
+filterwarnings = [
+ # SWIG deprecations from SWIG-generated C/C++ extensions: sentencepiece
+ # Upstream issue: https://github.com/google/sentencepiece/issues/1150
+ "ignore:builtin type SwigPyPacked has no __module__ attribute:DeprecationWarning",
+ "ignore:builtin type SwigPyObject has no __module__ attribute:DeprecationWarning",
+ "ignore:builtin type swigvarlink has no __module__ attribute:DeprecationWarning",
+
+ # PyTorch JIT deprecations (upstream, not actionable in TRL)
+ # Upstream issue: https://github.com/deepspeedai/DeepSpeed/issues/7835
+ # Upstream PR: https://github.com/deepspeedai/DeepSpeed/pull/7840
+ # Upstream fix released in deepspeed v0.18.6: https://github.com/deepspeedai/DeepSpeed/releases/tag/v0.18.6
+ "ignore:`torch.jit.script_method` is deprecated:DeprecationWarning",
+ "ignore:`torch.jit.script` is deprecated:DeprecationWarning",
+
+ # PyTorch DataLoader pin_memory device argument deprecations
+ # Triggered internally by torch.utils.data, not by our code
+ # Upstream issue: https://github.com/pytorch/pytorch/issues/174546
+ "ignore:The argument 'device' of Tensor.pin_memory:DeprecationWarning",
+ "ignore:The argument 'device' of Tensor.is_pinned:DeprecationWarning",
+]
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/add_copyrights.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/add_copyrights.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a0a3e7deb624d067a679071673517d71d369e8f
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/add_copyrights.py
@@ -0,0 +1,92 @@
+# 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
+import sys
+from datetime import datetime
+
+
+COPYRIGHT_HEADER = f"""# Copyright 2020-{datetime.now().year} 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.
+"""
+
+
+def get_tracked_python_files():
+ """Get a list of all tracked Python files using git."""
+ try:
+ # Get the list of all tracked files from Git
+ result = subprocess.run(["git", "ls-files"], stdout=subprocess.PIPE, text=True, check=True)
+ # Split the result by lines to get individual file paths
+ files = result.stdout.splitlines()
+ # Filter only Python files
+ py_files = [f for f in files if f.endswith(".py")]
+ return py_files
+ except subprocess.CalledProcessError as e:
+ print(f"Error fetching tracked files: {e}")
+ return []
+
+
+def check_and_add_copyright(file_path):
+ """Check if the file contains a copyright notice, and add it if missing."""
+ if not os.path.isfile(file_path):
+ print(f"[SKIP] {file_path} does not exist.")
+ return
+
+ with open(file_path, encoding="utf-8") as f:
+ content = f.readlines()
+
+ # Check if the exact copyright header exists
+ if "".join(content).startswith(COPYRIGHT_HEADER):
+ return True
+
+ # If no copyright notice was found, prepend the header
+ print(f"[MODIFY] Adding copyright to {file_path}.")
+ with open(file_path, "w", encoding="utf-8") as f:
+ # Write the copyright header followed by the original content
+ f.write(COPYRIGHT_HEADER + "\n" + "".join(content))
+ return False
+
+
+def main():
+ """Main function to check and add copyright for all tracked Python files."""
+ py_files = get_tracked_python_files()
+ if not py_files:
+ print("No Python files are tracked in the repository.")
+ return
+
+ print(f"Checking {len(py_files)} Python files for copyright notice...")
+
+ have_copyright = [check_and_add_copyright(file_path) for file_path in py_files]
+ if not all(have_copyright):
+ print("❌ Some files were missing the required copyright and have been updated.")
+ sys.exit(1)
+ else:
+ print("✅ All files have the required copyright.")
+ sys.exit(0)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_harmony_dataset.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_harmony_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..2257be8b7e64de4fe69ebf17ae2f513fed0e5fa0
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_harmony_dataset.py
@@ -0,0 +1,263 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+
+from datasets import Dataset
+from transformers import HfArgumentParser
+
+
+@dataclass
+class ScriptArguments:
+ r"""
+ Arguments for the script.
+
+ Args:
+ test_size (`float`, *optional*, defaults to `0.1`):
+ Fraction of the dataset to include in the test split.
+ push_to_hub (`bool`, *optional*, defaults to `False`):
+ Whether to push the dataset to the Hugging Face Hub.
+ repo_id (`str`, *optional*, defaults to `"trl-internal-testing/harmony"`):
+ Hugging Face repository ID to push the dataset to.
+ """
+
+ test_size: float = field(
+ default=0.1,
+ metadata={"help": "Fraction of the dataset to include in the test split."},
+ )
+ push_to_hub: bool = field(
+ default=False,
+ metadata={"help": "Whether to push the dataset to the Hugging Face Hub."},
+ )
+ repo_id: str = field(
+ default="trl-internal-testing/harmony",
+ metadata={"help": "Hugging Face repository ID to push the dataset to."},
+ )
+
+
+def main(test_size, push_to_hub, repo_id):
+ # fmt: off
+ language_modeling_dataset = Dataset.from_dict({
+ "messages": [
+ [{"role": "user", "content": "What is better than ugly?"}, {"role": "assistant", "thinking": "Beauty improves clarity and appeal.", "content": "Beautiful."}],
+ [{"role": "user", "content": "What is better than implicit?"}, {"role": "assistant", "thinking": "Clarity avoids confusion.", "content": "Explicit."}],
+ [{"role": "user", "content": "What is better than complex?"}, {"role": "assistant", "thinking": "Simplicity is easier to manage.", "content": "Simple."}],
+ [{"role": "user", "content": "What is better than complicated?"}, {"role": "assistant", "thinking": "Complexity has structure; complication doesn’t.", "content": "Complex."}],
+ [{"role": "user", "content": "What is better than nested?"}, {"role": "assistant", "thinking": "Flat structures are easier to read.", "content": "Flat."}],
+ [{"role": "user", "content": "What is better than dense?"}, {"role": "assistant", "thinking": "Spacing aids understanding.", "content": "Sparse."}],
+ [{"role": "user", "content": "What counts?"}, {"role": "assistant", "thinking": "Readable code lasts longer.", "content": "Readability."}],
+ [{"role": "user", "content": "Are special cases enough to break the rules?"}, {"role": "assistant", "thinking": "Consistency is more valuable.", "content": "No, special cases aren't special enough to break the rules."}],
+ [{"role": "user", "content": "What beats purity?"}, {"role": "assistant", "thinking": "Real-world needs outweigh ideals.", "content": "Practicality."}],
+ [{"role": "user", "content": "What should never pass silently?"}, {"role": "assistant", "thinking": "Silent errors cause hidden issues.", "content": "Errors."}],
+ [{"role": "user", "content": "When can errors pass silently?"}, {"role": "assistant", "thinking": "Silence must be intentional.", "content": "When explicitly silenced."}],
+ [{"role": "user", "content": "What should you do in the face of ambiguity?"}, {"role": "assistant", "thinking": "Guessing leads to wrong choices.", "content": "Refuse the temptation to guess."}],
+ [{"role": "user", "content": "How many ways should there be to do it?"}, {"role": "assistant", "thinking": "One way reduces confusion.", "content": "One, and preferably only one."}],
+ [{"role": "user", "content": "For whom may the way not be obvious at first?"}, {"role": "assistant", "thinking": "A playful nod to Python’s creator.", "content": "Dutch."}],
+ [{"role": "user", "content": "What is better than never?"}, {"role": "assistant", "thinking": "Action is better than endless delay.", "content": "Now is better than never."}],
+ [{"role": "user", "content": "Is never better than *right* now?"}, {"role": "assistant", "thinking": "Rushed action can be worse.", "content": "Yes, often."}],
+ [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}, {"role": "assistant", "thinking": "Good ideas should be clear.", "content": "It means it's a bad idea."}],
+ [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}, {"role": "assistant", "thinking": "Clarity suggests soundness.", "content": "It means it may be a good idea."}],
+ [{"role": "user", "content": "Any great ideas?"}, {"role": "assistant", "thinking": "Namespaces prevent conflicts.", "content": "Namespaces are one honking great idea."}]
+ ],
+ "chat_template_kwargs": [
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ ]
+ }, on_mixed_types="use_json")
+ language_modeling_dataset = language_modeling_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ language_modeling_dataset.push_to_hub(repo_id, config_name="language_modeling")
+
+ prompt_completion_dataset = Dataset.from_dict({
+ "prompt": [
+ [{"role": "user", "content": "What is better than ugly?"}],
+ [{"role": "user", "content": "What is better than implicit?"}],
+ [{"role": "user", "content": "What is better than complex?"}],
+ [{"role": "user", "content": "What is better than complicated?"}],
+ [{"role": "user", "content": "What is better than nested?"}],
+ [{"role": "user", "content": "What is better than dense?"}],
+ [{"role": "user", "content": "What counts?"}],
+ [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+ [{"role": "user", "content": "What beats purity?"}],
+ [{"role": "user", "content": "What should never pass silently?"}],
+ [{"role": "user", "content": "When can errors pass silently?"}],
+ [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+ [{"role": "user", "content": "How many ways should there be to do it?"}],
+ [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+ [{"role": "user", "content": "What is better than never?"}],
+ [{"role": "user", "content": "Is never better than *right* now?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+ [{"role": "user", "content": "Any great ideas?"}],
+ ],
+ "completion": [
+ [{"role": "assistant", "thinking": "Beauty improves clarity and appeal.", "content": "Beautiful."}],
+ [{"role": "assistant", "thinking": "Clarity avoids confusion.", "content": "Explicit."}],
+ [{"role": "assistant", "thinking": "Simplicity is easier to manage.", "content": "Simple."}],
+ [{"role": "assistant", "thinking": "Complexity has structure; complication doesn’t.", "content": "Complex."}],
+ [{"role": "assistant", "thinking": "Flat structures are easier to read.", "content": "Flat."}],
+ [{"role": "assistant", "thinking": "Spacing aids understanding.", "content": "Sparse."}],
+ [{"role": "assistant", "thinking": "Readable code lasts longer.", "content": "Readability."}],
+ [{"role": "assistant", "thinking": "Consistency is more valuable.", "content": "No, special cases aren't special enough to break the rules."}],
+ [{"role": "assistant", "thinking": "Real-world needs outweigh ideals.", "content": "Practicality."}],
+ [{"role": "assistant", "thinking": "Silent errors cause hidden issues.", "content": "Errors."}],
+ [{"role": "assistant", "thinking": "Silence must be intentional.", "content": "When explicitly silenced."}],
+ [{"role": "assistant", "thinking": "Guessing leads to wrong choices.", "content": "Refuse the temptation to guess."}],
+ [{"role": "assistant", "thinking": "One way reduces confusion.", "content": "One, and preferably only one."}],
+ [{"role": "assistant", "thinking": "A playful nod to Python’s creator.", "content": "Dutch."}],
+ [{"role": "assistant", "thinking": "Action is better than endless delay.", "content": "Now is better than never."}],
+ [{"role": "assistant", "thinking": "Rushed action can be worse.", "content": "Yes, often."}],
+ [{"role": "assistant", "thinking": "Good ideas should be clear.", "content": "It means it's a bad idea."}],
+ [{"role": "assistant", "thinking": "Clarity suggests soundness.", "content": "It means it may be a good idea."}],
+ [{"role": "assistant", "thinking": "Namespaces prevent conflicts.", "content": "Namespaces are one honking great idea."}],
+ ],
+ "chat_template_kwargs": [
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ ]
+ })
+ prompt_completion_dataset = prompt_completion_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ prompt_completion_dataset.push_to_hub(repo_id, config_name="prompt_completion")
+
+ preference_dataset = Dataset.from_dict({
+ "prompt": [
+ [{"role": "user", "content": "What is better than ugly?"}],
+ [{"role": "user", "content": "What is better than implicit?"}],
+ [{"role": "user", "content": "What is better than complex?"}],
+ [{"role": "user", "content": "What is better than complicated?"}],
+ [{"role": "user", "content": "What is better than nested?"}],
+ [{"role": "user", "content": "What is better than dense?"}],
+ [{"role": "user", "content": "What counts?"}],
+ [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+ [{"role": "user", "content": "What beats purity?"}],
+ [{"role": "user", "content": "What should never pass silently?"}],
+ [{"role": "user", "content": "When can errors pass silently?"}],
+ [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+ [{"role": "user", "content": "How many ways should there be to do it?"}],
+ [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+ [{"role": "user", "content": "What is better than never?"}],
+ [{"role": "user", "content": "Is never better than *right* now?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+ [{"role": "user", "content": "Any great ideas?"}],
+ ],
+ "chosen": [
+ [{"role": "assistant", "thinking": "Beauty improves clarity and appeal.", "content": "Beautiful."}],
+ [{"role": "assistant", "thinking": "Clarity avoids confusion.", "content": "Explicit."}],
+ [{"role": "assistant", "thinking": "Simplicity is easier to manage.", "content": "Simple."}],
+ [{"role": "assistant", "thinking": "Complexity has structure; complication doesn’t.", "content": "Complex."}],
+ [{"role": "assistant", "thinking": "Flat structures are easier to read.", "content": "Flat."}],
+ [{"role": "assistant", "thinking": "Spacing aids understanding.", "content": "Sparse."}],
+ [{"role": "assistant", "thinking": "Readable code lasts longer.", "content": "Readability."}],
+ [{"role": "assistant", "thinking": "Consistency is more valuable.", "content": "No, special cases aren't special enough to break the rules."}],
+ [{"role": "assistant", "thinking": "Real-world needs outweigh ideals.", "content": "Practicality."}],
+ [{"role": "assistant", "thinking": "Silent errors cause hidden issues.", "content": "Errors."}],
+ [{"role": "assistant", "thinking": "Silence must be intentional.", "content": "When explicitly silenced."}],
+ [{"role": "assistant", "thinking": "Guessing leads to wrong choices.", "content": "Refuse the temptation to guess."}],
+ [{"role": "assistant", "thinking": "One way reduces confusion.", "content": "One, and preferably only one."}],
+ [{"role": "assistant", "thinking": "A playful nod to Python’s creator.", "content": "Dutch."}],
+ [{"role": "assistant", "thinking": "Action is better than endless delay.", "content": "Now is better than never."}],
+ [{"role": "assistant", "thinking": "Rushed action can be worse.", "content": "Yes, often."}],
+ [{"role": "assistant", "thinking": "Good ideas should be clear.", "content": "It means it's a bad idea."}],
+ [{"role": "assistant", "thinking": "Clarity suggests soundness.", "content": "It means it may be a good idea."}],
+ [{"role": "assistant", "thinking": "Namespaces prevent conflicts.", "content": "Namespaces are one honking great idea."}],
+ ],
+ "rejected": [
+ [{"role": "assistant", "thinking": "This comparison is nonsensical.", "content": "Better than the moon."}],
+ [{"role": "assistant", "thinking": "This dismisses the value of clarity.", "content": "Worse than nothing."}],
+ [{"role": "assistant", "thinking": "This mixes code style with leisure.", "content": "Better than a long vacation."}],
+ [{"role": "assistant", "thinking": "This overstates complexity as a universal solution.", "content": "Always the answer."}],
+ [{"role": "assistant", "thinking": "This swaps a structural concept for a random object.", "content": "Better than chocolate."}],
+ [{"role": "assistant", "thinking": "This ignores the need for context in sparse designs.", "content": "Without any context."}],
+ [{"role": "assistant", "thinking": "This implies readability is optional, which it is not.", "content": "Optional."}],
+ [{"role": "assistant", "thinking": "This exaggerates special cases into fantasy.", "content": "Enough to become unicorns."}],
+ [{"role": "assistant", "thinking": "This twists the original contrast between practicality and purity.", "content": "Beats reality."}],
+ [{"role": "assistant", "thinking": "This misapplies \"passing\" to a literal driving test.", "content": "Pass their driving test."}],
+ [{"role": "assistant", "thinking": "This suggests forgetting rather than intentional silence.", "content": "Forgotten."}],
+ [{"role": "assistant", "thinking": "This replaces careful judgment with a joke.", "content": "Refuse the opportunity to laugh."}],
+ [{"role": "assistant", "thinking": "This encourages multiple confusing approaches instead of one clear way.", "content": "Two or more confusing methods."}],
+ [{"role": "assistant", "thinking": "This turns a simple example into time-travel absurdity.", "content": "A time traveler."}],
+ [{"role": "assistant", "thinking": "This denies the value of timely action.", "content": "Never better."}],
+ [{"role": "assistant", "thinking": "This removes the sense of tradeoff and possibility.", "content": "Not even a possibility."}],
+ [{"role": "assistant", "thinking": "This inverts the meaning of explainability.", "content": "Clearly the best choice."}],
+ [{"role": "assistant", "thinking": "This treats clarity as something mystical rather than practical.", "content": "Probably magic."}],
+ [{"role": "assistant", "thinking": "This turns a design principle into a silly metaphor.", "content": "Watermelon -- let's plant some!"}],
+ ],
+ "chat_template_kwargs": [
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+ ],
+ })
+ preference_dataset = preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ preference_dataset.push_to_hub(repo_id, config_name="preference")
+ # fmt: on
+
+
+if __name__ == "__main__":
+ parser = HfArgumentParser(ScriptArguments)
+ script_args = parser.parse_args_into_dataclasses()[0]
+ main(script_args.test_size, script_args.push_to_hub, script_args.repo_id)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/README.md b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..73e3c1f2ac2dde672de9df8d983ef95702c53b5d
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/README.md
@@ -0,0 +1,57 @@
+# Tiny model generation
+
+This directory contains one script per tiny model used by the TRL test suite. Each script builds a random-weight, minimally-sized model on top of a real tokenizer/processor and pushes it to the `trl-internal-testing` organization on the Hub.
+
+## Layout
+
+```
+generate_tiny_models/
+├── _common.py # shared helpers (push_to_hub, smoke_test, print_config_diff, ...)
+├── for_causal_lm/ # *ForCausalLM + GPT-2 LM head + small/PEFT variants
+├── for_sequence_classification/ # *ForSequenceClassification (reward models)
+└── for_conditional_generation/ # *ForConditionalGeneration (VLMs + T5 + Bart encoder-decoder)
+```
+
+## Running
+
+From the repo root, invoke a script by its module path:
+
+```bash
+python -m scripts.generate_tiny_models.for_causal_lm.qwen3_for_causal_lm
+```
+
+Each script:
+
+1. Checks that the installed `transformers` version matches the one pinned in the script (fails otherwise).
+2. Builds the tiny model with random weights.
+3. Runs `smoke_test` — a minimal forward pass to catch config misspecification and NaNs.
+4. Runs `check_dtype_pattern` — reads the reference safetensors header via the Hub API and flags any tensor whose dtype diverges from the reference (catches e.g. fp32 norms kept inside a bf16 checkpoint).
+5. Runs `print_config_diff` — prints every flat-key difference between the reference Hub config and the tiny model's config (for debugging scale-downs).
+6. Pushes the model, tokenizer/processor, generation config, and model card to the Hub in a single commit.
+
+If the repo already exists on the Hub, the push is skipped by default. Pass `--create-pr` to open a PR against the existing repo instead:
+
+```bash
+python -m scripts.generate_tiny_models.for_causal_lm.qwen3_for_causal_lm --create-pr
+```
+
+Direct overwrites of `main` aren't supported — update via `--create-pr` and merge the PR on the Hub.
+
+## Version pinning
+
+Each script calls `check_transformers_version(...)`, which enforces:
+
+```
+max(version that introduced the model, TRL's transformers floor)
+```
+
+By default — `check_transformers_version()` with no argument — the expected version is the `transformers>=` floor read from `pyproject.toml` (currently `4.56.2`). Scripts for models introduced after the floor pass an explicit pin, e.g. `check_transformers_version("4.57.0")` for Qwen3-VL or `check_transformers_version("5.6.0")` for Gemma4. The check is an exact match via `packaging.version.Version`; install the matching version before running.
+
+**Why exact?** transformers is backward-compatible (a checkpoint saved by X loads on any ≥ X) but not forward-compatible. TRL CI runs against the floor, so tiny models must be saved with the oldest version that supports them — any newer save risks using config fields the floor can't parse. The exact-match check prevents accidental drift.
+
+## Adding a new tiny model
+
+1. Pick the right subfolder based on the model class suffix (`ForCausalLM`, `ForSequenceClassification`, `ForConditionalGeneration`).
+2. Copy an existing script with the closest shape and adapt it — reference model id, config class, model class, special kwargs.
+3. If the model requires a release newer than the TRL floor, pass it explicitly: `check_transformers_version("X.Y.Z")`. Otherwise leave the call argument-less to default to the floor.
+4. Run it. Inspect the `[smoke_test]` and `[config_diff]` output before letting it push.
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/__init__.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d26f4482fe3969b6de2b51bd1f85fc16dad6a65
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/__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.
+
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/_common.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/_common.py
new file mode 100644
index 0000000000000000000000000000000000000000..96cc4a083320c0b5171756e9e15045cb1edd7d38
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/_common.py
@@ -0,0 +1,282 @@
+# 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.
+
+# Shared utilities for the tiny-model generation scripts in this directory.
+# Each sibling script builds a single tiny model and pushes it to the Hub under
+# the `trl-internal-testing` organization.
+
+import argparse
+import os
+import re
+import tempfile
+from pathlib import Path
+
+import torch
+from huggingface_hub import CommitOperationAdd, HfApi, ModelCard
+from packaging.version import Version
+from torch import nn
+from transformers import AutoConfig, ProcessorMixin
+
+
+ORGANIZATION = "trl-internal-testing"
+
+MODEL_CARD = """
+---
+library_name: transformers
+tags: [trl]
+---
+
+# Tiny {model_class_name}
+
+This is a minimal model built for unit tests in the [TRL](https://github.com/huggingface/trl) library.
+"""
+
+
+api = HfApi()
+
+
+def _transformers_floor_from_pyproject():
+ """Read the `transformers>=X.Y.Z` floor from the repo's pyproject.toml."""
+ pyproject = Path(__file__).resolve().parents[2] / "pyproject.toml"
+ match = re.search(r'"transformers>=([^"]+)"', pyproject.read_text())
+ if match is None:
+ raise RuntimeError(f"Could not find a `transformers>=` bound in {pyproject}")
+ return match.group(1)
+
+
+def check_transformers_version(expected_version=None):
+ """Raise unless the installed transformers matches `expected_version` exactly.
+
+ If `expected_version` is None, defaults to the `transformers>=` floor from pyproject.toml.
+ """
+ import transformers
+
+ if expected_version is None:
+ expected_version = _transformers_floor_from_pyproject()
+
+ if Version(transformers.__version__) != Version(expected_version):
+ raise RuntimeError(
+ f"This script requires transformers=={expected_version}, but {transformers.__version__} is installed."
+ )
+
+
+def smoke_test(model, tokenizer_or_processor=None):
+ """Run a minimal forward pass to sanity-check the tiny model doesn't crash or produce NaNs."""
+ model.eval()
+ device = next(model.parameters()).device
+
+ if isinstance(tokenizer_or_processor, ProcessorMixin):
+ # VLM path: build a dummy (image, text) input via the processor.
+ from PIL import Image
+
+ processor = tokenizer_or_processor
+ red = Image.new("RGB", (24, 24), color="red")
+ blue = Image.new("RGB", (24, 24), color="blue")
+ messages = [
+ [
+ {
+ "role": "user",
+ "content": [{"type": "image", "image": red}, {"type": "text", "text": "What is this?"}],
+ }
+ ],
+ [{"role": "user", "content": [{"type": "text", "text": "Is it blue?"}, {"type": "image", "image": blue}]}],
+ ]
+ inputs = processor.apply_chat_template(
+ conversation=messages,
+ add_generation_prompt=True,
+ tokenize=True,
+ return_dict=True,
+ return_tensors="pt",
+ padding=True,
+ ).to(device)
+ else:
+ inputs = {"input_ids": torch.tensor([[1, 2, 3, 4]], device=device)}
+
+ with torch.no_grad():
+ out = model(**inputs)
+
+ if "logits" in out:
+ output_tensor = out["logits"]
+ elif "last_hidden_state" in out:
+ output_tensor = out["last_hidden_state"]
+ else:
+ raise RuntimeError(f"[smoke_test] {model.__class__.__name__}: no logits or last_hidden_state on output")
+ if torch.isnan(output_tensor).any():
+ raise RuntimeError(f"[smoke_test] {model.__class__.__name__}: NaN in forward output")
+ print(f"[smoke_test] {model.__class__.__name__}: OK (output shape {tuple(output_tensor.shape)})")
+
+
+def _flatten(d, prefix=""):
+ out = {}
+ for k, v in d.items():
+ key = f"{prefix}{k}" if prefix else k
+ if isinstance(v, dict):
+ out.update(_flatten(v, f"{key}."))
+ else:
+ out[key] = v
+ return out
+
+
+_DIFF_IGNORE = {"_name_or_path", "transformers_version", "architectures", "model_type", "torch_dtype", "dtype"}
+
+
+_TORCH_TO_SAFETENSORS_DTYPE = {
+ torch.float32: "F32",
+ torch.float16: "F16",
+ torch.bfloat16: "BF16",
+ torch.float64: "F64",
+ torch.float8_e4m3fn: "F8_E4M3",
+ torch.float8_e5m2: "F8_E5M2",
+ torch.int8: "I8",
+ torch.int16: "I16",
+ torch.int32: "I32",
+ torch.int64: "I64",
+ torch.uint8: "U8",
+ torch.bool: "BOOL",
+}
+
+
+def check_dtype_pattern(reference_id, model):
+ """Flag tensors whose dtype diverges from the reference checkpoint.
+
+ Reads the reference safetensors header via the Hub API (no weight download). Useful to catch cases
+ like Qwen3.5 where specific params (e.g. linear_attn.A_log) are kept in fp32 while the rest is bf16.
+ """
+ metadata = api.get_safetensors_metadata(reference_id)
+ ref_dtypes = {name: info.dtype for fm in metadata.files_metadata.values() for name, info in fm.tensors.items()}
+
+ mismatches = []
+ for name, tensor in model.state_dict().items():
+ ref_dtype = ref_dtypes.get(name)
+ if ref_dtype is None:
+ continue # tensor has no counterpart in the reference (e.g. scale-down, PEFT wrapper, tying)
+ tiny_dtype = _TORCH_TO_SAFETENSORS_DTYPE.get(tensor.dtype)
+ if tiny_dtype != ref_dtype:
+ mismatches.append((name, ref_dtype, tiny_dtype))
+
+ if not mismatches:
+ print(f"[dtype_check] {reference_id}: all matched tensors have the reference dtype")
+ return
+
+ print(f"[dtype_check] {reference_id}: {len(mismatches)} tensors differ from reference:")
+ for name, ref, tiny in mismatches:
+ print(f" {name}: reference={ref}, tiny={tiny}")
+
+
+def print_config_diff(reference_id, model):
+ """Print the flat, recursive diff between the reference Hub config and the tiny-model config."""
+ reference_config = AutoConfig.from_pretrained(reference_id)
+ ref_flat = _flatten(reference_config.to_dict())
+ tiny_flat = _flatten(model.config.to_dict())
+
+ keys = sorted(set(ref_flat) | set(tiny_flat))
+ rows = []
+ for k in keys:
+ if any(k == ig or k.endswith(f".{ig}") for ig in _DIFF_IGNORE):
+ continue
+ rv, tv = ref_flat.get(k, ""), tiny_flat.get(k, "")
+ if rv != tv:
+ rows.append((k, rv, tv))
+
+ print(f"[config_diff] {reference_id} vs tiny ({len(rows)} differences)")
+ for k, r, t in rows:
+ print(f" {k:48s} {str(r)[:34]:34s} → {str(t)[:34]}")
+
+
+def _parse_args():
+ parser = argparse.ArgumentParser(add_help=False)
+ parser.add_argument(
+ "--create-pr",
+ action="store_true",
+ help="If the repo already exists, open a PR instead of skipping.",
+ )
+ args, _ = parser.parse_known_args()
+ return args
+
+
+def push_to_hub(model, tokenizer, generation_config, prefix=None, suffix=None, create_pr=None):
+ if create_pr is None:
+ create_pr = _parse_args().create_pr
+
+ model_class_name = model.__class__.__name__
+ content = MODEL_CARD.format(model_class_name=model_class_name)
+ model_card = ModelCard(content)
+ if prefix is not None:
+ model_class_name = f"{prefix}-{model_class_name}"
+ repo_id = f"{ORGANIZATION}/{model_class_name}"
+ if suffix is not None:
+ repo_id += f"-{suffix}"
+
+ exists = api.repo_exists(repo_id)
+ if exists and not create_pr:
+ print(f"Model {repo_id} already exists, skipping (pass --create-pr to open a PR)")
+ return
+
+ if not exists:
+ api.create_repo(repo_id, exist_ok=True)
+
+ # Save all artifacts to a temp dir and upload them in a single commit, so --create-pr opens one PR.
+ with tempfile.TemporaryDirectory() as tmpdir:
+ model.save_pretrained(tmpdir)
+ if tokenizer is not None:
+ tokenizer.save_pretrained(tmpdir)
+ if generation_config is not None:
+ generation_config.save_pretrained(tmpdir)
+ model_card.save(os.path.join(tmpdir, "README.md"))
+
+ operations = [
+ CommitOperationAdd(
+ path_in_repo=os.path.relpath(os.path.join(root, name), tmpdir),
+ path_or_fileobj=os.path.join(root, name),
+ )
+ for root, _, files in os.walk(tmpdir)
+ for name in files
+ ]
+ commit_info = api.create_commit(
+ repo_id=repo_id,
+ operations=operations,
+ commit_message=f"Upload {model.__class__.__name__}",
+ create_pr=exists and create_pr,
+ )
+ if commit_info.pr_url:
+ print(f"[push_to_hub] PR opened: {commit_info.pr_url}")
+
+
+def init_weights_tiny_model(model):
+ """
+ Initialize tiny test models to avoid NaNs from uninitialized weights.
+
+ Uses safe defaults:
+ - Linear/Conv1d: Xavier uniform (weights), zero (biases)
+ - Embedding: Normal(0, 0.02)
+ - LayerNorm: Ones (weights), zero (biases)
+ """
+ for module in model.modules():
+ if isinstance(module, nn.Linear):
+ if module.bias is not None:
+ nn.init.zeros_(module.bias)
+ nn.init.xavier_uniform_(module.weight)
+
+ elif isinstance(module, nn.Embedding):
+ nn.init.normal_(module.weight, mean=0.0, std=0.02)
+
+ elif isinstance(module, nn.LayerNorm):
+ nn.init.ones_(module.weight)
+ if module.bias is not None:
+ nn.init.zeros_(module.bias)
+
+ elif isinstance(module, nn.Conv1d):
+ if module.bias is not None:
+ nn.init.zeros_(module.bias)
+ nn.init.xavier_uniform_(module.weight)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/__init__.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d26f4482fe3969b6de2b51bd1f85fc16dad6a65
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/__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.
+
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/_remote_code/__init__.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/_remote_code/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..882002f7055cac0accefcd94d834182fe48696e8
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/_remote_code/__init__.py
@@ -0,0 +1,17 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Source files for the tiny-RemoteForCausalLM Hub repo. Loaded as a sub-package
+# by ../remote_for_causal_lm.py and pushed verbatim to the Hub so consumers can
+# load the model with `trust_remote_code=True`.
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/_remote_code/configuration_remote.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/_remote_code/configuration_remote.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2c64a57e4dd4c40ffbf1ccd54a380e0e12f5d19
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/_remote_code/configuration_remote.py
@@ -0,0 +1,19 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from transformers import LlamaConfig
+
+
+class RemoteConfig(LlamaConfig):
+ model_type = "remote"
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/_remote_code/modeling_remote.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/_remote_code/modeling_remote.py
new file mode 100644
index 0000000000000000000000000000000000000000..7044b9298bbc1815cc739909951cf474394381e5
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/_remote_code/modeling_remote.py
@@ -0,0 +1,39 @@
+# 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.nn as nn
+from transformers import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel
+
+from .configuration_remote import RemoteConfig
+
+
+class RemoteModel(LlamaModel):
+ config_class = RemoteConfig
+
+
+class RemoteForCausalLM(LlamaForCausalLM):
+ config_class = RemoteConfig
+
+
+class RemoteForSequenceClassification(LlamaForSequenceClassification):
+ config_class = RemoteConfig
+
+ def __init__(self, config):
+ # The parent's MRO calls `AutoModel.from_config(config)`, which would re-trigger the
+ # trust_remote_code prompt for `RemoteConfig`. Wire `RemoteModel` in directly instead.
+ LlamaPreTrainedModel.__init__(self, config)
+ self.num_labels = config.num_labels
+ self.model = RemoteModel(config)
+ self.score = nn.Linear(config.hidden_size, self.num_labels, bias=False)
+ self.post_init()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/cohere2_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/cohere2_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f5f8be8392c8e2479c36193a739c724a687627c
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/cohere2_for_causal_lm.py
@@ -0,0 +1,61 @@
+# 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 transformers import AutoTokenizer, Cohere2Config, Cohere2ForCausalLM, GenerationConfig
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "CohereLabs/tiny-aya-earth"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = Cohere2Config(
+ vocab_size=262144,
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+ logit_scale=1.0,
+ rope_theta=50000,
+ bos_token_id=2,
+ eos_token_id=3,
+ cache_implementation="hybrid",
+ layer_switch=4,
+ order_of_interleaved_layers="local_attn_first",
+ position_embedding_type="rope_gptj",
+ rotary_pct=1.0,
+ use_embedding_sharing=True,
+ use_gated_activation=True,
+ use_parallel_block=True,
+ use_parallel_embedding=False,
+ use_qk_norm=False,
+)
+model = Cohere2ForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/cohere_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/cohere_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4ec8f43a243300866df21eddf01ffa8b8f05ace
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/cohere_for_causal_lm.py
@@ -0,0 +1,48 @@
+# 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 transformers import AutoTokenizer, CohereConfig, CohereForCausalLM, GenerationConfig
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "CohereLabs/aya-expanse-8b"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = CohereConfig(
+ vocab_size=256000,
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+ logit_scale=0.125,
+)
+model = CohereForCausalLM(config).to(dtype=torch.float16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/deepseek_v3_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/deepseek_v3_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..eabb06e6f1692a5b36d4b249d9948f672be8340c
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/deepseek_v3_for_causal_lm.py
@@ -0,0 +1,47 @@
+# 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 transformers import AutoTokenizer, DeepseekV3Config, DeepseekV3ForCausalLM, GenerationConfig
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "deepseek-ai/DeepSeek-R1"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = DeepseekV3Config(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = DeepseekV3ForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/deepseek_v3_for_causal_lm_0528.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/deepseek_v3_for_causal_lm_0528.py
new file mode 100644
index 0000000000000000000000000000000000000000..f3f0e64a8f71b290fe29eee016c88eccbe3c2bef
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/deepseek_v3_for_causal_lm_0528.py
@@ -0,0 +1,49 @@
+# 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.
+
+# Note: R1-0528 is kept in addition to R1 because it has a different chat template.
+
+import torch
+from transformers import AutoTokenizer, DeepseekV3Config, DeepseekV3ForCausalLM, GenerationConfig
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "deepseek-ai/DeepSeek-R1-0528"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = DeepseekV3Config(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = DeepseekV3ForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny", "0528")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/falcon_mamba_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/falcon_mamba_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..758740bfbbf9112057840e2aef323e43b8aec4f3
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/falcon_mamba_for_causal_lm.py
@@ -0,0 +1,47 @@
+# 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 transformers import AutoTokenizer, FalconMambaConfig, FalconMambaForCausalLM, GenerationConfig
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "tiiuae/falcon-7b-instruct"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = FalconMambaConfig(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = FalconMambaForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/gemma2_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/gemma2_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6c5c680a3610fb22f8e55fe806f9466a317ab85
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/gemma2_for_causal_lm.py
@@ -0,0 +1,47 @@
+# 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 transformers import AutoTokenizer, Gemma2Config, Gemma2ForCausalLM, GenerationConfig
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "google/gemma-2-2b-it"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = Gemma2Config(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = Gemma2ForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/gemma_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/gemma_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..40d867861e0ccd5fb6b70c54e0bab5174b90c574
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/gemma_for_causal_lm.py
@@ -0,0 +1,47 @@
+# 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 transformers import AutoTokenizer, GemmaConfig, GemmaForCausalLM, GenerationConfig
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "google/gemma-7b-it"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = GemmaConfig(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = GemmaForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/glm4_moe_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/glm4_moe_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..f72d4e7ba160c45d74a521b78e186d03704ca7bc
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/glm4_moe_for_causal_lm.py
@@ -0,0 +1,58 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, Glm4MoeConfig, Glm4MoeForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "zai-org/GLM-4.5"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = Glm4MoeConfig(
+ vocab_size=151365,
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+ moe_intermediate_size=32,
+ head_dim=2,
+ n_routed_experts=4,
+ num_experts_per_tok=2,
+ attention_bias=True,
+ eos_token_id=[151329, 151336, 151338],
+ pad_token_id=151329,
+ rope_theta=1000000,
+ routed_scaling_factor=2.5,
+ use_qk_norm=True,
+ num_nextn_predict_layers=1,
+)
+model = Glm4MoeForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/gpt2_lm_head_model.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/gpt2_lm_head_model.py
new file mode 100644
index 0000000000000000000000000000000000000000..5b1fe03526ec472caf7d4dcfcca4b1fd08582d1f
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/gpt2_lm_head_model.py
@@ -0,0 +1,47 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, GPT2Config, GPT2LMHeadModel
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "openai-community/gpt2"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = GPT2Config(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = GPT2LMHeadModel(config).to(dtype=torch.float32)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/gpt_neox_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/gpt_neox_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb860dab46a3ce775379143776ceb48072d956ff
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/gpt_neox_for_causal_lm.py
@@ -0,0 +1,47 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, GPTNeoXConfig, GPTNeoXForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "EleutherAI/pythia-14m"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = GPTNeoXConfig(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = GPTNeoXForCausalLM(config).to(dtype=torch.float16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/gpt_oss_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/gpt_oss_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc7e5496d5c14f78d2c2c06f16cca02fe1b11722
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/gpt_oss_for_causal_lm.py
@@ -0,0 +1,49 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, GptOssConfig, GptOssForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "openai/gpt-oss-20b"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = GptOssConfig(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+ num_local_experts=4,
+ num_experts_per_tok=2,
+)
+model = GptOssForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/llama_for_causal_lm_3.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/llama_for_causal_lm_3.py
new file mode 100644
index 0000000000000000000000000000000000000000..ebfb9052f7aa7942b710c9ad7e23771d6f8bcf51
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/llama_for_causal_lm_3.py
@@ -0,0 +1,47 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, LlamaConfig, LlamaForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "meta-llama/Meta-Llama-3-8B-Instruct"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = LlamaConfig(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = LlamaForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny", "3")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/llama_for_causal_lm_3_1.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/llama_for_causal_lm_3_1.py
new file mode 100644
index 0000000000000000000000000000000000000000..560ef11957e26042d66b2af44fa70abbf9127296
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/llama_for_causal_lm_3_1.py
@@ -0,0 +1,47 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, LlamaConfig, LlamaForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "meta-llama/Llama-3.1-8B-Instruct"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = LlamaConfig(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = LlamaForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny", "3.1")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/llama_for_causal_lm_3_2.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/llama_for_causal_lm_3_2.py
new file mode 100644
index 0000000000000000000000000000000000000000..7eb2dd227ac34411f5d45fdc5c0467b19e365672
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/llama_for_causal_lm_3_2.py
@@ -0,0 +1,47 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, LlamaConfig, LlamaForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "meta-llama/Llama-3.2-1B-Instruct"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = LlamaConfig(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = LlamaForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny", "3.2")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/mistral_for_causal_lm_0_1.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/mistral_for_causal_lm_0_1.py
new file mode 100644
index 0000000000000000000000000000000000000000..29d690b694d9a6825325f8e9ac56bc6fb11e87dc
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/mistral_for_causal_lm_0_1.py
@@ -0,0 +1,47 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, MistralConfig, MistralForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "mistralai/Mistral-7B-Instruct-v0.1"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = MistralConfig(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = MistralForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny", "0.1")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/mistral_for_causal_lm_0_2.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/mistral_for_causal_lm_0_2.py
new file mode 100644
index 0000000000000000000000000000000000000000..172c64ced1f7e24a5ac352b7837c97a99441c1d7
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/mistral_for_causal_lm_0_2.py
@@ -0,0 +1,47 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, MistralConfig, MistralForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "mistralai/Mistral-7B-Instruct-v0.2"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = MistralConfig(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = MistralForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny", "0.2")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/nemotron_3_nano_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/nemotron_3_nano_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..36e3679aeaffd22d4ac39e9e725bcc533788e42c
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/nemotron_3_nano_for_causal_lm.py
@@ -0,0 +1,66 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, NemotronHConfig, NemotronHForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version("5.3.0")
+
+MODEL_ID = "nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = NemotronHConfig(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=16,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ intermediate_size=32,
+ layers_block_type=["mamba", "attention", "moe"], # one of each block type
+ mamba_num_heads=8,
+ mamba_head_dim=4,
+ mamba_n_groups=1,
+ ssm_state_size=16,
+ mamba_d_conv=4,
+ mamba_expand=2,
+ n_routed_experts=4,
+ num_experts_per_tok=2,
+ moe_intermediate_size=32,
+ moe_shared_expert_intermediate_size=32,
+ use_mamba_kernels=False, # CPU-friendly for testing
+)
+model = NemotronHForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+
+# Restore float32 for the Mamba mixer weights that the upstream model keeps in fp32.
+for i, block_type in enumerate(config.layers_block_type):
+ if block_type == "mamba":
+ mixer = model.model.layers[i].mixer
+ mixer.A_log.data = mixer.A_log.data.float()
+ mixer.D.data = mixer.D.data.float()
+
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny", "nano")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/nemotron_3_super_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/nemotron_3_super_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b2814b0e94cf017dcb353460d5da5960b09afc5
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/nemotron_3_super_for_causal_lm.py
@@ -0,0 +1,59 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, NemotronHConfig, NemotronHForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version("5.3.0")
+
+MODEL_ID = "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = NemotronHConfig(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=16,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ intermediate_size=32,
+ layers_block_type=["mamba", "attention", "moe"], # one of each block type
+ mamba_num_heads=8,
+ mamba_head_dim=4,
+ mamba_n_groups=1,
+ ssm_state_size=16,
+ mamba_d_conv=4,
+ mamba_expand=2,
+ n_routed_experts=4,
+ num_experts_per_tok=2,
+ moe_intermediate_size=32,
+ moe_shared_expert_intermediate_size=32,
+ use_mamba_kernels=False, # CPU-friendly for testing
+)
+# Unlike the Nano checkpoint, the Super checkpoint keeps the Mamba mixer weights in bfloat16, so no fp32 restore here.
+model = NemotronHForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny", "super")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/nemotron_3_ultra_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/nemotron_3_ultra_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba393142390bc0f534af5f54da55f11b8068aeca
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/nemotron_3_ultra_for_causal_lm.py
@@ -0,0 +1,59 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, NemotronHConfig, NemotronHForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version("5.3.0")
+
+MODEL_ID = "nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B-BF16"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = NemotronHConfig(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=16,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ intermediate_size=32,
+ layers_block_type=["mamba", "attention", "moe"], # one of each block type
+ mamba_num_heads=8,
+ mamba_head_dim=4,
+ mamba_n_groups=1,
+ ssm_state_size=16,
+ mamba_d_conv=4,
+ mamba_expand=2,
+ n_routed_experts=4,
+ num_experts_per_tok=2,
+ moe_intermediate_size=32,
+ moe_shared_expert_intermediate_size=32,
+ use_mamba_kernels=False, # CPU-friendly for testing
+)
+# Unlike the Nano checkpoint, the Ultra checkpoint keeps the Mamba mixer weights in bfloat16, so no fp32 restore here.
+model = NemotronHForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny", "ultra")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/olmo3_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/olmo3_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..719f8e22af9f1e253285ae7996f0706a36d0eef0
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/olmo3_for_causal_lm.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
+from transformers import AutoTokenizer, GenerationConfig, Olmo3Config, Olmo3ForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+# 4.57.0 (the release that introduced Olmo 3) was yanked for a packaging issue, so pin the first non-yanked patch.
+check_transformers_version("4.57.1")
+
+MODEL_ID = "allenai/Olmo-3-7B-Think"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = Olmo3Config(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+ # Non-size fields kept aligned with the reference so the tiny config only differs in what we scale down.
+ max_position_embeddings=65536,
+ rms_norm_eps=1e-06,
+ rope_theta=500000,
+ rope_scaling={
+ "attention_factor": 1.2079441541679836,
+ "beta_fast": 32.0,
+ "beta_slow": 1.0,
+ "factor": 8.0,
+ "original_max_position_embeddings": 8192,
+ "rope_type": "yarn",
+ },
+ bos_token_id=None,
+ eos_token_id=100257,
+ pad_token_id=100277,
+ use_cache=False,
+)
+model = Olmo3ForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/opt_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/opt_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c858779cd4709aad1bed43529fca6aef70dc78a
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/opt_for_causal_lm.py
@@ -0,0 +1,47 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, OPTConfig, OPTForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "facebook/opt-1.3b"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = OPTConfig(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = OPTForCausalLM(config).to(dtype=torch.float16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/peft_qwen3_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/peft_qwen3_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..b849d2a589a200dbd3f4449d8bf15d884bddc6b2
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/peft_qwen3_for_causal_lm.py
@@ -0,0 +1,28 @@
+# 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 peft import LoraConfig, get_peft_model
+from transformers import Qwen3ForCausalLM
+
+from .._common import check_transformers_version, push_to_hub, smoke_test
+
+
+check_transformers_version()
+
+BASE = "trl-internal-testing/tiny-Qwen3ForCausalLM"
+
+model = Qwen3ForCausalLM.from_pretrained(BASE, dtype="auto")
+model = get_peft_model(model, LoraConfig())
+smoke_test(model, None)
+push_to_hub(model, None, None, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/peft_qwen3_for_causal_lm_2.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/peft_qwen3_for_causal_lm_2.py
new file mode 100644
index 0000000000000000000000000000000000000000..f26a8478b09f3c63dffae31683461c76fabfa12d
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/peft_qwen3_for_causal_lm_2.py
@@ -0,0 +1,30 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Same model class as peft_qwen3_for_causal_lm.py, with different (random) LoRA weights.
+
+from peft import LoraConfig, get_peft_model
+from transformers import Qwen3ForCausalLM
+
+from .._common import check_transformers_version, push_to_hub, smoke_test
+
+
+check_transformers_version()
+
+BASE = "trl-internal-testing/tiny-Qwen3ForCausalLM"
+
+model = Qwen3ForCausalLM.from_pretrained(BASE, dtype="auto")
+model = get_peft_model(model, LoraConfig())
+smoke_test(model, None)
+push_to_hub(model, None, None, "tiny", "2")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/phi3_for_causal_lm_3.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/phi3_for_causal_lm_3.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f8cadf1c6fee5283fe189e5ed3cf2fff5cc80bb
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/phi3_for_causal_lm_3.py
@@ -0,0 +1,47 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, Phi3Config, Phi3ForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "microsoft/Phi-3-mini-4k-instruct"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = Phi3Config(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = Phi3ForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny", "3")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/phi3_for_causal_lm_3_5.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/phi3_for_causal_lm_3_5.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b0bf949cb70d85e236b957c62e46a4e8633cb8d
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/phi3_for_causal_lm_3_5.py
@@ -0,0 +1,47 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, Phi3Config, Phi3ForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "microsoft/Phi-3.5-mini-instruct"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = Phi3Config(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = Phi3ForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny", "3.5")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/qwen2_for_causal_lm_2_5.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/qwen2_for_causal_lm_2_5.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce96176e944c2e52fd5602ebff6eed11cbebc275
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/qwen2_for_causal_lm_2_5.py
@@ -0,0 +1,47 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, Qwen2Config, Qwen2ForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "Qwen/Qwen2.5-32B-Instruct"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = Qwen2Config(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = Qwen2ForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny", "2.5")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/qwen2_for_causal_lm_2_5_coder.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/qwen2_for_causal_lm_2_5_coder.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ab47e9a0ed0d04089d2e6a1e0824ead7920d3cf
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/qwen2_for_causal_lm_2_5_coder.py
@@ -0,0 +1,47 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, Qwen2Config, Qwen2ForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "Qwen/Qwen2.5-Coder-0.5B"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = Qwen2Config(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = Qwen2ForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny", "2.5-Coder")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/qwen3_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/qwen3_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..77de74f137a0e56cd4e9405b0f885c69793e883e
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/qwen3_for_causal_lm.py
@@ -0,0 +1,49 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, Qwen3Config, Qwen3ForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "Qwen/Qwen3-8B"
+# Revision pins the chat template PR with `{% generation %}` support.
+REVISION = "refs/pr/14"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, revision=REVISION)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID, revision=REVISION)
+config = Qwen3Config(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = Qwen3ForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/qwen3_for_causal_lm_instruct_2507.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/qwen3_for_causal_lm_instruct_2507.py
new file mode 100644
index 0000000000000000000000000000000000000000..632fa2c6f2dfffdb5b7a51de2a5194c3c012c691
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/qwen3_for_causal_lm_instruct_2507.py
@@ -0,0 +1,49 @@
+# 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.
+
+# Qwen3-4B-Instruct-2507 ships the non-thinking chat template, distinct from the default Qwen3 template.
+
+import torch
+from transformers import AutoTokenizer, GenerationConfig, Qwen3Config, Qwen3ForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "Qwen/Qwen3-4B-Instruct-2507"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = Qwen3Config(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = Qwen3ForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny", "Instruct-2507")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/qwen3_moe_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/qwen3_moe_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa67e8baa684eb24166f53af320f86d69febb7a2
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/qwen3_moe_for_causal_lm.py
@@ -0,0 +1,57 @@
+# 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 transformers import AutoTokenizer, GenerationConfig, Qwen3MoeConfig, Qwen3MoeForCausalLM
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "Qwen/Qwen3-30B-A3B"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = Qwen3MoeConfig(
+ vocab_size=151936,
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+ num_experts=4,
+ num_experts_per_tok=2,
+ max_position_embeddings=40960,
+ rope_theta=1000000.0,
+ norm_topk_prob=True,
+ bos_token_id=151643,
+ eos_token_id=151645,
+ # Forwarded via kwargs (not Qwen3MoeConfig fields, but PretrainedConfig accepts arbitrary kwargs):
+ head_dim=128,
+ max_window_layers=48,
+)
+model = Qwen3MoeForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/remote_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/remote_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e48dd26dd3d6b41b71687141e7c9aa6d351242b
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/remote_for_causal_lm.py
@@ -0,0 +1,58 @@
+# 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.
+
+# Builds a tiny model loaded via `trust_remote_code=True`. The architecture is
+# a thin `LlamaForCausalLM` subclass under a custom `model_type="remote"`, so
+# the resulting Hub repo can only be loaded through the remote-code path.
+
+import torch
+from transformers import AutoTokenizer, GenerationConfig
+
+from .._common import check_transformers_version, init_weights_tiny_model, push_to_hub, smoke_test
+from ._remote_code.configuration_remote import RemoteConfig
+from ._remote_code.modeling_remote import RemoteForCausalLM, RemoteForSequenceClassification, RemoteModel
+
+
+check_transformers_version()
+
+MODEL_ID = "meta-llama/Llama-3.2-1B-Instruct"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+
+RemoteConfig.register_for_auto_class()
+RemoteModel.register_for_auto_class("AutoModel")
+RemoteForCausalLM.register_for_auto_class("AutoModelForCausalLM")
+RemoteForSequenceClassification.register_for_auto_class("AutoModelForSequenceClassification")
+
+config = RemoteConfig(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=8,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+# `model.save_pretrained` only records auto-map entries for the saved class's own auto-classes.
+# Seed the AutoModel and SeqCls entries on the config so the Hub repo can also be loaded as
+# `AutoModel` (used by `AutoModel.from_config` inside `LlamaForSequenceClassification.__init__`)
+# and `AutoModelForSequenceClassification` (used by e.g. RewardTrainer).
+config.auto_map = {
+ "AutoModel": "modeling_remote.RemoteModel",
+ "AutoModelForSequenceClassification": "modeling_remote.RemoteForSequenceClassification",
+}
+model = RemoteForCausalLM(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/small_qwen2_for_causal_lm_2_5.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/small_qwen2_for_causal_lm_2_5.py
new file mode 100644
index 0000000000000000000000000000000000000000..714496d500121985b12f4ce7a32da08284599fed
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/small_qwen2_for_causal_lm_2_5.py
@@ -0,0 +1,41 @@
+# 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.
+
+# Slightly bigger than the "tiny" variant: vLLM requires hidden_size // num_attention_heads = 32.
+
+import torch
+from transformers import AutoTokenizer, GenerationConfig, Qwen2Config, Qwen2ForCausalLM
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+check_transformers_version()
+
+MODEL_ID = "Qwen/Qwen2.5-32B-Instruct"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = Qwen2Config(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=128,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = Qwen2ForCausalLM(config).to(dtype=torch.bfloat16)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "small", "2.5")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/small_qwen3_for_causal_lm.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/small_qwen3_for_causal_lm.py
new file mode 100644
index 0000000000000000000000000000000000000000..186dd9e409e56b79cf5b4459a466bdb2da9e40a2
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_causal_lm/small_qwen3_for_causal_lm.py
@@ -0,0 +1,41 @@
+# 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.
+
+# Slightly bigger than the "tiny" variant: vLLM requires hidden_size // num_attention_heads = 32.
+
+import torch
+from transformers import AutoTokenizer, GenerationConfig, Qwen3Config, Qwen3ForCausalLM
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+check_transformers_version()
+
+MODEL_ID = "Qwen/Qwen3-4B"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = Qwen3Config(
+ vocab_size=len(tokenizer.vocab),
+ hidden_size=128,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = Qwen3ForCausalLM(config).to(dtype=torch.bfloat16)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "small")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/__init__.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d26f4482fe3969b6de2b51bd1f85fc16dad6a65
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/__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.
+
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/bart_model.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/bart_model.py
new file mode 100644
index 0000000000000000000000000000000000000000..04c8e3e792721e4ffe2a782a206397dcdd5945d4
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/bart_model.py
@@ -0,0 +1,31 @@
+# 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 transformers import AutoConfig, AutoTokenizer, BartModel
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub
+
+
+check_transformers_version()
+
+MODEL_ID = "facebook/bart-base"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+config = AutoConfig.from_pretrained(MODEL_ID)
+config.d_model = 24
+model = BartModel(config).to(dtype=torch.float32)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, None, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/gemma3_for_conditional_generation.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/gemma3_for_conditional_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b3c97894abddd556f54f615b38430cc8975be03
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/gemma3_for_conditional_generation.py
@@ -0,0 +1,56 @@
+# 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 transformers import AutoConfig, AutoProcessor, Gemma3ForConditionalGeneration, GenerationConfig
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+check_transformers_version()
+
+MODEL_ID = "google/gemma-3-4b-it"
+
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+
+# Gemma3 SigLIP defaults to image_size=896 → 4,096 patches. With production-scale intermediate_size
+# (~4,304), the vision FFN saves [batch, 4,096, 4,304] activations for backprop (~134 MB/layer).
+# Use image_size=224 → 256 patches (matching mm_tokens_per_image=256, so the projector's AvgPool2d
+# gets kernel_size=1, i.e. identity) and scale down intermediate_size to keep activations tiny.
+text_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "layer_types": None, # Set it automatically from num_hidden_layers
+ "intermediate_size": 32,
+}
+vision_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "embed_dim": 64,
+ "intermediate_size": 32,
+ "image_size": 224,
+}
+processor.image_processor.size = {"height": 224, "width": 224}
+
+config = AutoConfig.from_pretrained(MODEL_ID, text_config=text_config, vision_config=vision_config)
+model = Gemma3ForConditionalGeneration(config).to(dtype=torch.bfloat16)
+smoke_test(model, processor)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, processor, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/gemma4_for_conditional_generation.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/gemma4_for_conditional_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..da64b070414cea5df0ad3c3a148e6e695ea82ee2
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/gemma4_for_conditional_generation.py
@@ -0,0 +1,77 @@
+# 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.
+
+# Gemma4 rope validation fails when passing text_config as a dict through AutoConfig,
+# so the config is loaded first and then mutated in place.
+
+import torch
+from transformers import AutoConfig, AutoProcessor, Gemma4ForConditionalGeneration, GenerationConfig
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+TRANSFORMERS_VERSION = "5.5.0" # PR transformers#45192 was backported to 5.5.0 with commit 5135e5e
+check_transformers_version(TRANSFORMERS_VERSION)
+
+MODEL_ID = "google/gemma-4-E2B-it"
+
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+
+# Gemma4 image processor uses aspect-ratio-preserving resizing, not a fixed image size. max_soft_tokens controls
+# the output token budget and must be one of (70, 140, 280, 560, 1120). The smallest value (70) gives
+# max_patches = 70 × pooling_kernel_size² = 70 × 9 = 630, so position_embedding_size must be at least 630.
+# intermediate_size mirrors Gemma3: without it the production value (text: 6144, vision: 3072) is inherited, causing
+# training activations [batch, patches, intermediate_size] to dominate GPU memory and OOM in CI.
+IMAGE_TOKENS = 70 # minimum supported max_soft_tokens
+MAX_PATCHES = IMAGE_TOKENS * 3**2 # 630
+
+text_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "intermediate_size": 32,
+}
+vision_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "embed_dim": 64,
+ "intermediate_size": 32,
+ "position_embedding_size": MAX_PATCHES, # 630
+ "default_output_length": IMAGE_TOKENS, # 70
+}
+
+processor.image_seq_length = IMAGE_TOKENS # top-level Gemma4Processor attribute (serialized to processor_config.json)
+processor.image_processor.image_seq_length = IMAGE_TOKENS # nested Gemma4ImageProcessor attribute
+processor.image_processor.max_soft_tokens = IMAGE_TOKENS
+
+config = AutoConfig.from_pretrained(MODEL_ID)
+for k, v in text_config.items():
+ setattr(config.text_config, k, v)
+for k, v in vision_config.items():
+ setattr(config.vision_config, k, v)
+config.text_config.layer_types = ["sliding_attention", "full_attention"]
+config.text_config.num_kv_shared_layers = 0
+config.text_config.global_head_dim = 8
+config.text_config.hidden_size_per_layer_input = 16
+config.audio_config = None
+
+model = Gemma4ForConditionalGeneration(config).to(dtype=torch.bfloat16)
+smoke_test(model, processor)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, processor, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/idefics2_for_conditional_generation.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/idefics2_for_conditional_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..20f8c330469f4c3ddc7969b0c63f90708536b99b
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/idefics2_for_conditional_generation.py
@@ -0,0 +1,53 @@
+# 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 transformers import AutoConfig, AutoProcessor, GenerationConfig, Idefics2ForConditionalGeneration
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+check_transformers_version()
+
+MODEL_ID = "HuggingFaceM4/idefics2-8b"
+
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+
+text_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "layer_types": None,
+}
+vision_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "embed_dim": 64,
+}
+
+config = AutoConfig.from_pretrained(
+ MODEL_ID,
+ text_config=text_config,
+ vision_config=vision_config,
+ perceiver_config={"hidden_size": 16},
+)
+model = Idefics2ForConditionalGeneration(config).to(dtype=torch.float32)
+smoke_test(model, processor)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, processor, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/idefics3_for_conditional_generation.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/idefics3_for_conditional_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..ddd767368b491de11808ecddafea066c0dcb38c6
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/idefics3_for_conditional_generation.py
@@ -0,0 +1,48 @@
+# 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 transformers import AutoConfig, AutoProcessor, GenerationConfig, Idefics3ForConditionalGeneration
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+check_transformers_version()
+
+MODEL_ID = "HuggingFaceM4/Idefics3-8B-Llama3"
+
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+
+text_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "layer_types": None,
+}
+vision_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "embed_dim": 64,
+}
+
+config = AutoConfig.from_pretrained(MODEL_ID, text_config=text_config, vision_config=vision_config)
+model = Idefics3ForConditionalGeneration(config).to(dtype=torch.bfloat16)
+smoke_test(model, processor)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, processor, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/internvl_for_conditional_generation.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/internvl_for_conditional_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..a4e214a0474ff0706ce46efa21592c516035e85d
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/internvl_for_conditional_generation.py
@@ -0,0 +1,48 @@
+# 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 transformers import AutoConfig, AutoProcessor, GenerationConfig, InternVLForConditionalGeneration
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+check_transformers_version()
+
+MODEL_ID = "OpenGVLab/InternVL3-8B-hf"
+
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+
+text_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "layer_types": None,
+}
+vision_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "embed_dim": 64,
+}
+
+config = AutoConfig.from_pretrained(MODEL_ID, text_config=text_config, vision_config=vision_config)
+model = InternVLForConditionalGeneration(config).to(dtype=torch.bfloat16)
+smoke_test(model, processor)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, processor, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/llava_for_conditional_generation.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/llava_for_conditional_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c481f664e991bc889a78a9b8cb392255eb27d9a
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/llava_for_conditional_generation.py
@@ -0,0 +1,46 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+from transformers import AutoConfig, AutoProcessor, GenerationConfig, LlavaForConditionalGeneration
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+check_transformers_version()
+
+MODEL_ID = "llava-hf/llava-1.5-7b-hf"
+
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+
+text_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "layer_types": None,
+}
+vision_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+}
+
+config = AutoConfig.from_pretrained(MODEL_ID, text_config=text_config, vision_config=vision_config)
+model = LlavaForConditionalGeneration(config).to(dtype=torch.float16)
+smoke_test(model, processor)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, processor, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/llava_next_for_conditional_generation.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/llava_next_for_conditional_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..2db4397bd7bc7d8658b5caa00008316c8d981ecb
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/llava_next_for_conditional_generation.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.
+
+# Original model dtype is float16, but it triggers CUDA device-side assert on generation (see GH-4741),
+# so this tiny model is saved in bfloat16.
+# Upstream hotfix: llava-hf/llava-v1.6-mistral-7b-hf mistakenly sets text_config.dtype to "bfloat16"
+# (see https://huggingface.co/llava-hf/llava-v1.6-mistral-7b-hf/discussions/46), which we clear here.
+
+import torch
+from transformers import AutoConfig, AutoProcessor, GenerationConfig, LlavaNextForConditionalGeneration
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+check_transformers_version()
+
+MODEL_ID = "llava-hf/llava-v1.6-mistral-7b-hf"
+
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+
+text_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "layer_types": None,
+ "dtype": None, # hotfix for upstream text_config.dtype = "bfloat16"
+}
+vision_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+}
+
+config = AutoConfig.from_pretrained(MODEL_ID, text_config=text_config, vision_config=vision_config)
+model = LlavaNextForConditionalGeneration(config).to(dtype=torch.bfloat16)
+smoke_test(model, processor)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, processor, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/paligemma_for_conditional_generation.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/paligemma_for_conditional_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..3392c08a7c737d7b3c09f997bf54cc55a38eef44
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/paligemma_for_conditional_generation.py
@@ -0,0 +1,48 @@
+# 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 transformers import AutoConfig, AutoProcessor, GenerationConfig, PaliGemmaForConditionalGeneration
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+check_transformers_version()
+
+MODEL_ID = "google/paligemma-3b-pt-224"
+
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+
+text_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "layer_types": None,
+}
+vision_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "embed_dim": 64,
+}
+
+config = AutoConfig.from_pretrained(MODEL_ID, text_config=text_config, vision_config=vision_config)
+model = PaliGemmaForConditionalGeneration(config).to(dtype=torch.float32)
+smoke_test(model, processor)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, processor, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen2_5_vl_for_conditional_generation.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen2_5_vl_for_conditional_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb785fddaf78fbbc65481ffc7f33b5928c3d4fe4
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen2_5_vl_for_conditional_generation.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.
+
+# Note: Qwen2.5-VL requires out_hidden_size on the vision config, plus root-level num_hidden_layers/hidden_size/
+# num_attention_heads (distinct from the text_config fields). See GH-4101 and transformers#41020.
+
+import torch
+from transformers import AutoConfig, AutoProcessor, GenerationConfig, Qwen2_5_VLForConditionalGeneration
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+check_transformers_version()
+
+MODEL_ID = "Qwen/Qwen2.5-VL-3B-Instruct"
+
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+
+text_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "layer_types": None,
+ "rope_scaling": {"type": "default", "mrope_section": [1, 1], "rope_type": "default"},
+}
+vision_config = {
+ "hidden_size": 16,
+ "num_heads": 4,
+ "depth": 2,
+ "fullatt_block_indexes": [1], # must contain valid layer indices (< depth)
+ "out_hidden_size": 16,
+}
+
+config = AutoConfig.from_pretrained(
+ MODEL_ID,
+ text_config=text_config,
+ vision_config=vision_config,
+ rope_scaling={"type": "default", "mrope_section": [1, 1], "rope_type": "default"},
+ num_hidden_layers=2,
+ hidden_size=16,
+ num_attention_heads=4,
+)
+model = Qwen2_5_VLForConditionalGeneration(config).to(dtype=torch.bfloat16)
+smoke_test(model, processor)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, processor, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen2_vl_for_conditional_generation.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen2_vl_for_conditional_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ded1b5167eb1e4f1d293057eb4897619fb9519a
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen2_vl_for_conditional_generation.py
@@ -0,0 +1,55 @@
+# 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.
+
+# Note: two distinct rope_scaling dict objects (root and text_config). See GH-4101 and transformers#41020.
+
+import torch
+from transformers import AutoConfig, AutoProcessor, GenerationConfig, Qwen2VLForConditionalGeneration
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+check_transformers_version()
+
+MODEL_ID = "Qwen/Qwen2-VL-2B-Instruct"
+
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+
+text_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "layer_types": None,
+ "rope_scaling": {"type": "default", "mrope_section": [1, 1], "rope_type": "default"},
+}
+vision_config = {
+ "hidden_size": 16,
+ "num_heads": 4,
+ "embed_dim": 64,
+ "depth": 2,
+}
+
+config = AutoConfig.from_pretrained(
+ MODEL_ID,
+ text_config=text_config,
+ vision_config=vision_config,
+ rope_scaling={"type": "default", "mrope_section": [1, 1], "rope_type": "default"},
+)
+model = Qwen2VLForConditionalGeneration(config).to(dtype=torch.bfloat16)
+smoke_test(model, processor)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, processor, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen3_5_for_conditional_generation_nothink.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen3_5_for_conditional_generation_nothink.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f437de4ea0e535257db641a57e4b81f11fa818d
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen3_5_for_conditional_generation_nothink.py
@@ -0,0 +1,66 @@
+# 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.
+
+# Notes:
+# - Qwen3.5 auto-builds layer_types from num_hidden_layers with default interval 4, so tiny models
+# (2 layers) end up all-linear-attention, which breaks dynamic cache. Force one full-attention layer.
+# - The vision config expects `depth`/`num_heads` (not `num_hidden_layers`/`num_attention_heads`).
+# - Qwen3.5 has no published generation_config on the Hub yet.
+# - Qwen3.5 keeps some linear-attn weights in float32; we cast them back after the bfloat16 conversion.
+# - Sourced from Qwen/Qwen3.5-0.8B because its bundled tokenizer defaults to thinking disabled.
+# Switching to a >=4B Qwen3.5 release will flip that default.
+
+import torch
+from transformers import AutoConfig, AutoProcessor, Qwen3_5ForConditionalGeneration
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+TRANSFORMERS_VERSION = "5.2.0"
+check_transformers_version(TRANSFORMERS_VERSION)
+
+MODEL_ID = "Qwen/Qwen3.5-0.8B"
+
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+
+text_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "layer_types": ["linear_attention", "full_attention"],
+ "full_attention_interval": 2,
+}
+vision_config = {
+ "hidden_size": 16,
+ "depth": 2,
+ "num_heads": 4,
+ "intermediate_size": 32,
+ "out_hidden_size": 16,
+}
+
+config = AutoConfig.from_pretrained(MODEL_ID, text_config=text_config, vision_config=vision_config)
+model = Qwen3_5ForConditionalGeneration(config).to(dtype=torch.bfloat16)
+
+# Restore float32 for linear-attn weights that the upstream model keeps in fp32.
+for i, layer_type in enumerate(config.text_config.layer_types):
+ if layer_type == "linear_attention":
+ linear_attn = model.model.language_model.layers[i].linear_attn
+ linear_attn.A_log.data = linear_attn.A_log.data.float()
+ linear_attn.norm.weight.data = linear_attn.norm.weight.data.float()
+
+smoke_test(model, processor)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, processor, None, "tiny", "NoThink")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen3_5_for_conditional_generation_think.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen3_5_for_conditional_generation_think.py
new file mode 100644
index 0000000000000000000000000000000000000000..0eccd40a4689da90ee0c29d6fb36a376ff9cf74e
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen3_5_for_conditional_generation_think.py
@@ -0,0 +1,66 @@
+# 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.
+
+# Notes:
+# - Qwen3.5 auto-builds layer_types from num_hidden_layers with default interval 4, so tiny models
+# (2 layers) end up all-linear-attention, which breaks dynamic cache. Force one full-attention layer.
+# - The vision config expects `depth`/`num_heads` (not `num_hidden_layers`/`num_attention_heads`).
+# - Qwen3.5 has no published generation_config on the Hub yet.
+# - Qwen3.5 keeps some linear-attn weights in float32; we cast them back after the bfloat16 conversion.
+# - Sourced from Qwen/Qwen3.5-4B because its bundled tokenizer defaults to thinking enabled.
+# Switching to a smaller Qwen3.5 release will flip that default.
+
+import torch
+from transformers import AutoConfig, AutoProcessor, Qwen3_5ForConditionalGeneration
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+TRANSFORMERS_VERSION = "5.2.0"
+check_transformers_version(TRANSFORMERS_VERSION)
+
+MODEL_ID = "Qwen/Qwen3.5-4B"
+
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+
+text_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "layer_types": ["linear_attention", "full_attention"],
+ "full_attention_interval": 2,
+}
+vision_config = {
+ "hidden_size": 16,
+ "depth": 2,
+ "num_heads": 4,
+ "intermediate_size": 32,
+ "out_hidden_size": 16,
+}
+
+config = AutoConfig.from_pretrained(MODEL_ID, text_config=text_config, vision_config=vision_config)
+model = Qwen3_5ForConditionalGeneration(config).to(dtype=torch.bfloat16)
+
+# Restore float32 for linear-attn weights that the upstream model keeps in fp32.
+for i, layer_type in enumerate(config.text_config.layer_types):
+ if layer_type == "linear_attention":
+ linear_attn = model.model.language_model.layers[i].linear_attn
+ linear_attn.A_log.data = linear_attn.A_log.data.float()
+ linear_attn.norm.weight.data = linear_attn.norm.weight.data.float()
+
+smoke_test(model, processor)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, processor, None, "tiny", "Think")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen3_6_for_conditional_generation.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen3_6_for_conditional_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0f5bef6e7a6d6219449e8cb2f6a9ac00afa42a2
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen3_6_for_conditional_generation.py
@@ -0,0 +1,63 @@
+# 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.
+
+# Notes:
+# - Qwen3.6 reuses the Qwen3_5Moe class with extra MoE config fields
+# (num_experts, num_experts_per_tok, moe_intermediate_size, shared_expert_intermediate_size).
+# - Same layer_types/full_attention_interval workaround as Qwen3.5: tiny models (2 layers) need
+# one full-attention layer to keep the dynamic cache happy.
+# - The vision config expects `depth`/`num_heads` (not `num_hidden_layers`/`num_attention_heads`).
+# - Unlike Qwen3.5, Qwen3.6 stores linear-attn weights in bf16, so no float32 cast is needed.
+
+import torch
+from transformers import AutoConfig, AutoProcessor, GenerationConfig, Qwen3_5MoeForConditionalGeneration
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+TRANSFORMERS_VERSION = "5.2.0"
+check_transformers_version(TRANSFORMERS_VERSION)
+
+MODEL_ID = "Qwen/Qwen3.6-35B-A3B"
+
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+
+text_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "layer_types": ["linear_attention", "full_attention"],
+ "full_attention_interval": 2,
+ "num_experts": 4,
+ "num_experts_per_tok": 2,
+ "moe_intermediate_size": 32,
+ "shared_expert_intermediate_size": 32,
+}
+vision_config = {
+ "hidden_size": 16,
+ "depth": 2,
+ "num_heads": 4,
+ "intermediate_size": 32,
+ "out_hidden_size": 16,
+}
+
+config = AutoConfig.from_pretrained(MODEL_ID, text_config=text_config, vision_config=vision_config)
+model = Qwen3_5MoeForConditionalGeneration(config).to(dtype=torch.bfloat16)
+
+smoke_test(model, processor)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, processor, generation_config, "tiny", "3.6")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen3_vl_for_conditional_generation.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen3_vl_for_conditional_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..924ead3d29a467ab049df9bae65a6bb6a46d078b
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/qwen3_vl_for_conditional_generation.py
@@ -0,0 +1,58 @@
+# 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.
+
+# Notes:
+# - "layer_types" is intentionally omitted from text_config: qwen3_vl's modeling code checks
+# `hasattr(config, "layer_types")` and uses a different path when absent
+# (see transformers/models/qwen3_vl/modeling_qwen3_vl.py).
+# - mrope_section needs 3 elements (for dim, offset in enumerate((1, 2), start=1): mrope_section[dim]).
+
+import torch
+from transformers import AutoConfig, AutoProcessor, GenerationConfig, Qwen3VLForConditionalGeneration
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+TRANSFORMERS_VERSION = "4.57.0"
+check_transformers_version(TRANSFORMERS_VERSION)
+
+MODEL_ID = "Qwen/Qwen3-VL-2B-Instruct"
+
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+
+text_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "rope_scaling": {"mrope_interleaved": True, "mrope_section": [2, 2, 2], "rope_type": "default"},
+}
+vision_config = {
+ # Real Qwen3-VL has depth=24 with deepstack at layers [5, 11, 17]. With depth=2 here, those
+ # indexes are unreachable, so the deepstack mergers were instantiated but never invoked.
+ # Pick an index inside [0, depth).
+ "deepstack_visual_indexes": [1],
+ "hidden_size": 16,
+ "num_heads": 4,
+ "depth": 2,
+ "out_hidden_size": 16,
+}
+
+config = AutoConfig.from_pretrained(MODEL_ID, text_config=text_config, vision_config=vision_config)
+model = Qwen3VLForConditionalGeneration(config).to(dtype=torch.bfloat16)
+smoke_test(model, processor)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, processor, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/smolvlm_for_conditional_generation.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/smolvlm_for_conditional_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..02b0348ffd06e07eec52029887736bfba906708e
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/smolvlm_for_conditional_generation.py
@@ -0,0 +1,48 @@
+# 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 transformers import AutoConfig, AutoProcessor, GenerationConfig, SmolVLMForConditionalGeneration
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+check_transformers_version()
+
+MODEL_ID = "HuggingFaceTB/SmolVLM2-2.2B-Instruct"
+
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+
+text_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "layer_types": None,
+}
+vision_config = {
+ "num_hidden_layers": 2,
+ "hidden_size": 16,
+ "num_attention_heads": 4,
+ "num_key_value_heads": 2,
+ "embed_dim": 64,
+}
+
+config = AutoConfig.from_pretrained(MODEL_ID, text_config=text_config, vision_config=vision_config)
+model = SmolVLMForConditionalGeneration(config).to(dtype=torch.float32)
+smoke_test(model, processor)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, processor, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/t5_for_conditional_generation.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/t5_for_conditional_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..2fcbc996dd5e41467c9fcdc2059263024dc2b425
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_conditional_generation/t5_for_conditional_generation.py
@@ -0,0 +1,32 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+from transformers import AutoConfig, AutoTokenizer, GenerationConfig, T5ForConditionalGeneration
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub
+
+
+check_transformers_version()
+
+MODEL_ID = "google/flan-t5-small"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = AutoConfig.from_pretrained(MODEL_ID)
+config.d_model = 24
+model = T5ForConditionalGeneration(config).to(dtype=torch.float32)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/__init__.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d26f4482fe3969b6de2b51bd1f85fc16dad6a65
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/__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.
+
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/gpt_neox_for_sequence_classification.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/gpt_neox_for_sequence_classification.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa715eac938ff28cfdda496710b602ace33dee4e
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/gpt_neox_for_sequence_classification.py
@@ -0,0 +1,48 @@
+# 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 transformers import AutoConfig, AutoTokenizer, GenerationConfig, GPTNeoXForSequenceClassification
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "EleutherAI/pythia-14m"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = AutoConfig.from_pretrained(
+ MODEL_ID,
+ num_labels=1,
+ hidden_size=16,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = GPTNeoXForSequenceClassification(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/llama_for_sequence_classification_3_2.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/llama_for_sequence_classification_3_2.py
new file mode 100644
index 0000000000000000000000000000000000000000..83db25400309d34a46b05f946aac1fe402453185
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/llama_for_sequence_classification_3_2.py
@@ -0,0 +1,48 @@
+# 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 transformers import AutoConfig, AutoTokenizer, GenerationConfig, LlamaForSequenceClassification
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "meta-llama/Llama-3.2-1B-Instruct"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = AutoConfig.from_pretrained(
+ MODEL_ID,
+ num_labels=1,
+ hidden_size=16,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+model = LlamaForSequenceClassification(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny", "3.2")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/qwen2_for_sequence_classification_2_5.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/qwen2_for_sequence_classification_2_5.py
new file mode 100644
index 0000000000000000000000000000000000000000..7163043b83dbec3a58394e8aee83698a55098558
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/qwen2_for_sequence_classification_2_5.py
@@ -0,0 +1,50 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+from transformers import AutoConfig, AutoTokenizer, GenerationConfig, Qwen2ForSequenceClassification
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "Qwen/Qwen2.5-32B-Instruct"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = AutoConfig.from_pretrained(
+ MODEL_ID,
+ num_labels=1,
+ hidden_size=16,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+# Bug in transformers: it ignores num_hidden_layers to build layer_types
+config.layer_types = config.layer_types[:2]
+model = Qwen2ForSequenceClassification(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny", "2.5")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/qwen3_for_sequence_classification.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/qwen3_for_sequence_classification.py
new file mode 100644
index 0000000000000000000000000000000000000000..61b017ef11eae5768fb2b3adddf78e3491715ef7
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/qwen3_for_sequence_classification.py
@@ -0,0 +1,50 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+from transformers import AutoConfig, AutoTokenizer, GenerationConfig, Qwen3ForSequenceClassification
+
+from .._common import (
+ check_dtype_pattern,
+ check_transformers_version,
+ init_weights_tiny_model,
+ print_config_diff,
+ push_to_hub,
+ smoke_test,
+)
+
+
+check_transformers_version()
+
+MODEL_ID = "Qwen/Qwen3-4B"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = AutoConfig.from_pretrained(
+ MODEL_ID,
+ num_labels=1,
+ hidden_size=16,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+)
+# Bug in transformers: it ignores num_hidden_layers to build layer_types
+config.layer_types = config.layer_types[:2]
+model = Qwen3ForSequenceClassification(config).to(dtype=torch.bfloat16)
+init_weights_tiny_model(model)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/qwen3_moe_for_sequence_classification.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/qwen3_moe_for_sequence_classification.py
new file mode 100644
index 0000000000000000000000000000000000000000..ca3da4f91854bb1ddc9454577d333be2d39cb289
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_tiny_models/for_sequence_classification/qwen3_moe_for_sequence_classification.py
@@ -0,0 +1,42 @@
+# 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 transformers import AutoConfig, AutoTokenizer, GenerationConfig, Qwen3MoeForSequenceClassification
+
+from .._common import check_dtype_pattern, check_transformers_version, print_config_diff, push_to_hub, smoke_test
+
+
+check_transformers_version()
+
+MODEL_ID = "Qwen/Qwen3-30B-A3B"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+generation_config = GenerationConfig.from_pretrained(MODEL_ID)
+config = AutoConfig.from_pretrained(
+ MODEL_ID,
+ num_labels=1,
+ hidden_size=16,
+ num_attention_heads=4,
+ num_key_value_heads=2,
+ num_hidden_layers=2,
+ intermediate_size=32,
+ num_experts=4,
+ num_experts_per_tok=2,
+)
+model = Qwen3MoeForSequenceClassification(config).to(dtype=torch.bfloat16)
+smoke_test(model, tokenizer)
+check_dtype_pattern(MODEL_ID, model)
+print_config_diff(MODEL_ID, model)
+push_to_hub(model, tokenizer, generation_config, "tiny")
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_toolcall_dataset.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_toolcall_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..84b56b88ab94fd418e6685bc8d3429bca59bcec0
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_toolcall_dataset.py
@@ -0,0 +1,340 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+
+from datasets import Dataset
+from transformers import HfArgumentParser
+from transformers.utils import get_json_schema
+
+
+@dataclass
+class ScriptArguments:
+ r"""
+ Arguments for the script.
+
+ Args:
+ test_size (`float`, *optional*, defaults to `0.1`):
+ Fraction of the dataset to include in the test split.
+ push_to_hub (`bool`, *optional*, defaults to `False`):
+ Whether to push the dataset to the Hugging Face Hub.
+ repo_id (`str`, *optional*, defaults to `"trl-internal-testing/zen"`):
+ Hugging Face repository ID to push the dataset to.
+ """
+
+ test_size: float = field(
+ default=0.1,
+ metadata={"help": "Fraction of the dataset to include in the test split."},
+ )
+ push_to_hub: bool = field(
+ default=False,
+ metadata={"help": "Whether to push the dataset to the Hugging Face Hub."},
+ )
+ repo_id: str = field(
+ default="trl-internal-testing/toolcall",
+ metadata={"help": "Hugging Face repository ID to push the dataset to."},
+ )
+
+
+def main(test_size, push_to_hub, repo_id):
+ # Fictitious functions to simulate tool calls
+ def start_timer(duration: int) -> int:
+ """
+ Starts a timer for the specified duration in seconds.
+
+ Args:
+ duration: Duration in seconds to set the timer for.
+
+ Returns:
+ The duration set for the timer.
+ """
+ return duration
+
+ def get_current_time(location: str) -> str:
+ """
+ Returns the current time in the specified location.
+
+ Args:
+ location: The location for which to get the current time.
+
+ Returns:
+ The current time in the specified location.
+ """
+ return "06:22:48"
+
+ def get_air_quality_index(location: str) -> int:
+ """
+ Returns the air quality index for the specified location.
+
+ Args:
+ location: The location for which to get the air quality index.
+
+ Returns:
+ The air quality index for the specified location.
+ """
+ return 53
+
+ def play_music(title: str, artist: str) -> dict:
+ """
+ Plays music by the specified title and artist.
+
+ Args:
+ title: The title of the music to play.
+ artist: The artist of the music to play.
+
+ Returns:
+ A dictionary indicating the status of the music playback.
+ """
+ return {"status": "Playing"}
+
+ def get_weather_forecast(city: str, date: str) -> dict:
+ """
+ Returns the weather forecast for the specified city and date.
+
+ Args:
+ city: The city for which to get the weather forecast.
+ date: The date for which to get the weather forecast.
+
+ Returns:
+ A dictionary containing the temperature and weather condition.
+ """
+ return {"temperature": 22, "condition": "partly cloudy"}
+
+ def control_light(room: str, state: str) -> dict:
+ """
+ Controls the light in the specified room.
+
+ Args:
+ room: The room where the light should be controlled.
+ state: The desired state of the light ("on" or "off").
+
+ Returns:
+ A dictionary indicating the state of the light.
+ """
+ return {"state": state}
+
+ def create_reminder(time: str, note: str) -> str:
+ """
+ Creates a reminder for the specified time and note.
+
+ Args:
+ time: The time for the reminder.
+ note: The note for the reminder.
+
+ Returns:
+ A confirmation message indicating that the reminder has been set.
+ """
+ return "I'll remind you to call mom at 7 PM."
+
+ def get_wind_conditions(city: str, unit: str) -> tuple[int, str]:
+ """
+ Returns the wind conditions for the specified city.
+
+ Args:
+ city: The city for which to get the wind conditions.
+ unit: The unit of measurement for the wind speed (e.g., "mph").
+
+ Returns:
+ A tuple containing the wind speed and direction.
+ """
+ return 14, "NW"
+
+ start_timer = get_json_schema(start_timer)
+ get_current_time = get_json_schema(get_current_time)
+ get_air_quality_index = get_json_schema(get_air_quality_index)
+ play_music = get_json_schema(play_music)
+ get_weather_forecast = get_json_schema(get_weather_forecast)
+ control_light = get_json_schema(control_light)
+ create_reminder = get_json_schema(create_reminder)
+ get_wind_conditions = get_json_schema(get_wind_conditions)
+
+ # fmt: off
+ language_modeling_dataset = Dataset.from_dict({
+ "messages": [
+ [
+ {"role": "user", "content": "Set a timer for 10 minutes."},
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "start_timer", "arguments": {"duration": 600}}}]},
+ {"role": "tool", "name": "start_timer", "content": "600"},
+ {"role": "assistant", "content": "Timer set for 10 minutes."},
+ ],
+ [
+ {"role": "user", "content": "What time is it in Tokyo?"},
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_current_time", "arguments": {"location": "Tokyo"}}}]},
+ {"role": "tool", "name": "get_current_time", "content": "06:22:48"},
+ {"role": "assistant", "content": "The current time in Tokyo is 06:22 AM."},
+ ],
+ [
+ {"role": "user", "content": "Is the air clean today in Lisbon?"},
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_air_quality_index", "arguments": {"location": "Lisbon, Portugal"}}}]},
+ {"role": "tool", "name": "get_air_quality_index", "content": "53"},
+ {"role": "assistant", "content": "The air quality is moderate."},
+ ],
+ [
+ {"role": "user", "content": "Play some music."},
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "play_music", "arguments": {"title": "Take Five", "artist": "Dave Brubeck"}}}]},
+ {"role": "tool", "name": "play_music", "content": "{'status': 'Playing'}"},
+ {"role": "assistant", "content": "Enjoy the jazz tunes!"},
+ ],
+ [
+ {"role": "user", "content": "What's the weather like tomorrow in Berlin?"},
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_weather_forecast", "arguments": {"city": "Berlin", "date": "2025-06-16"}}}]},
+ {"role": "tool", "name": "get_weather_forecast", "content": "{'temperature': 22, 'condition': 'partly cloudy'}"},
+ {"role": "assistant", "content": "Tomorrow in Berlin will be partly cloudy with a high of 22°C."}
+ ],
+ [
+ {"role": "user", "content": "Turn on the living room lights."},
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "control_light", "arguments": {"room": "living room", "state": "on"}}}]},
+ {"role": "tool", "name": "control_light", "content": "{'state': 'on'}"},
+ {"role": "assistant", "content": "The living room lights are now on."}
+ ],
+ [
+ {"role": "user", "content": "Remind me to call mom at 7 PM."},
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "create_reminder", "arguments": {"time": "19:00", "note": "Call mom"}}}]},
+ {"role": "tool", "name": "create_reminder", "content": "Reminder set"},
+ {"role": "assistant", "content": "Okay, I'll remind you to call mom at 7 PM."}
+ ],
+ [
+ {"role": "user", "content": "How strong is the wind in Chicago right now?"},
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_wind_conditions", "arguments": {"city": "Chicago", "unit": "mph"}}}]},
+ {"role": "tool", "name": "get_wind_conditions", "content": "(14, 'NW')"},
+ {"role": "assistant", "content": "The wind in Chicago is blowing at 14 mph from the northwest."}
+ ]
+ ],
+ "tools": [
+ [start_timer, create_reminder],
+ [get_current_time],
+ [get_air_quality_index, get_weather_forecast, get_wind_conditions],
+ [play_music, control_light],
+ [get_weather_forecast, get_wind_conditions],
+ [control_light],
+ [start_timer, create_reminder],
+ [get_weather_forecast, get_wind_conditions],
+ ]
+ }, on_mixed_types="use_json")
+ language_modeling_dataset = language_modeling_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ language_modeling_dataset.push_to_hub(repo_id, config_name="language_modeling")
+
+ preference_dataset = Dataset.from_dict({
+ "prompt": [
+ [{"role": "user", "content": "Set a timer for 10 minutes."}],
+ [{"role": "user", "content": "What time is it in Tokyo?"}],
+ [{"role": "user", "content": "Is the air clean today in Lisbon?"}],
+ [{"role": "user", "content": "Play some music."}],
+ [{"role": "user", "content": "What's the weather like tomorrow in Berlin?"}],
+ [{"role": "user", "content": "Turn on the living room lights."}],
+ [{"role": "user", "content": "Remind me to call mom at 7 PM."}],
+ [{"role": "user", "content": "How strong is the wind in Chicago right now?"}],
+ ],
+ "chosen": [
+ [
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "start_timer", "arguments": {"duration": 600}}}]},
+ {"role": "tool", "name": "start_timer", "content": "600"},
+ {"role": "assistant", "content": "Timer set for 10 minutes."},
+ ],
+ [
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_current_time", "arguments": {"location": "Tokyo"}}}]},
+ {"role": "tool", "name": "get_current_time", "content": "06:22:48"},
+ {"role": "assistant", "content": "The current time in Tokyo is 06:22 AM."},
+ ],
+ [
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_air_quality_index", "arguments": {"location": "Lisbon, Portugal"}}}]},
+ {"role": "tool", "name": "get_air_quality_index", "content": "53"},
+ {"role": "assistant", "content": "The air quality is moderate."},
+ ],
+ [
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "play_music", "arguments": {"title": "Take Five", "artist": "Dave Brubeck"}}}]},
+ {"role": "tool", "name": "play_music", "content": "{'status': 'Playing'}"},
+ {"role": "assistant", "content": "Enjoy the jazz tunes!"},
+ ],
+ [
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_weather_forecast", "arguments": {"city": "Berlin", "date": "2025-06-16"}}}]},
+ {"role": "tool", "name": "get_weather_forecast", "content": "{'temperature': 22, 'condition': 'partly cloudy'}"},
+ {"role": "assistant", "content": "Tomorrow in Berlin will be partly cloudy with a high of 22°C."}
+ ],
+ [
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "control_light", "arguments": {"room": "living room", "state": "on"}}}]},
+ {"role": "tool", "name": "control_light", "content": "{'state': 'on'}"},
+ {"role": "assistant", "content": "The living room lights are now on."}
+ ],
+ [
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "create_reminder", "arguments": {"time": "19:00", "note": "Call mom"}}}]},
+ {"role": "tool", "name": "create_reminder", "content": "Reminder set"},
+ {"role": "assistant", "content": "Okay, I’ll remind you to call mom at 7 PM."}
+ ],
+ [
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_wind_conditions", "arguments": {"city": "Chicago", "unit": "mph"}}}]},
+ {"role": "tool", "name": "get_wind_conditions", "content": "(14, 'NW')"},
+ {"role": "assistant", "content": "The wind in Chicago is blowing at 14 mph from the northwest."}
+ ],
+ ],
+ "rejected": [
+ [
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "start_timer", "arguments": {"duration": 10}}}]},
+ {"role": "tool", "name": "start_timer", "content": "10"},
+ {"role": "assistant", "content": "Timer set for 10 seconds."},
+ ],
+ [
+ {"role": "assistant", "content": "It is 6:22 AM in Tokyo."},
+ ],
+ [
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_air_quality_index", "arguments": {"location": "Lisbon"}}}]},
+ {"role": "tool", "name": "get_air_quality_index", "content": "53"},
+ {"role": "assistant", "content": "The air quality is great."},
+ ],
+ [
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "play_music", "arguments": {"title": "Take Five", "artist": "Daft Punk"}}}]},
+ {"role": "tool", "name": "play_music", "content": "{'status': 'Playing'}"},
+ {"role": "assistant", "content": "Playing your song."},
+ ],
+ [
+ {"role": "assistant", "content": "Tomorrow in Berlin will be hot and sunny."},
+ ],
+ [
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "control_light", "arguments": {"room": "living room", "state": "off"}}}]},
+ {"role": "tool", "name": "control_light", "content": "{'state': 'off'}"},
+ {"role": "assistant", "content": "The living room lights are now off."}
+ ],
+ [
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "create_reminder", "arguments": {"time": "07:00", "note": "Call mom"}}}]},
+ {"role": "tool", "name": "create_reminder", "content": "Reminder set"},
+ {"role": "assistant", "content": "Okay, I'll remind you to call mom at 7 AM."}
+ ],
+ [
+ {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_weather_forecast", "arguments": {"city": "Chicago", "date": "2025-06-16"}}}]},
+ {"role": "tool", "name": "get_weather_forecast", "content": "{'temperature': 22, 'condition': 'partly cloudy'}"},
+ {"role": "assistant", "content": "Tomorrow in Chicago will be partly cloudy with a high of 22°C."}
+ ],
+ ],
+ "tools": [
+ [start_timer],
+ [get_current_time],
+ [get_air_quality_index],
+ [play_music],
+ [get_weather_forecast],
+ [control_light],
+ [create_reminder],
+ [get_wind_conditions],
+ ],
+ }, on_mixed_types="use_json")
+ preference_dataset = preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ preference_dataset.push_to_hub(repo_id, config_name="preference")
+ # fmt: on
+
+
+if __name__ == "__main__":
+ parser = HfArgumentParser(ScriptArguments)
+ script_args = parser.parse_args_into_dataclasses()[0]
+ main(script_args.test_size, script_args.push_to_hub, script_args.repo_id)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_zen_dataset.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_zen_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..14b78c7f73fdb6f9bc04acc63b3b0f4479b2f3b4
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_zen_dataset.py
@@ -0,0 +1,660 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+
+from datasets import Dataset
+from transformers import HfArgumentParser
+
+
+@dataclass
+class ScriptArguments:
+ r"""
+ Arguments for the script.
+
+ Args:
+ test_size (`float`, *optional*, defaults to `0.1`):
+ Fraction of the dataset to include in the test split.
+ push_to_hub (`bool`, *optional*, defaults to `False`):
+ Whether to push the dataset to the Hugging Face Hub.
+ repo_id (`str`, *optional*, defaults to `"trl-internal-testing/zen"`):
+ Hugging Face repository ID to push the dataset to.
+ """
+
+ test_size: float = field(
+ default=0.1,
+ metadata={"help": "Fraction of the dataset to include in the test split."},
+ )
+ push_to_hub: bool = field(
+ default=False,
+ metadata={"help": "Whether to push the dataset to the Hugging Face Hub."},
+ )
+ repo_id: str = field(
+ default="trl-internal-testing/zen",
+ metadata={"help": "Hugging Face repository ID to push the dataset to."},
+ )
+
+
+def main(test_size, push_to_hub, repo_id):
+ # fmt: off
+ standard_language_modeling_dataset = Dataset.from_dict({
+ "text": [
+ "Beautiful is better than ugly.",
+ "Explicit is better than implicit.",
+ "Simple is better than complex.",
+ "Complex is better than complicated.",
+ "Flat is better than nested.",
+ "Sparse is better than dense.",
+ "Readability counts.",
+ "Special cases aren't special enough to break the rules.",
+ "Although practicality beats purity.",
+ "Errors should never pass silently.",
+ "Unless explicitly silenced.",
+ "In the face of ambiguity, refuse the temptation to guess.",
+ "There should be one-- and preferably only one --obvious way to do it.",
+ "Although that way may not be obvious at first unless you're Dutch.",
+ "Now is better than never.",
+ "Although never is often better than *right* now.",
+ "If the implementation is hard to explain, it's a bad idea.",
+ "If the implementation is easy to explain, it may be a good idea.",
+ "Namespaces are one honking great idea -- let's do more of those!",
+ ],
+ })
+ standard_language_modeling_dataset = standard_language_modeling_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ standard_language_modeling_dataset.push_to_hub(repo_id, config_name="standard_language_modeling")
+
+ standard_prompt_only_dataset = Dataset.from_dict({
+ "prompt": [
+ "Beautiful is better than",
+ "Explicit is",
+ "Simple is better",
+ "Complex",
+ "Flat is better than",
+ "Sparse is better",
+ "Readability",
+ "Special cases aren't special",
+ "Although practicality beats",
+ "Errors should never",
+ "Unless explicitly",
+ "In the face of ambiguity, refuse",
+ "There should be one-- and preferably",
+ "Although that way may not be obvious at first unless you're",
+ "Now is",
+ "Although never is often",
+ "If the implementation is hard to explain,",
+ "If the implementation is easy",
+ "Namespaces are one honking great",
+ ],
+ })
+ standard_prompt_only_dataset = standard_prompt_only_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ standard_prompt_only_dataset.push_to_hub(repo_id, config_name="standard_prompt_only")
+
+ standard_prompt_completion_dataset = Dataset.from_dict({
+ "prompt": [
+ "Beautiful is better than",
+ "Explicit is",
+ "Simple is better",
+ "Complex",
+ "Flat is better than",
+ "Sparse is better",
+ "Readability",
+ "Special cases aren't special",
+ "Although practicality beats",
+ "Errors should never",
+ "Unless explicitly",
+ "In the face of ambiguity, refuse",
+ "There should be one-- and preferably",
+ "Although that way may not be obvious at first unless you're",
+ "Now is",
+ "Although never is often",
+ "If the implementation is hard to explain,",
+ "If the implementation is easy",
+ "Namespaces are one honking great",
+ ],
+ "completion": [
+ " ugly.",
+ " better than implicit.",
+ " than complex.",
+ " is better than complicated.",
+ " nested.",
+ " than dense.",
+ " counts.",
+ " enough to break the rules.",
+ " purity.",
+ " pass silently.",
+ " silenced.",
+ " the temptation to guess.",
+ " only one --obvious way to do it.",
+ " Dutch.",
+ " better than never.",
+ " better than *right* now.",
+ " it's a bad idea.",
+ " to explain, it may be a good idea.",
+ " idea -- let's do more of those!",
+ ],
+ })
+ standard_prompt_completion_dataset = standard_prompt_completion_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ standard_prompt_completion_dataset.push_to_hub(repo_id, config_name="standard_prompt_completion")
+
+ standard_preference_dataset = Dataset.from_dict({
+ "prompt": [
+ "Beautiful is better than",
+ "Explicit is",
+ "Simple is better",
+ "Complex",
+ "Flat is better than",
+ "Sparse is better",
+ "Readability",
+ "Special cases aren't special",
+ "Although practicality beats",
+ "Errors should never",
+ "Unless explicitly",
+ "In the face of ambiguity, refuse",
+ "There should be one-- and preferably",
+ "Although that way may not be obvious at first unless you're",
+ "Now is",
+ "Although never is often",
+ "If the implementation is hard to explain,",
+ "If the implementation is easy",
+ "Namespaces are one honking great",
+ ],
+ "chosen": [
+ " ugly.",
+ " better than implicit.",
+ " than complex.",
+ " is better than complicated.",
+ " nested.",
+ " than dense.",
+ " counts.",
+ " enough to break the rules.",
+ " purity.",
+ " pass silently.",
+ " silenced.",
+ " the temptation to guess.",
+ " only one --obvious way to do it.",
+ " Dutch.",
+ " better than never.",
+ " better than *right* now.",
+ " it's a bad idea.",
+ " to explain, it may be a good idea.",
+ " idea -- let's do more of those!",
+ ],
+ "rejected": [
+ " the moon.",
+ " worse than nothing.",
+ " than a long vacation.",
+ " is always the answer.",
+ " chocolate.",
+ " without any context.",
+ " is optional.",
+ " enough to become unicorns.",
+ " reality.",
+ " pass their driving test.",
+ " forgotten.",
+ " the opportunity to laugh.",
+ " two or more confusing methods.",
+ " a time traveler.",
+ " never better.",
+ " not even a possibility.",
+ " it's clearly the best choice.",
+ " it's probably magic.",
+ " watermelon -- let's plant some!",
+ ],
+ })
+ standard_preference_dataset = standard_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ standard_preference_dataset.push_to_hub(repo_id, config_name="standard_preference")
+
+ standard_implicit_prompt_preference_dataset = Dataset.from_dict({
+ "chosen": [
+ "Beautiful is better than ugly.",
+ "Explicit is better than implicit.",
+ "Simple is better than complex.",
+ "Complex is better than complicated.",
+ "Flat is better than nested.",
+ "Sparse is better than dense.",
+ "Readability counts.",
+ "Special cases aren't special enough to break the rules.",
+ "Although practicality beats purity.",
+ "Errors should never pass silently.",
+ "Unless explicitly silenced.",
+ "In the face of ambiguity, refuse the temptation to guess.",
+ "There should be one-- and preferably only one --obvious way to do it.",
+ "Although that way may not be obvious at first unless you're Dutch.",
+ "Now is better than never.",
+ "Although never is often better than *right* now.",
+ "If the implementation is hard to explain, it's a bad idea.",
+ "If the implementation is easy to explain, it may be a good idea.",
+ "Namespaces are one honking great idea -- let's do more of those!",
+ ],
+ "rejected": [
+ "Beautiful is better than the moon.",
+ "Explicit is worse than nothing.",
+ "Simple is better than a long vacation.",
+ "Complex is always the answer.",
+ "Flat is better than chocolate.",
+ "Sparse is better without any context.",
+ "Readability is optional.",
+ "Special cases aren't special enough to become unicorns.",
+ "Although practicality beats reality.",
+ "Errors should never pass their driving test.",
+ "Unless explicitly forgotten.",
+ "In the face of ambiguity, refuse the opportunity to laugh.",
+ "There should be one-- and preferably two or more confusing methods.",
+ "Although that way may not be obvious at first unless you're a time traveler.",
+ "Now is never better.",
+ "Although never is often not even a possibility.",
+ "If the implementation is hard to explain, it's clearly the best choice.",
+ "If the implementation is easy it's probably magic.",
+ "Namespaces are one honking great watermelon -- let's plant some!",
+ ],
+ })
+ standard_implicit_prompt_preference_dataset = standard_implicit_prompt_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ standard_implicit_prompt_preference_dataset.push_to_hub(repo_id, config_name="standard_implicit_prompt_preference")
+
+ standard_unpaired_preference_dataset = Dataset.from_dict({
+ "prompt": [
+ "Beautiful is better than",
+ "Explicit is",
+ "Simple is better",
+ "Complex",
+ "Flat is better than",
+ "Sparse is better",
+ "Readability",
+ "Special cases aren't special",
+ "Although practicality beats",
+ "Errors should never",
+ "Unless explicitly",
+ "In the face of ambiguity, refuse",
+ "There should be one-- and preferably",
+ "Although that way may not be obvious at first unless you're",
+ "Now is",
+ "Although never is often",
+ "If the implementation is hard to explain,",
+ "If the implementation is easy",
+ "Namespaces are one honking great",
+ ],
+ "completion": [
+ " ugly.",
+ " worse than nothing.",
+ " than a long vacation.",
+ " is better than complicated.",
+ " nested.",
+ " without any context.",
+ " counts.",
+ " enough to become unicorns.",
+ " purity.",
+ " pass silently.",
+ " forgotten.",
+ " the temptation to guess.",
+ " only one --obvious way to do it.",
+ " a time traveler.",
+ " better than never.",
+ " not even a possibility.",
+ " it's a bad idea.",
+ " it's probably magic.",
+ " watermelon -- let's plant some!",
+ ],
+ "label": [True, False, False, True, True, False, True, False, True, True, False, True, True, False, True, False, True, False, False],
+ })
+ standard_unpaired_preference_dataset = standard_unpaired_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ standard_unpaired_preference_dataset.push_to_hub(repo_id, config_name="standard_unpaired_preference")
+
+ standard_stepwise_supervision_dataset = Dataset.from_dict({
+ "prompt": [
+ "Beautiful is better than",
+ "Explicit is better than",
+ "Simple is better than",
+ "Complex is better than",
+ "Flat is better than",
+ "Sparse is better than",
+ "Readability counts",
+ "Special cases aren't special enough",
+ "Although practicality beats",
+ "Errors should never pass",
+ "In the face of ambiguity, refuse",
+ "There should be one-- and preferably only one --",
+ "Although that way may not be",
+ "Now is better than",
+ "Never is often better than",
+ "If the implementation is hard to explain, it's",
+ "If the implementation is easy to explain, it",
+ "Namespaces are one",
+ "Although practicality sometimes beats purity,",
+ ],
+ "completions": [
+ [", let me think...", " ugly."],
+ [", of course,", " implicit.", " because clarity matters."],
+ ["... let's keep it basic,", " complex."],
+ [" when needed,", " complicated."],
+ [" in terms of structure,", " nested."],
+ ["... especially for readability."],
+ [" especially when others read it."],
+ [", unless...", " they follow the rules."],
+ [" some theoretical elegance,", " purity."],
+ [" silently,", " unless explicitly silenced."],
+ [" the temptation to guess."],
+ [" way to do it,", " but sometimes it's not obvious.", " especially when there's more than one possibility."],
+ [" clear at first,", " it will eventually emerge."],
+ [" later."],
+ [" problematic fixes."],
+ [" likely because it's too complicated."],
+ [" might be a good design."],
+ [" of those great ideas,", " that solve many problems."],
+ [" the code should still aim for balance."],
+ ],
+ "labels": [
+ [False, True],
+ [False, True, False],
+ [False, True],
+ [True, True],
+ [True, False],
+ [True],
+ [False],
+ [True, False],
+ [False, False],
+ [False, False],
+ [True],
+ [True, True, False],
+ [True, True],
+ [False],
+ [True], [False],
+ [False],
+ [True, True],
+ [False]
+ ]
+ })
+ standard_stepwise_supervision_dataset = standard_stepwise_supervision_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ standard_stepwise_supervision_dataset.push_to_hub(repo_id, config_name="standard_stepwise_supervision")
+
+ conversational_language_modeling_dataset = Dataset.from_dict({
+ "messages": [
+ [{"role": "user", "content": "What is better than ugly?"}, {"role": "assistant", "content": "Beautiful."},],
+ [{"role": "user", "content": "What is better than implicit?"}, {"role": "assistant", "content": "Explicit."}],
+ [{"role": "user", "content": "What is better than complex?"}, {"role": "assistant", "content": "Simple."}],
+ [{"role": "user", "content": "What is better than complicated?"}, {"role": "assistant", "content": "Complex."}],
+ [{"role": "user", "content": "What is better than nested?"}, {"role": "assistant", "content": "Flat."}],
+ [{"role": "user", "content": "What is better than dense?"}, {"role": "assistant", "content": "Sparse."}],
+ [{"role": "user", "content": "What counts?"}, {"role": "assistant", "content": "Readability."}],
+ [{"role": "user", "content": "Are special cases enough to break the rules?"}, {"role": "assistant", "content": "No, special cases aren't special enough to break the rules."}],
+ [{"role": "user", "content": "What beats purity?"}, {"role": "assistant", "content": "Practicality."}],
+ [{"role": "user", "content": "What should never pass silently?"}, {"role": "assistant", "content": "Errors."}],
+ [{"role": "user", "content": "When can errors pass silently?"}, {"role": "assistant", "content": "When explicitly silenced."}],
+ [{"role": "user", "content": "What should you do in the face of ambiguity?"}, {"role": "assistant", "content": "Refuse the temptation to guess."}],
+ [{"role": "user", "content": "How many ways should there be to do it?"}, {"role": "assistant", "content": "One, and preferably only one."}],
+ [{"role": "user", "content": "For whom may the way not be obvious at first?"}, {"role": "assistant", "content": "Dutch."}],
+ [{"role": "user", "content": "What is better than never?"}, {"role": "assistant", "content": "Now is better than never."}],
+ [{"role": "user", "content": "Is never better than *right* now?"}, {"role": "assistant", "content": "Yes, often."}],
+ [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}, {"role": "assistant", "content": "It means it's a bad idea."}],
+ [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}, {"role": "assistant", "content": "It means it may be a good idea."}],
+ [{"role": "user", "content": "Any great ideas?"}, {"role": "assistant", "content": "Namespaces are one honking great idea."}],
+ ],
+ })
+ conversational_language_modeling_dataset = conversational_language_modeling_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ conversational_language_modeling_dataset.push_to_hub(repo_id, config_name="conversational_language_modeling")
+
+ conversational_prompt_only_dataset = Dataset.from_dict({
+ "prompt": [
+ [{"role": "user", "content": "What is better than ugly?"}],
+ [{"role": "user", "content": "What is better than implicit?"}],
+ [{"role": "user", "content": "What is better than complex?"}],
+ [{"role": "user", "content": "What is better than complicated?"}],
+ [{"role": "user", "content": "What is better than nested?"}],
+ [{"role": "user", "content": "What is better than dense?"}],
+ [{"role": "user", "content": "What counts?"}],
+ [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+ [{"role": "user", "content": "What beats purity?"}],
+ [{"role": "user", "content": "What should never pass silently?"}],
+ [{"role": "user", "content": "When can errors pass silently?"}],
+ [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+ [{"role": "user", "content": "How many ways should there be to do it?"}],
+ [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+ [{"role": "user", "content": "What is better than never?"}],
+ [{"role": "user", "content": "Is never better than *right* now?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+ [{"role": "user", "content": "Any great ideas?"}],
+ ],
+ })
+ conversational_prompt_only_dataset = conversational_prompt_only_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ conversational_prompt_only_dataset.push_to_hub(repo_id, config_name="conversational_prompt_only")
+
+ conversational_prompt_completion_dataset = Dataset.from_dict({
+ "prompt": [
+ [{"role": "user", "content": "What is better than ugly?"}],
+ [{"role": "user", "content": "What is better than implicit?"}],
+ [{"role": "user", "content": "What is better than complex?"}],
+ [{"role": "user", "content": "What is better than complicated?"}],
+ [{"role": "user", "content": "What is better than nested?"}],
+ [{"role": "user", "content": "What is better than dense?"}],
+ [{"role": "user", "content": "What counts?"}],
+ [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+ [{"role": "user", "content": "What beats purity?"}],
+ [{"role": "user", "content": "What should never pass silently?"}],
+ [{"role": "user", "content": "When can errors pass silently?"}],
+ [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+ [{"role": "user", "content": "How many ways should there be to do it?"}],
+ [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+ [{"role": "user", "content": "What is better than never?"}],
+ [{"role": "user", "content": "Is never better than *right* now?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+ [{"role": "user", "content": "Any great ideas?"}],
+ ],
+ "completion": [
+ [{"role": "assistant", "content": "Beautiful."}],
+ [{"role": "assistant", "content": "Explicit."}],
+ [{"role": "assistant", "content": "Simple."}],
+ [{"role": "assistant", "content": "Complex."}],
+ [{"role": "assistant", "content": "Flat."}],
+ [{"role": "assistant", "content": "Sparse."}],
+ [{"role": "assistant", "content": "Readability."}],
+ [{"role": "assistant", "content": "No, special cases aren't special enough to break the rules."}],
+ [{"role": "assistant", "content": "Practicality."}],
+ [{"role": "assistant", "content": "Errors."}],
+ [{"role": "assistant", "content": "When explicitly silenced."}],
+ [{"role": "assistant", "content": "Refuse the temptation to guess."}],
+ [{"role": "assistant", "content": "One, and preferably only one."}],
+ [{"role": "assistant", "content": "Dutch."}],
+ [{"role": "assistant", "content": "Now is better than never."}],
+ [{"role": "assistant", "content": "Yes, often."}],
+ [{"role": "assistant", "content": "It means it's a bad idea."}],
+ [{"role": "assistant", "content": "It means it may be a good idea."}],
+ [{"role": "assistant", "content": "Namespaces are one honking great idea."}],
+ ],
+ })
+ conversational_prompt_completion_dataset = conversational_prompt_completion_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ conversational_prompt_completion_dataset.push_to_hub(repo_id, config_name="conversational_prompt_completion")
+
+ conversational_preference_dataset = Dataset.from_dict({
+ "prompt": [
+ [{"role": "user", "content": "What is better than ugly?"}],
+ [{"role": "user", "content": "What is better than implicit?"}],
+ [{"role": "user", "content": "What is better than complex?"}],
+ [{"role": "user", "content": "What is better than complicated?"}],
+ [{"role": "user", "content": "What is better than nested?"}],
+ [{"role": "user", "content": "What is better than dense?"}],
+ [{"role": "user", "content": "What counts?"}],
+ [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+ [{"role": "user", "content": "What beats purity?"}],
+ [{"role": "user", "content": "What should never pass silently?"}],
+ [{"role": "user", "content": "When can errors pass silently?"}],
+ [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+ [{"role": "user", "content": "How many ways should there be to do it?"}],
+ [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+ [{"role": "user", "content": "What is better than never?"}],
+ [{"role": "user", "content": "Is never better than *right* now?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+ [{"role": "user", "content": "Any great ideas?"}],
+ ],
+ "chosen": [
+ [{"role": "assistant", "content": "Beautiful."}],
+ [{"role": "assistant", "content": "Explicit."}],
+ [{"role": "assistant", "content": "Simple."}],
+ [{"role": "assistant", "content": "Complex."}],
+ [{"role": "assistant", "content": "Flat."}],
+ [{"role": "assistant", "content": "Sparse."}],
+ [{"role": "assistant", "content": "Readability."}],
+ [{"role": "assistant", "content": "No, special cases aren't special enough to break the rules."}],
+ [{"role": "assistant", "content": "Practicality."}],
+ [{"role": "assistant", "content": "Errors."}],
+ [{"role": "assistant", "content": "When explicitly silenced."}],
+ [{"role": "assistant", "content": "Refuse the temptation to guess."}],
+ [{"role": "assistant", "content": "One, and preferably only one."}],
+ [{"role": "assistant", "content": "Dutch."}],
+ [{"role": "assistant", "content": "Now is better than never."}],
+ [{"role": "assistant", "content": "Yes, often."}],
+ [{"role": "assistant", "content": "It means it's a bad idea."}],
+ [{"role": "assistant", "content": "It means it may be a good idea."}],
+ [{"role": "assistant", "content": "Namespaces are one honking great idea."}],
+ ],
+ "rejected": [
+ [{"role": "assistant", "content": "Acceptable."}],
+ [{"role": "assistant", "content": "Explained."}],
+ [{"role": "assistant", "content": "Very complex."}],
+ [{"role": "assistant", "content": "Very complicated."}],
+ [{"role": "assistant", "content": "Circular."}],
+ [{"role": "assistant", "content": "Heavy."}],
+ [{"role": "assistant", "content": "Looking complicated."}],
+ [{"role": "assistant", "content": "Yes, special cases are special enough to break the rules."}],
+ [{"role": "assistant", "content": "Nothing."}],
+ [{"role": "assistant", "content": "Warnings."}],
+ [{"role": "assistant", "content": "Never."}],
+ [{"role": "assistant", "content": "Give up."}],
+ [{"role": "assistant", "content": "As many as possible."}],
+ [{"role": "assistant", "content": "French."}],
+ [{"role": "assistant", "content": "Some day."}],
+ [{"role": "assistant", "content": "No, never."}],
+ [{"role": "assistant", "content": "It means it's a good idea."}],
+ [{"role": "assistant", "content": "It means it's a bad idea."}],
+ [{"role": "assistant", "content": "Recursion."}],
+ ],
+ })
+ conversational_preference_dataset = conversational_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ conversational_preference_dataset.push_to_hub(repo_id, config_name="conversational_preference")
+
+ conversational_implicit_prompt_preference_dataset = Dataset.from_dict({
+ "chosen": [
+ [{"role": "user", "content": "What is better than ugly?"}, {"role": "assistant", "content": "Beautiful."}],
+ [{"role": "user", "content": "What is better than implicit?"}, {"role": "assistant", "content": "Explicit."}],
+ [{"role": "user", "content": "What is better than complex?"}, {"role": "assistant", "content": "Simple."}],
+ [{"role": "user", "content": "What is better than complicated?"}, {"role": "assistant", "content": "Complex."}],
+ [{"role": "user", "content": "What is better than nested?"}, {"role": "assistant", "content": "Flat."}],
+ [{"role": "user", "content": "What is better than dense?"}, {"role": "assistant", "content": "Sparse."}],
+ [{"role": "user", "content": "What counts?"}, {"role": "assistant", "content": "Readability."}],
+ [{"role": "user", "content": "Are special cases enough to break the rules?"}, {"role": "assistant", "content": "No, special cases aren't special enough to break the rules."}],
+ [{"role": "user", "content": "What beats purity?"}, {"role": "assistant", "content": "Practicality."}],
+ [{"role": "user", "content": "What should never pass silently?"}, {"role": "assistant", "content": "Errors."}],
+ [{"role": "user", "content": "When can errors pass silently?"}, {"role": "assistant", "content": "When explicitly silenced."}],
+ [{"role": "user", "content": "What should you do in the face of ambiguity?"}, {"role": "assistant", "content": "Refuse the temptation to guess."}],
+ [{"role": "user", "content": "How many ways should there be to do it?"}, {"role": "assistant", "content": "One, and preferably only one."}],
+ [{"role": "user", "content": "For whom may the way not be obvious at first?"}, {"role": "assistant", "content": "Dutch."}],
+ [{"role": "user", "content": "What is better than never?"}, {"role": "assistant", "content": "Now is better than never."}],
+ [{"role": "user", "content": "Is never better than *right* now?"}, {"role": "assistant", "content": "Yes, often."}],
+ [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}, {"role": "assistant", "content": "It means it's a bad idea."}],
+ [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}, {"role": "assistant", "content": "It means it may be a good idea."}],
+ [{"role": "user", "content": "Any great ideas?"}, {"role": "assistant", "content": "Namespaces are one honking great idea."}],
+ ],
+ "rejected": [
+ [{"role": "user", "content": "What is better than ugly?"}, {"role": "assistant", "content": "Acceptable."}],
+ [{"role": "user", "content": "What is better than implicit?"}, {"role": "assistant", "content": "Explained."}],
+ [{"role": "user", "content": "What is better than complex?"}, {"role": "assistant", "content": "Very complex."}],
+ [{"role": "user", "content": "What is better than complicated?"}, {"role": "assistant", "content": "Very complicated."}],
+ [{"role": "user", "content": "What is better than nested?"}, {"role": "assistant", "content": "Circular."}],
+ [{"role": "user", "content": "What is better than dense?"}, {"role": "assistant", "content": "Heavy."}],
+ [{"role": "user", "content": "What counts?"}, {"role": "assistant", "content": "Looking complicated."}],
+ [{"role": "user", "content": "Are special cases enough to break the rules?"}, {"role": "assistant", "content": "Yes, special cases are special enough to break the rules."}],
+ [{"role": "user", "content": "What beats purity?"}, {"role": "assistant", "content": "Nothing."}],
+ [{"role": "user", "content": "What should never pass silently?"}, {"role": "assistant", "content": "Warnings."}],
+ [{"role": "user", "content": "When can errors pass silently?"}, {"role": "assistant", "content": "Never."}],
+ [{"role": "user", "content": "What should you do in the face of ambiguity?"}, {"role": "assistant", "content": "Give up."}],
+ [{"role": "user", "content": "How many ways should there be to do it?"}, {"role": "assistant", "content": "As many as possible."}],
+ [{"role": "user", "content": "For whom may the way not be obvious at first?"}, {"role": "assistant", "content": "French."}],
+ [{"role": "user", "content": "What is better than never?"}, {"role": "assistant", "content": "Some day."}],
+ [{"role": "user", "content": "Is never better than *right* now?"}, {"role": "assistant", "content": "No, never."}],
+ [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}, {"role": "assistant", "content": "It means it's a good idea."}],
+ [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}, {"role": "assistant", "content": "It means it's a bad idea."}],
+ [{"role": "user", "content": "Any great ideas?"}, {"role": "assistant", "content": "Recursion."}],
+ ],
+ })
+ conversational_implicit_prompt_preference_dataset = conversational_implicit_prompt_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ conversational_implicit_prompt_preference_dataset.push_to_hub(repo_id, config_name="conversational_implicit_prompt_preference")
+
+ conversational_unpaired_preference_dataset = Dataset.from_dict({
+ "prompt": [
+ [{"role": "user", "content": "What is better than ugly?"}],
+ [{"role": "user", "content": "What is better than implicit?"}],
+ [{"role": "user", "content": "What is better than complex?"}],
+ [{"role": "user", "content": "What is better than complicated?"}],
+ [{"role": "user", "content": "What is better than nested?"}],
+ [{"role": "user", "content": "What is better than dense?"}],
+ [{"role": "user", "content": "What counts?"}],
+ [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+ [{"role": "user", "content": "What beats purity?"}],
+ [{"role": "user", "content": "What should never pass silently?"}],
+ [{"role": "user", "content": "When can errors pass silently?"}],
+ [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+ [{"role": "user", "content": "How many ways should there be to do it?"}],
+ [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+ [{"role": "user", "content": "What is better than never?"}],
+ [{"role": "user", "content": "Is never better than *right* now?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+ [{"role": "user", "content": "Any great ideas?"}],
+ ],
+ "completion": [
+ [{'role': 'assistant', 'content': 'Beautiful.'}],
+ [{'role': 'assistant', 'content': 'Explicit.'}],
+ [{'role': 'assistant', 'content': 'Simple.'}],
+ [{'role': 'assistant', 'content': 'Very complicated.'}],
+ [{'role': 'assistant', 'content': 'Flat.'}],
+ [{'role': 'assistant', 'content': 'Sparse.'}],
+ [{'role': 'assistant', 'content': 'Readability.'}],
+ [{'role': 'assistant', 'content': 'Yes, special cases are special enough to break the rules.'}],
+ [{'role': 'assistant', 'content': 'Practicality.'}],
+ [{'role': 'assistant', 'content': 'Warnings.'}],
+ [{'role': 'assistant', 'content': 'When explicitly silenced.'}],
+ [{'role': 'assistant', 'content': 'Give up.'}],
+ [{'role': 'assistant', 'content': 'One, and preferably only one.'}],
+ [{'role': 'assistant', 'content': 'French.'}],
+ [{'role': 'assistant', 'content': 'Some day.'}],
+ [{'role': 'assistant', 'content': 'Yes, often.'}],
+ [{'role': 'assistant', 'content': "It means it's a bad idea."}],
+ [{'role': 'assistant', 'content': 'It means it may be a good idea.'}],
+ [{'role': 'assistant', 'content': 'Namespaces are one honking great idea.'}],
+ ],
+ "label": [True, True, True, False, True, True, True, False, True, False, True, False, True, False, False, True, True, True, True],
+ })
+ conversational_unpaired_preference_dataset = conversational_unpaired_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ conversational_unpaired_preference_dataset.push_to_hub(repo_id, config_name="conversational_unpaired_preference")
+ # fmt: on
+
+
+if __name__ == "__main__":
+ parser = HfArgumentParser(ScriptArguments)
+ script_args = parser.parse_args_into_dataclasses()[0]
+ main(script_args.test_size, script_args.push_to_hub, script_args.repo_id)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_zen_image_dataset.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_zen_image_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..dff74d2d062d3b9d77db47120364801fdac9fc5e
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_zen_image_dataset.py
@@ -0,0 +1,346 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+
+import numpy as np
+from datasets import Dataset, Features, Image, Value
+from transformers import HfArgumentParser
+
+
+Message = [{"content": Value("string"), "role": Value("string")}]
+
+
+@dataclass
+class ScriptArguments:
+ r"""
+ Arguments for the script.
+
+ Args:
+ test_size (`float`, *optional*, defaults to `0.1`):
+ Fraction of the dataset to include in the test split.
+ push_to_hub (`bool`, *optional*, defaults to `False`):
+ Whether to push the dataset to the Hugging Face Hub.
+ repo_id (`str`, *optional*, defaults to `"trl-internal-testing/zen-image"`):
+ Hugging Face repository ID to push the dataset to.
+ """
+
+ test_size: float = field(
+ default=0.1,
+ metadata={"help": "Fraction of the dataset to include in the test split."},
+ )
+ push_to_hub: bool = field(
+ default=False,
+ metadata={"help": "Whether to push the dataset to the Hugging Face Hub."},
+ )
+ repo_id: str = field(
+ default="trl-internal-testing/zen-image",
+ metadata={"help": "Hugging Face repository ID to push the dataset to."},
+ )
+
+
+def main(test_size, push_to_hub, repo_id):
+ # fmt: off
+ sizes = np.random.randint(32, 64, size=(19, 2))
+ data = {
+ "messages": [
+ [{"role": "user", "content": "What is better than ugly?"}, {"role": "assistant", "content": "Beautiful."},],
+ [{"role": "user", "content": "What is better than implicit?"}, {"role": "assistant", "content": "Explicit."}],
+ [{"role": "user", "content": "What is better than complex?"}, {"role": "assistant", "content": "Simple."}],
+ [{"role": "user", "content": "What is better than complicated?"}, {"role": "assistant", "content": "Complex."}],
+ [{"role": "user", "content": "What is better than nested?"}, {"role": "assistant", "content": "Flat."}],
+ [{"role": "user", "content": "What is better than dense?"}, {"role": "assistant", "content": "Sparse."}],
+ [{"role": "user", "content": "What counts?"}, {"role": "assistant", "content": "Readability."}],
+ [{"role": "user", "content": "Are special cases enough to break the rules?"}, {"role": "assistant", "content": "No, special cases aren't special enough to break the rules."}],
+ [{"role": "user", "content": "What beats purity?"}, {"role": "assistant", "content": "Practicality."}],
+ [{"role": "user", "content": "What should never pass silently?"}, {"role": "assistant", "content": "Errors."}],
+ [{"role": "user", "content": "When can errors pass silently?"}, {"role": "assistant", "content": "When explicitly silenced."}],
+ [{"role": "user", "content": "What should you do in the face of ambiguity?"}, {"role": "assistant", "content": "Refuse the temptation to guess."}],
+ [{"role": "user", "content": "How many ways should there be to do it?"}, {"role": "assistant", "content": "One, and preferably only one."}],
+ [{"role": "user", "content": "For whom may the way not be obvious at first?"}, {"role": "assistant", "content": "Dutch."}],
+ [{"role": "user", "content": "What is better than never?"}, {"role": "assistant", "content": "Now is better than never."}],
+ [{"role": "user", "content": "Is never better than *right* now?"}, {"role": "assistant", "content": "Yes, often."}],
+ [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}, {"role": "assistant", "content": "It means it's a bad idea."}],
+ [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}, {"role": "assistant", "content": "It means it may be a good idea."}],
+ [{"role": "user", "content": "Any great ideas?"}, {"role": "assistant", "content": "Namespaces are one honking great idea."}],
+ ],
+ "image": [np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in sizes],
+ }
+ conversational_language_modeling_dataset = Dataset.from_dict(data, features=Features(messages=Message, image=Image()))
+ conversational_language_modeling_dataset = conversational_language_modeling_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ conversational_language_modeling_dataset.push_to_hub(repo_id, config_name="conversational_language_modeling")
+
+ sizes = np.random.randint(32, 64, size=(19, 2))
+ data = {
+ "prompt": [
+ [{"role": "user", "content": "What is better than ugly?"}],
+ [{"role": "user", "content": "What is better than implicit?"}],
+ [{"role": "user", "content": "What is better than complex?"}],
+ [{"role": "user", "content": "What is better than complicated?"}],
+ [{"role": "user", "content": "What is better than nested?"}],
+ [{"role": "user", "content": "What is better than dense?"}],
+ [{"role": "user", "content": "What counts?"}],
+ [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+ [{"role": "user", "content": "What beats purity?"}],
+ [{"role": "user", "content": "What should never pass silently?"}],
+ [{"role": "user", "content": "When can errors pass silently?"}],
+ [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+ [{"role": "user", "content": "How many ways should there be to do it?"}],
+ [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+ [{"role": "user", "content": "What is better than never?"}],
+ [{"role": "user", "content": "Is never better than *right* now?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+ [{"role": "user", "content": "Any great ideas?"}],
+ ],
+ "image": [np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in sizes],
+ }
+ conversational_prompt_only_dataset = Dataset.from_dict(data, features=Features(prompt=Message, image=Image()))
+ conversational_prompt_only_dataset = conversational_prompt_only_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ conversational_prompt_only_dataset.push_to_hub(repo_id, config_name="conversational_prompt_only")
+
+ sizes = np.random.randint(32, 64, size=(19, 2))
+ data = {
+ "prompt": [
+ [{"role": "user", "content": "What is better than ugly?"}],
+ [{"role": "user", "content": "What is better than implicit?"}],
+ [{"role": "user", "content": "What is better than complex?"}],
+ [{"role": "user", "content": "What is better than complicated?"}],
+ [{"role": "user", "content": "What is better than nested?"}],
+ [{"role": "user", "content": "What is better than dense?"}],
+ [{"role": "user", "content": "What counts?"}],
+ [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+ [{"role": "user", "content": "What beats purity?"}],
+ [{"role": "user", "content": "What should never pass silently?"}],
+ [{"role": "user", "content": "When can errors pass silently?"}],
+ [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+ [{"role": "user", "content": "How many ways should there be to do it?"}],
+ [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+ [{"role": "user", "content": "What is better than never?"}],
+ [{"role": "user", "content": "Is never better than *right* now?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+ [{"role": "user", "content": "Any great ideas?"}],
+ ],
+ "completion": [
+ [{"role": "assistant", "content": "Beautiful."}],
+ [{"role": "assistant", "content": "Explicit."}],
+ [{"role": "assistant", "content": "Simple."}],
+ [{"role": "assistant", "content": "Complex."}],
+ [{"role": "assistant", "content": "Flat."}],
+ [{"role": "assistant", "content": "Sparse."}],
+ [{"role": "assistant", "content": "Readability."}],
+ [{"role": "assistant", "content": "No, special cases aren't special enough to break the rules."}],
+ [{"role": "assistant", "content": "Practicality."}],
+ [{"role": "assistant", "content": "Errors."}],
+ [{"role": "assistant", "content": "When explicitly silenced."}],
+ [{"role": "assistant", "content": "Refuse the temptation to guess."}],
+ [{"role": "assistant", "content": "One, and preferably only one."}],
+ [{"role": "assistant", "content": "Dutch."}],
+ [{"role": "assistant", "content": "Now is better than never."}],
+ [{"role": "assistant", "content": "Yes, often."}],
+ [{"role": "assistant", "content": "It means it's a bad idea."}],
+ [{"role": "assistant", "content": "It means it may be a good idea."}],
+ [{"role": "assistant", "content": "Namespaces are one honking great idea."}],
+ ],
+ "image": [np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in sizes],
+ }
+ conversational_prompt_completion_dataset = Dataset.from_dict(data, features=Features(prompt=Message, completion=Message, image=Image()))
+ conversational_prompt_completion_dataset = conversational_prompt_completion_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ conversational_prompt_completion_dataset.push_to_hub(repo_id, config_name="conversational_prompt_completion")
+
+ sizes = np.random.randint(32, 64, size=(19, 2))
+ data = {
+ "prompt": [
+ [{"role": "user", "content": "What is better than ugly?"}],
+ [{"role": "user", "content": "What is better than implicit?"}],
+ [{"role": "user", "content": "What is better than complex?"}],
+ [{"role": "user", "content": "What is better than complicated?"}],
+ [{"role": "user", "content": "What is better than nested?"}],
+ [{"role": "user", "content": "What is better than dense?"}],
+ [{"role": "user", "content": "What counts?"}],
+ [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+ [{"role": "user", "content": "What beats purity?"}],
+ [{"role": "user", "content": "What should never pass silently?"}],
+ [{"role": "user", "content": "When can errors pass silently?"}],
+ [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+ [{"role": "user", "content": "How many ways should there be to do it?"}],
+ [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+ [{"role": "user", "content": "What is better than never?"}],
+ [{"role": "user", "content": "Is never better than *right* now?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+ [{"role": "user", "content": "Any great ideas?"}],
+ ],
+ "chosen": [
+ [{"role": "assistant", "content": "Beautiful."}],
+ [{"role": "assistant", "content": "Explicit."}],
+ [{"role": "assistant", "content": "Simple."}],
+ [{"role": "assistant", "content": "Complex."}],
+ [{"role": "assistant", "content": "Flat."}],
+ [{"role": "assistant", "content": "Sparse."}],
+ [{"role": "assistant", "content": "Readability."}],
+ [{"role": "assistant", "content": "No, special cases aren't special enough to break the rules."}],
+ [{"role": "assistant", "content": "Practicality."}],
+ [{"role": "assistant", "content": "Errors."}],
+ [{"role": "assistant", "content": "When explicitly silenced."}],
+ [{"role": "assistant", "content": "Refuse the temptation to guess."}],
+ [{"role": "assistant", "content": "One, and preferably only one."}],
+ [{"role": "assistant", "content": "Dutch."}],
+ [{"role": "assistant", "content": "Now is better than never."}],
+ [{"role": "assistant", "content": "Yes, often."}],
+ [{"role": "assistant", "content": "It means it's a bad idea."}],
+ [{"role": "assistant", "content": "It means it may be a good idea."}],
+ [{"role": "assistant", "content": "Namespaces are one honking great idea."}],
+ ],
+ "rejected": [
+ [{"role": "assistant", "content": "Acceptable."}],
+ [{"role": "assistant", "content": "Explained."}],
+ [{"role": "assistant", "content": "Very complex."}],
+ [{"role": "assistant", "content": "Very complicated."}],
+ [{"role": "assistant", "content": "Circular."}],
+ [{"role": "assistant", "content": "Heavy."}],
+ [{"role": "assistant", "content": "Looking complicated."}],
+ [{"role": "assistant", "content": "Yes, special cases are special enough to break the rules."}],
+ [{"role": "assistant", "content": "Nothing."}],
+ [{"role": "assistant", "content": "Warnings."}],
+ [{"role": "assistant", "content": "Never."}],
+ [{"role": "assistant", "content": "Give up."}],
+ [{"role": "assistant", "content": "As many as possible."}],
+ [{"role": "assistant", "content": "French."}],
+ [{"role": "assistant", "content": "Some day."}],
+ [{"role": "assistant", "content": "No, never."}],
+ [{"role": "assistant", "content": "It means it's a good idea."}],
+ [{"role": "assistant", "content": "It means it's a bad idea."}],
+ [{"role": "assistant", "content": "Recursion."}],
+ ],
+ "image": [np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in sizes],
+ }
+ conversational_preference_dataset = Dataset.from_dict(data, features=Features(prompt=Message, chosen=Message, rejected=Message, image=Image()))
+ conversational_preference_dataset = conversational_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ conversational_preference_dataset.push_to_hub(repo_id, config_name="conversational_preference")
+
+ sizes = np.random.randint(32, 64, size=(19, 2))
+ data = {
+ "chosen": [
+ [{"role": "user", "content": "What is better than ugly?"}, {"role": "assistant", "content": "Beautiful."}],
+ [{"role": "user", "content": "What is better than implicit?"}, {"role": "assistant", "content": "Explicit."}],
+ [{"role": "user", "content": "What is better than complex?"}, {"role": "assistant", "content": "Simple."}],
+ [{"role": "user", "content": "What is better than complicated?"}, {"role": "assistant", "content": "Complex."}],
+ [{"role": "user", "content": "What is better than nested?"}, {"role": "assistant", "content": "Flat."}],
+ [{"role": "user", "content": "What is better than dense?"}, {"role": "assistant", "content": "Sparse."}],
+ [{"role": "user", "content": "What counts?"}, {"role": "assistant", "content": "Readability."}],
+ [{"role": "user", "content": "Are special cases enough to break the rules?"}, {"role": "assistant", "content": "No, special cases aren't special enough to break the rules."}],
+ [{"role": "user", "content": "What beats purity?"}, {"role": "assistant", "content": "Practicality."}],
+ [{"role": "user", "content": "What should never pass silently?"}, {"role": "assistant", "content": "Errors."}],
+ [{"role": "user", "content": "When can errors pass silently?"}, {"role": "assistant", "content": "When explicitly silenced."}],
+ [{"role": "user", "content": "What should you do in the face of ambiguity?"}, {"role": "assistant", "content": "Refuse the temptation to guess."}],
+ [{"role": "user", "content": "How many ways should there be to do it?"}, {"role": "assistant", "content": "One, and preferably only one."}],
+ [{"role": "user", "content": "For whom may the way not be obvious at first?"}, {"role": "assistant", "content": "Dutch."}],
+ [{"role": "user", "content": "What is better than never?"}, {"role": "assistant", "content": "Now is better than never."}],
+ [{"role": "user", "content": "Is never better than *right* now?"}, {"role": "assistant", "content": "Yes, often."}],
+ [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}, {"role": "assistant", "content": "It means it's a bad idea."}],
+ [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}, {"role": "assistant", "content": "It means it may be a good idea."}],
+ [{"role": "user", "content": "Any great ideas?"}, {"role": "assistant", "content": "Namespaces are one honking great idea."}],
+ ],
+ "rejected": [
+ [{"role": "user", "content": "What is better than ugly?"}, {"role": "assistant", "content": "Acceptable."}],
+ [{"role": "user", "content": "What is better than implicit?"}, {"role": "assistant", "content": "Explained."}],
+ [{"role": "user", "content": "What is better than complex?"}, {"role": "assistant", "content": "Very complex."}],
+ [{"role": "user", "content": "What is better than complicated?"}, {"role": "assistant", "content": "Very complicated."}],
+ [{"role": "user", "content": "What is better than nested?"}, {"role": "assistant", "content": "Circular."}],
+ [{"role": "user", "content": "What is better than dense?"}, {"role": "assistant", "content": "Heavy."}],
+ [{"role": "user", "content": "What counts?"}, {"role": "assistant", "content": "Looking complicated."}],
+ [{"role": "user", "content": "Are special cases enough to break the rules?"}, {"role": "assistant", "content": "Yes, special cases are special enough to break the rules."}],
+ [{"role": "user", "content": "What beats purity?"}, {"role": "assistant", "content": "Nothing."}],
+ [{"role": "user", "content": "What should never pass silently?"}, {"role": "assistant", "content": "Warnings."}],
+ [{"role": "user", "content": "When can errors pass silently?"}, {"role": "assistant", "content": "Never."}],
+ [{"role": "user", "content": "What should you do in the face of ambiguity?"}, {"role": "assistant", "content": "Give up."}],
+ [{"role": "user", "content": "How many ways should there be to do it?"}, {"role": "assistant", "content": "As many as possible."}],
+ [{"role": "user", "content": "For whom may the way not be obvious at first?"}, {"role": "assistant", "content": "French."}],
+ [{"role": "user", "content": "What is better than never?"}, {"role": "assistant", "content": "Some day."}],
+ [{"role": "user", "content": "Is never better than *right* now?"}, {"role": "assistant", "content": "No, never."}],
+ [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}, {"role": "assistant", "content": "It means it's a good idea."}],
+ [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}, {"role": "assistant", "content": "It means it's a bad idea."}],
+ [{"role": "user", "content": "Any great ideas?"}, {"role": "assistant", "content": "Recursion."}],
+ ],
+ "image": [np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in sizes],
+ }
+ conversational_implicit_prompt_preference_dataset = Dataset.from_dict(data, features=Features(chosen=Message, rejected=Message, image=Image()))
+ conversational_implicit_prompt_preference_dataset = conversational_implicit_prompt_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ conversational_implicit_prompt_preference_dataset.push_to_hub(repo_id, config_name="conversational_implicit_prompt_preference")
+
+ sizes = np.random.randint(32, 64, size=(19, 2))
+ data = {
+ "prompt": [
+ [{"role": "user", "content": "What is better than ugly?"}],
+ [{"role": "user", "content": "What is better than implicit?"}],
+ [{"role": "user", "content": "What is better than complex?"}],
+ [{"role": "user", "content": "What is better than complicated?"}],
+ [{"role": "user", "content": "What is better than nested?"}],
+ [{"role": "user", "content": "What is better than dense?"}],
+ [{"role": "user", "content": "What counts?"}],
+ [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+ [{"role": "user", "content": "What beats purity?"}],
+ [{"role": "user", "content": "What should never pass silently?"}],
+ [{"role": "user", "content": "When can errors pass silently?"}],
+ [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+ [{"role": "user", "content": "How many ways should there be to do it?"}],
+ [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+ [{"role": "user", "content": "What is better than never?"}],
+ [{"role": "user", "content": "Is never better than *right* now?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+ [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+ [{"role": "user", "content": "Any great ideas?"}],
+ ],
+ "completion": [
+ [{'role': 'assistant', 'content': 'Beautiful.'}],
+ [{'role': 'assistant', 'content': 'Explicit.'}],
+ [{'role': 'assistant', 'content': 'Simple.'}],
+ [{'role': 'assistant', 'content': 'Very complicated.'}],
+ [{'role': 'assistant', 'content': 'Flat.'}],
+ [{'role': 'assistant', 'content': 'Sparse.'}],
+ [{'role': 'assistant', 'content': 'Readability.'}],
+ [{'role': 'assistant', 'content': 'Yes, special cases are special enough to break the rules.'}],
+ [{'role': 'assistant', 'content': 'Practicality.'}],
+ [{'role': 'assistant', 'content': 'Warnings.'}],
+ [{'role': 'assistant', 'content': 'When explicitly silenced.'}],
+ [{'role': 'assistant', 'content': 'Give up.'}],
+ [{'role': 'assistant', 'content': 'One, and preferably only one.'}],
+ [{'role': 'assistant', 'content': 'French.'}],
+ [{'role': 'assistant', 'content': 'Some day.'}],
+ [{'role': 'assistant', 'content': 'Yes, often.'}],
+ [{'role': 'assistant', 'content': "It means it's a bad idea."}],
+ [{'role': 'assistant', 'content': 'It means it may be a good idea.'}],
+ [{'role': 'assistant', 'content': 'Namespaces are one honking great idea.'}],
+ ],
+ "label": [True, True, True, False, True, True, True, False, True, False, True, False, True, False, False, True, True, True, True],
+ "image": [np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in sizes],
+ }
+ conversational_unpaired_preference_dataset = Dataset.from_dict(data, features=Features(prompt=Message, completion=Message, label=Value("bool"), image=Image()))
+ conversational_unpaired_preference_dataset = conversational_unpaired_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ conversational_unpaired_preference_dataset.push_to_hub(repo_id, config_name="conversational_unpaired_preference")
+ # fmt: on
+
+
+if __name__ == "__main__":
+ parser = HfArgumentParser(ScriptArguments)
+ script_args = parser.parse_args_into_dataclasses()[0]
+ main(script_args.test_size, script_args.push_to_hub, script_args.repo_id)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_zen_multi_image_dataset.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_zen_multi_image_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb7089386eab6aefc51e27d24d306c1529612a62
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/generate_zen_multi_image_dataset.py
@@ -0,0 +1,243 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+
+import numpy as np
+from datasets import Dataset, Features, Image, List, Value
+from transformers import HfArgumentParser
+
+
+Message = List({"content": List({"text": Value("string"), "type": Value("string")}), "role": Value("string")})
+
+
+@dataclass
+class ScriptArguments:
+ r"""
+ Arguments for the script.
+
+ Args:
+ test_size (`float`, *optional*, defaults to `0.1`):
+ Fraction of the dataset to include in the test split.
+ push_to_hub (`bool`, *optional*, defaults to `False`):
+ Whether to push the dataset to the Hugging Face Hub.
+ repo_id (`str`, *optional*, defaults to `"trl-internal-testing/zen-multi-image"`):
+ Hugging Face repository ID to push the dataset to.
+ """
+
+ test_size: float = field(
+ default=0.1,
+ metadata={"help": "Fraction of the dataset to include in the test split."},
+ )
+ push_to_hub: bool = field(
+ default=False,
+ metadata={"help": "Whether to push the dataset to the Hugging Face Hub."},
+ )
+ repo_id: str = field(
+ default="trl-internal-testing/zen-multi-image",
+ metadata={"help": "Hugging Face repository ID to push the dataset to."},
+ )
+
+
+def main(test_size, push_to_hub, repo_id):
+ # fmt: off
+ messages = [
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than ugly?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Beautiful."}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What is better than implicit?"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Explicit."}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than complex?"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Simple."}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "image"}, {"type": "text", "text": "What is better than complicated?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Complex."}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than nested?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Flat."}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What is better than dense?"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Sparse."}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What counts?"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Readability."}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "Are special cases enough to break the rules?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "No, special cases aren't special enough to break the rules."}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What beats purity?"}, {"type": "image"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Practicality."}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "image"}, {"type": "text", "text": "What should never pass silently?"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Errors."}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "When can errors pass silently?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "When explicitly silenced."}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What should you do in the face of ambiguity?"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Refuse the temptation to guess."}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "How many ways should there be to do it?"}, {"type": "image"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "One, and preferably only one."}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "For whom may the way not be obvious at first?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Dutch."}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What is better than never?"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Now is better than never."}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "Is"}, {"type": "image"}, {"type": "text", "text": " never better than *right* now?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Yes, often."}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What does it mean if the implementation is hard to explain?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "It means it's a bad idea."}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What does it mean if the implementation is easy to explain?"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "It means it may be a good idea."}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "Any great ideas?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Namespaces are one honking great idea."}]}],
+ ]
+ # Create the images
+ number_of_images = [sum(1 for part in row[0]["content"] if part.get("type") == "image") for row in messages]
+ sizes = [np.random.randint(32, 64, size=(num_images, 2)) for num_images in number_of_images]
+ images = [[np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in s] for s in sizes]
+ conversational_language_modeling_dataset = Dataset.from_dict({"messages": messages, "images": images}, features=Features(messages=Message, images=List(Image())))
+ conversational_language_modeling_dataset = conversational_language_modeling_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ conversational_language_modeling_dataset.push_to_hub(repo_id, config_name="conversational_language_modeling")
+
+ prompt = [
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than ugly?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What is better than implicit?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than complex?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "image"}, {"type": "text", "text": "What is better than complicated?"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than nested?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What is better than dense?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What counts?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "Are special cases enough to break the rules?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What beats purity?"}, {"type": "image"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "image"}, {"type": "text", "text": "What should never pass silently?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "When can errors pass silently?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What should you do in the face of ambiguity?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "How many ways should there be to do it?"}, {"type": "image"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "For whom may the way not be obvious at first?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What is better than never?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "Is"}, {"type": "image"}, {"type": "text", "text": " never better than *right* now?"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What does it mean if the implementation is hard to explain?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What does it mean if the implementation is easy to explain?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "Any great ideas?"}]}],
+ ]
+ # Create the images
+ number_of_images = [sum(1 for part in row[0]["content"] if part.get("type") == "image") for row in prompt]
+ sizes = [np.random.randint(32, 64, size=(num_images, 2)) for num_images in number_of_images]
+ images = [[np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in s] for s in sizes]
+ conversational_prompt_only_dataset = Dataset.from_dict({"prompt": prompt, "images": images}, features=Features(prompt=Message, images=List(Image())))
+ conversational_prompt_only_dataset = conversational_prompt_only_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ conversational_prompt_only_dataset.push_to_hub(repo_id, config_name="conversational_prompt_only")
+
+ prompt = [
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than ugly?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What is better than implicit?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than complex?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "image"}, {"type": "text", "text": "What is better than complicated?"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than nested?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What is better than dense?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What counts?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "Are special cases enough to break the rules?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What beats purity?"}, {"type": "image"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "image"}, {"type": "text", "text": "What should never pass silently?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "When can errors pass silently?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What should you do in the face of ambiguity?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "How many ways should there be to do it?"}, {"type": "image"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "For whom may the way not be obvious at first?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What is better than never?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "Is"}, {"type": "image"}, {"type": "text", "text": " never better than *right* now?"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What does it mean if the implementation is hard to explain?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What does it mean if the implementation is easy to explain?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "Any great ideas?"}]}],
+ ]
+ completion = [
+ [{"role": "assistant", "content": [{"type": "text", "text": "Beautiful."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Explicit."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Simple."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Complex."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Flat."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Sparse."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Readability."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "No, special cases aren't special enough to break the rules."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Practicality."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Errors."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "When explicitly silenced."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Refuse the temptation to guess."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "One, and preferably only one."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Dutch."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Now is better than never."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Yes, often."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "It means it's a bad idea."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "It means it may be a good idea."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Namespaces are one honking great idea."}]}],
+ ]
+ # Create the images
+ number_of_images = [sum(1 for part in row[0]["content"] if part.get("type") == "image") for row in prompt]
+ sizes = [np.random.randint(32, 64, size=(num_images, 2)) for num_images in number_of_images]
+ images = [[np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in s] for s in sizes]
+ conversational_prompt_completion_dataset = Dataset.from_dict({"prompt": prompt, "completion": completion, "images": images}, features=Features(prompt=Message, completion=Message, images=List(Image())))
+ conversational_prompt_completion_dataset = conversational_prompt_completion_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ conversational_prompt_completion_dataset.push_to_hub(repo_id, config_name="conversational_prompt_completion")
+
+ prompt = [
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than ugly?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What is better than implicit?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than complex?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "image"}, {"type": "text", "text": "What is better than complicated?"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than nested?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What is better than dense?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What counts?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "Are special cases enough to break the rules?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What beats purity?"}, {"type": "image"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "image"}, {"type": "text", "text": "What should never pass silently?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "When can errors pass silently?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What should you do in the face of ambiguity?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "How many ways should there be to do it?"}, {"type": "image"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "For whom may the way not be obvious at first?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What is better than never?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "Is"}, {"type": "image"}, {"type": "text", "text": " never better than *right* now?"}]}],
+ [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What does it mean if the implementation is hard to explain?"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "What does it mean if the implementation is easy to explain?"}, {"type": "image"}]}],
+ [{"role": "user", "content": [{"type": "text", "text": "Any great ideas?"}]}],
+ ]
+ chosen = [
+ [{"role": "assistant", "content": [{"type": "text", "text": "Beautiful."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Explicit."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Simple."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Complex."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Flat."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Sparse."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Readability."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "No, special cases aren't special enough to break the rules."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Practicality."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Errors."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "When explicitly silenced."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Refuse the temptation to guess."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "One, and preferably only one."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Dutch."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Now is better than never."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Yes, often."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "It means it's a bad idea."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "It means it may be a good idea."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Namespaces are one honking great idea."}]}],
+ ]
+ rejected = [
+ [{"role": "assistant", "content": [{"type": "text", "text": "Acceptable."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Explained."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Very complex."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Very complicated."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Circular."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Heavy."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Looking complicated."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Yes, special cases are special enough to break the rules."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Nothing."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Warnings."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Never."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Give up."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "As many as possible."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "French."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Some day."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "No, never."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "It means it's a good idea."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "It means it's a bad idea."}]}],
+ [{"role": "assistant", "content": [{"type": "text", "text": "Recursion."}]}],
+ ]
+ # Create the images
+ number_of_images = [sum(1 for part in row[0]["content"] if part.get("type") == "image") for row in prompt]
+ sizes = [np.random.randint(32, 64, size=(num_images, 2)) for num_images in number_of_images]
+ images = [[np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in s] for s in sizes]
+ conversational_preference_dataset = Dataset.from_dict({"prompt": prompt, "chosen": chosen, "rejected": rejected, "images": images}, features=Features(prompt=Message, chosen=Message, rejected=Message, images=List(Image())))
+ conversational_preference_dataset = conversational_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+ if push_to_hub:
+ conversational_preference_dataset.push_to_hub(repo_id, config_name="conversational_preference")
+ # fmt: on
+
+
+if __name__ == "__main__":
+ parser = HfArgumentParser(ScriptArguments)
+ script_args = parser.parse_args_into_dataclasses()[0]
+ main(script_args.test_size, script_args.push_to_hub, script_args.repo_id)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/scripts/log_reports.py b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/log_reports.py
new file mode 100644
index 0000000000000000000000000000000000000000..a3f2a88f0cdef53f45cf016951a576e230a1a9cd
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/scripts/log_reports.py
@@ -0,0 +1,169 @@
+# 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 json
+import logging
+import os
+from datetime import date
+from pathlib import Path
+
+from tabulate import tabulate
+
+
+MAX_LEN_MESSAGE = 2900 # Slack endpoint has a limit of 3001 characters
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--slack_channel_name", default="trl-push-ci")
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+
+
+def process_log_file(log):
+ failed_tests = []
+ passed_tests = []
+ section_num_failed = 0
+
+ try:
+ with open(log) as f:
+ for line in f:
+ try:
+ data = json.loads(line)
+ test_name = data.get("nodeid", "")
+ duration = f"{data['duration']:.4f}" if "duration" in data else "N/A"
+ outcome = data.get("outcome", "")
+
+ if test_name:
+ if outcome == "failed":
+ section_num_failed += 1
+ failed_tests.append([test_name, duration, log.stem.split("_")[0]])
+ else:
+ passed_tests.append([test_name, duration, log.stem.split("_")[0]])
+ except json.JSONDecodeError as e:
+ logging.warning(f"Could not decode line in {log}: {e}")
+
+ except FileNotFoundError as e:
+ logging.error(f"Log file {log} not found: {e}")
+ except Exception as e:
+ logging.error(f"Error processing log file {log}: {e}")
+
+ return failed_tests, passed_tests, section_num_failed
+
+
+def main(slack_channel_name):
+ group_info = []
+ total_num_failed = 0
+ total_empty_files = []
+
+ log_files = list(Path().glob("*.log"))
+ if not log_files:
+ logging.info("No log files found.")
+ return
+
+ for log in log_files:
+ failed, passed, section_num_failed = process_log_file(log)
+ empty_file = not failed and not passed
+
+ total_num_failed += section_num_failed
+ total_empty_files.append(empty_file)
+ group_info.append([str(log), section_num_failed, failed])
+
+ # Clean up log file
+ try:
+ os.remove(log)
+ except OSError as e:
+ logging.warning(f"Could not remove log file {log}: {e}")
+
+ # Prepare Slack message payload
+ payload = [
+ {
+ "type": "header",
+ "text": {"type": "plain_text", "text": f"🤗 Results of the {os.environ.get('TEST_TYPE', '')} TRL tests."},
+ },
+ ]
+
+ if total_num_failed > 0:
+ message = ""
+ for name, num_failed, failed_tests in group_info:
+ if num_failed > 0:
+ message += f"*{name}: {num_failed} failed test(s)*\n"
+ failed_table = [
+ test[0].split("::")[:2] + [test[0].split("::")[-1][:30] + ".."] for test in failed_tests
+ ]
+ message += (
+ "\n```\n"
+ + tabulate(failed_table, headers=["Test Location", "Test Name"], tablefmt="grid")
+ + "\n```\n"
+ )
+
+ if any(total_empty_files):
+ message += f"\n*{name}: Warning! Empty file - check GitHub action job*\n"
+
+ # Logging
+ logging.info(f"Total failed tests: {total_num_failed}")
+ print(f"### {message}")
+
+ if len(message) > MAX_LEN_MESSAGE:
+ message = (
+ f"❌ There are {total_num_failed} failed tests in total! Please check the action results directly."
+ )
+
+ payload.append({"type": "section", "text": {"type": "mrkdwn", "text": message}})
+ payload.append(
+ {
+ "type": "section",
+ "text": {"type": "mrkdwn", "text": "*For more details:*"},
+ "accessory": {
+ "type": "button",
+ "text": {"type": "plain_text", "text": "Check Action results"},
+ "url": f"https://github.com/huggingface/trl/actions/runs/{os.environ['GITHUB_RUN_ID']}",
+ },
+ }
+ )
+ payload.append(
+ {
+ "type": "context",
+ "elements": [
+ {
+ "type": "plain_text",
+ "text": f"On Push main {os.environ.get('TEST_TYPE')} results for {date.today()}",
+ }
+ ],
+ }
+ )
+
+ # Send to Slack
+ from slack_sdk import WebClient
+
+ slack_client = WebClient(token=os.environ.get("SLACK_API_TOKEN"))
+ slack_client.chat_postMessage(channel=f"#{slack_channel_name}", text=message, blocks=payload)
+
+ else:
+ payload.append(
+ {
+ "type": "section",
+ "text": {
+ "type": "plain_text",
+ "text": "✅ No failures! All tests passed successfully.",
+ "emoji": True,
+ },
+ }
+ )
+ logging.info("All tests passed. No errors detected.")
+
+
+if __name__ == "__main__":
+ args = parser.parse_args()
+ main(args.slack_channel_name)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/__init__.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d2777dd0eb21a0ea67dce8775337a27ea8499da2
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/__init__.py
@@ -0,0 +1,13 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/conftest.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..7eb74f893a562081569b2a044ea42849b72530ec
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/conftest.py
@@ -0,0 +1,136 @@
+# 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 traceback
+from functools import wraps
+
+import pytest
+import torch
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_runtest_makereport(item, call):
+ """Clear traceback frame locals after a failed test to release CUDA tensor references.
+
+ When a test fails (especially with OOM), the exception traceback holds references to every local variable in every
+ frame on the call stack at the time of failure — including the model, trainer, and all intermediate tensors.
+ gc.collect() cannot free objects that are still reachable through a live traceback, so memory accumulates across
+ reruns (~2 GiB per rerun for Gemma4, reaching 5 × 2.38 GiB = 11.89 GiB after 5 reruns). Clearing the frame locals
+ breaks those reference chains so that the subsequent gc.collect() + empty_cache() in cleanup_gpu can actually
+ reclaim the CUDA memory before the next attempt.
+ """
+ yield
+ if call.when == "call" and call.excinfo is not None:
+ traceback.clear_frames(call.excinfo.tb)
+ # Also clear all reachable chained exception tracebacks (both __context__ and __cause__ at
+ # every node): when OOM fires inside a try/except in the trainer, the OOM becomes __context__
+ # of the outer exception and its traceback holds frame locals (model, tensors) that prevent gc
+ # from releasing CUDA memory even after clear_frames above.
+ stack, seen = [call.excinfo.value], set()
+ while stack:
+ exc = stack.pop()
+ if exc is None or id(exc) in seen:
+ continue
+ seen.add(id(exc))
+ if exc.__traceback__ is not None:
+ traceback.clear_frames(exc.__traceback__)
+ exc.__traceback__ = None
+ stack.append(exc.__context__)
+ stack.append(exc.__cause__)
+
+
+# ============================================================================
+# Model Revision Override
+# ============================================================================
+# To test a tiny model PR before merging to main:
+# 1. Add the full model_id and PR revision to this dict
+# 2. Commit and push to trigger CI
+# 3. Once CI is green, merge the tiny model PR on HF Hub
+# 4. Remove the entry from this dict and commit
+#
+# Example:
+# MODEL_REVISIONS = {
+# "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5": "refs/pr/3",
+# "trl-internal-testing/tiny-LlavaForConditionalGeneration": "refs/pr/5",
+# }
+# ============================================================================
+
+MODEL_REVISIONS = {
+ # Add model_id: revision mappings here to test PRs
+}
+
+
+@pytest.fixture(autouse=True)
+def apply_model_revisions(monkeypatch):
+ """Auto-inject revision parameter for models defined in MODEL_REVISIONS."""
+ if not MODEL_REVISIONS:
+ return
+
+ from transformers import (
+ AutoConfig,
+ AutoModelForCausalLM,
+ AutoModelForSequenceClassification,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+ ProcessorMixin,
+ )
+
+ def create_classmethod_wrapper(original_classmethod):
+ # Extract the underlying function from the classmethod
+ original_func = original_classmethod.__func__
+
+ @wraps(original_func)
+ def wrapper(cls, pretrained_model_name_or_path, *args, **kwargs):
+ # Direct lookup: only inject if model_id is in the override dict
+ if pretrained_model_name_or_path in MODEL_REVISIONS:
+ if "revision" not in kwargs:
+ kwargs["revision"] = MODEL_REVISIONS[pretrained_model_name_or_path]
+ # Clear _commit_hash: Auto classes resolve it from the default branch before calling
+ # sub-loaders, so the cached hash points to main. If we don't clear it, it silently
+ # overrides the injected revision for the config load while the weight loader uses the
+ # revision, producing a config/weights shape mismatch.
+ kwargs.pop("_commit_hash", None)
+
+ return original_func(cls, pretrained_model_name_or_path, *args, **kwargs)
+
+ # Re-wrap as classmethod
+ return classmethod(wrapper)
+
+ # Patch all transformers Auto* classes
+ for cls in [
+ AutoConfig,
+ AutoModelForCausalLM,
+ AutoModelForSequenceClassification,
+ PreTrainedModel,
+ PreTrainedTokenizerBase,
+ ProcessorMixin,
+ ]:
+ monkeypatch.setattr(cls, "from_pretrained", create_classmethod_wrapper(cls.from_pretrained))
+
+
+@pytest.fixture(autouse=True)
+def cleanup_gpu():
+ """
+ Automatically cleanup GPU memory after each test.
+
+ This fixture helps prevent CUDA out of memory errors when running tests in parallel with pytest-xdist by ensuring
+ models and tensors are properly garbage collected and GPU memory caches are cleared between tests.
+ """
+ yield
+ # Cleanup after test
+ gc.collect()
+ if torch.cuda.is_available():
+ torch.cuda.empty_cache()
+ torch.cuda.synchronize()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/data/template.jinja b/tasks/tasksmith-466b1e8e082b/tests/source/tests/data/template.jinja
new file mode 100644
index 0000000000000000000000000000000000000000..01be9b307daa2d425f7c168c9fb145a286e0afb4
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/data/template.jinja
@@ -0,0 +1,89 @@
+{%- if tools %}
+ {{- '<|im_start|>system\n' }}
+ {%- if messages[0].role == 'system' %}
+ {{- messages[0].content + '\n\n' }}
+ {%- endif %}
+ {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within XML tags:\n" }}
+ {%- for tool in tools %}
+ {{- "\n" }}
+ {{- tool | tojson }}
+ {%- endfor %}
+ {{- "\n\n\nFor each function call, return a json object with function name and arguments within XML tags:\n\n{\"name\": , \"arguments\": }\n<|im_end|>\n" }}
+{%- else %}
+ {%- if messages[0].role == 'system' %}
+ {{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }}
+ {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+ {%- set index = (messages|length - 1) - loop.index0 %}
+ {%- if ns.multi_step_tool and message.role == "user" and message.content is string and not(message.content.startswith('') and message.content.endswith('')) %}
+ {%- set ns.multi_step_tool = false %}
+ {%- set ns.last_query_index = index %}
+ {%- endif %}
+{%- endfor %}
+{%- for message in messages %}
+ {%- if message.content is string %}
+ {%- set content = message.content %}
+ {%- else %}
+ {%- set content = '' %}
+ {%- endif %}
+ {%- 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 '' in content %}
+ {%- set reasoning_content = content.split(' | | ')[0].rstrip('\n').split('')[-1].lstrip('\n') %}
+ {%- set content = content.split('')[-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\n' + reasoning_content.strip('\n') + '\n\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 (loop.first and content) or (not loop.first) %}
+ {{- '\n' }}
+ {%- endif %}
+ {%- if tool_call.function %}
+ {%- set tool_call = tool_call.function %}
+ {%- endif %}
+ {{- '\n{"name": "' }}
+ {{- tool_call.name }}
+ {{- '", "arguments": ' }}
+ {%- if tool_call.arguments is string %}
+ {{- tool_call.arguments }}
+ {%- else %}
+ {{- tool_call.arguments | tojson }}
+ {%- endif %}
+ {{- '}\n' }}
+ {%- endfor %}
+ {%- endif %}
+ {{- '<|im_end|>\n' }}
+ {%- elif message.role == "tool" %}
+ {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+ {{- '<|im_start|>user' }}
+ {%- endif %}
+ {{- '\n\n' }}
+ {{- content }}
+ {{- '\n' }}
+ {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+ {{- '<|im_end|>\n' }}
+ {%- endif %}
+ {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+ {{- '<|im_start|>assistant\n' }}
+ {%- if enable_thinking is defined and enable_thinking is false %}
+ {{- '\n\n\n\n' }}
+ {%- endif %}
+{%- endif %}
\ No newline at end of file
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/__init__.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d26f4482fe3969b6de2b51bd1f85fc16dad6a65
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/__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.
+
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/data/accelerate_configs/ddp.yaml b/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/data/accelerate_configs/ddp.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..d5363d79686c57ac0e2b1a1e6f3f53a3b1eec102
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/data/accelerate_configs/ddp.yaml
@@ -0,0 +1,2 @@
+distributed_type: MULTI_GPU
+num_processes: 2
\ No newline at end of file
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/data/accelerate_configs/fsdp2.yaml b/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/data/accelerate_configs/fsdp2.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..274141f25833636ba2781193232d9c13d7d846c1
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/data/accelerate_configs/fsdp2.yaml
@@ -0,0 +1,4 @@
+distributed_type: FSDP
+fsdp_config:
+ fsdp_version: 2
+num_processes: 2
\ No newline at end of file
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/data/accelerate_configs/zero2.yaml b/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/data/accelerate_configs/zero2.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..2c51f5754cb3a51a96b9a94bc3f95ab69418ead0
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/data/accelerate_configs/zero2.yaml
@@ -0,0 +1,4 @@
+distributed_type: DEEPSPEED
+deepspeed_config:
+ zero_stage: 2
+num_processes: 2
\ No newline at end of file
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/data/accelerate_configs/zero3.yaml b/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/data/accelerate_configs/zero3.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..6ca9200eadb557b626d238c49f0dc153a54f1709
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/data/accelerate_configs/zero3.yaml
@@ -0,0 +1,4 @@
+distributed_type: DEEPSPEED
+deepspeed_config:
+ zero_stage: 3
+num_processes: 2
\ No newline at end of file
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/test_distributed.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/test_distributed.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e99bf0f4eaa13f73ef089fc980ca20316a93863
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/distributed/test_distributed.py
@@ -0,0 +1,378 @@
+# 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 pathlib import Path
+
+import pytest
+import torch
+import transformers
+from packaging.version import Version
+
+from ..testing_utils import TrlTestCase, require_liger_kernel, require_torch_multi_accelerator
+
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def run_command(command: list[str], env: dict[str, str]) -> None:
+ result = subprocess.run(command, env=env, cwd=ROOT)
+ assert result.returncode == 0
+
+
+@pytest.fixture
+def get_config_path(lazy_shared_datadir):
+ def _get_config_path(config_name):
+ return lazy_shared_datadir / "accelerate_configs" / f"{config_name}.yaml"
+
+ return _get_config_path
+
+
+@require_torch_multi_accelerator
+class TestDistributed(TrlTestCase):
+ @pytest.mark.parametrize(
+ "config",
+ [
+ "ddp",
+ pytest.param(
+ "zero2",
+ marks=pytest.mark.xfail(
+ Version(transformers.__version__) == Version("5.1.0"),
+ reason="Upstream incompatibility: deepspeed and transformers==5.1.0 (see transformers#43780)",
+ ),
+ ),
+ pytest.param(
+ "zero3",
+ marks=pytest.mark.xfail(
+ Version(transformers.__version__) == Version("5.1.0"),
+ reason="Upstream incompatibility: deepspeed and transformers==5.1.0 (see transformers#43780)",
+ ),
+ ),
+ "fsdp2",
+ ],
+ )
+ def test_sft(self, config, get_config_path):
+ # fmt: off
+ run_command(
+ [
+ "accelerate", "launch", "--config_file", get_config_path(config), "trl/scripts/sft.py",
+ "--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",
+ ],
+ os.environ.copy(),
+ )
+ # fmt: on
+
+ @pytest.mark.parametrize(
+ "config",
+ [
+ "ddp",
+ pytest.param(
+ "zero2",
+ marks=pytest.mark.xfail(
+ Version(transformers.__version__) == Version("5.1.0"),
+ reason="Upstream incompatibility: deepspeed and transformers==5.1.0 (see transformers#43780)",
+ ),
+ ),
+ pytest.param(
+ "zero3",
+ marks=pytest.mark.xfail(
+ Version(transformers.__version__) == Version("5.1.0"),
+ reason="Upstream incompatibility: deepspeed and transformers==5.1.0 (see transformers#43780)",
+ ),
+ ),
+ "fsdp2",
+ ],
+ )
+ def test_sft_nll_loss(self, config, get_config_path):
+ # fmt: off
+ run_command(
+ [
+ "accelerate", "launch", "--config_file", get_config_path(config), "trl/scripts/sft.py",
+ "--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",
+ "--loss_type", "nll",
+ ],
+ os.environ.copy(),
+ )
+ # fmt: on
+
+ @pytest.mark.parametrize(
+ "config",
+ [
+ "ddp",
+ pytest.param(
+ "zero2",
+ marks=pytest.mark.xfail(
+ Version(transformers.__version__) == Version("5.1.0"),
+ reason="Upstream incompatibility: deepspeed and transformers==5.1.0 (see transformers#43780)",
+ ),
+ ),
+ pytest.param(
+ "zero3",
+ marks=pytest.mark.xfail(
+ Version(transformers.__version__) == Version("5.1.0"),
+ reason="Upstream incompatibility: deepspeed and transformers==5.1.0 (see transformers#43780)",
+ ),
+ ),
+ "fsdp2",
+ ],
+ )
+ def test_dpo(self, config, get_config_path):
+ # fmt: off
+ run_command(
+ [
+ "accelerate", "launch", "--config_file", get_config_path(config), "trl/scripts/dpo.py",
+ "--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",
+ ],
+ os.environ.copy(),
+ )
+ # fmt: on
+
+ @pytest.mark.parametrize(
+ "config",
+ [
+ "ddp",
+ pytest.param(
+ "zero2",
+ marks=pytest.mark.xfail(
+ Version(transformers.__version__) == Version("5.1.0"),
+ reason="Upstream incompatibility: deepspeed and transformers==5.1.0 (see transformers#43780)",
+ ),
+ ),
+ pytest.param(
+ "zero3",
+ marks=pytest.mark.xfail(
+ Version(transformers.__version__) == Version("5.1.0"),
+ reason="Upstream incompatibility: deepspeed and transformers==5.1.0 (see transformers#43780)",
+ ),
+ ),
+ "fsdp2",
+ ],
+ )
+ def test_sft_dataset_streaming(self, config, get_config_path):
+ # fmt: off
+ run_command(
+ [
+ "accelerate", "launch", "--config_file", get_config_path(config), "trl/scripts/sft.py",
+ "--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",
+ "--dataset_streaming",
+ "--max_steps", "3",
+ ],
+ os.environ.copy(),
+ )
+ # fmt: on
+
+ @pytest.mark.parametrize(
+ "config",
+ [
+ "ddp",
+ pytest.param(
+ "zero2",
+ marks=pytest.mark.xfail(
+ condition=Version("2.10") <= Version(torch.__version__)
+ and Version(transformers.__version__) < Version("5.1.0"),
+ reason="ZeRO 2 + PEFT was failing before transformers 5.1.0 on torch 2.10; see #4884",
+ ),
+ ),
+ pytest.param(
+ "zero3",
+ marks=pytest.mark.xfail(
+ condition=Version("2.10") <= Version(torch.__version__)
+ and Version(transformers.__version__) < Version("5.1.0"),
+ reason="ZeRO 3 + PEFT was failing before transformers 5.1.0 on torch 2.10; see #4884",
+ ),
+ ),
+ "fsdp2",
+ ],
+ )
+ def test_sft_peft(self, config, get_config_path):
+ # fmt: off
+ run_command(
+ [
+ "accelerate", "launch", "--config_file", get_config_path(config), "trl/scripts/sft.py",
+ "--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",
+ "--use_peft",
+ ],
+ os.environ.copy(),
+ )
+ # fmt: on
+
+ @pytest.mark.parametrize(
+ "config",
+ [
+ "ddp",
+ pytest.param(
+ "zero2",
+ marks=pytest.mark.xfail(
+ Version(transformers.__version__) == Version("5.1.0"),
+ reason="Upstream incompatibility: deepspeed and transformers==5.1.0 (see transformers#43780)",
+ ),
+ ),
+ pytest.param(
+ "zero3",
+ marks=pytest.mark.xfail(
+ Version(transformers.__version__) == Version("5.1.0"),
+ reason="Upstream incompatibility: deepspeed and transformers==5.1.0 (see transformers#43780)",
+ ),
+ ),
+ "fsdp2",
+ ],
+ )
+ def test_reward(self, config, get_config_path):
+ # fmt: off
+ run_command(
+ [
+ "accelerate", "launch", "--config_file", get_config_path(config), "trl/scripts/reward.py",
+ "--output_dir", self.tmp_dir,
+ "--model_name_or_path", "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+ "--dataset_name", "trl-internal-testing/zen",
+ "--dataset_config", "conversational_implicit_prompt_preference",
+ ],
+ os.environ.copy(),
+ )
+ # fmt: on
+
+ @pytest.mark.parametrize(
+ "config",
+ [
+ "ddp",
+ pytest.param(
+ "zero2",
+ marks=pytest.mark.xfail(
+ Version(transformers.__version__) == Version("5.1.0"),
+ reason="Upstream incompatibility: deepspeed and transformers==5.1.0 (see transformers#43780)",
+ ),
+ ),
+ pytest.param(
+ "zero3",
+ marks=pytest.mark.xfail(
+ Version("5.0.0") <= Version(transformers.__version__) < Version("5.5.4"),
+ reason="ZeRO-3 fails with transformers >= 5.0.0 and < 5.5.4 (fixed in transformers#45414), see #4899",
+ strict=True,
+ ),
+ ),
+ pytest.param(
+ "fsdp2",
+ marks=pytest.mark.skipif(
+ Version("5.4.0") <= Version(transformers.__version__) < Version("5.6.0"),
+ reason="Upstream issue: NaN weights on non-rank-0 FSDP processes (see #5386 and transformers#45050)",
+ ),
+ ),
+ ],
+ )
+ def test_rloo(self, config, get_config_path):
+ # fmt: off
+ run_command(
+ [
+ "accelerate", "launch", "--config_file", get_config_path(config), "trl/scripts/rloo.py",
+ "--output_dir", self.tmp_dir,
+ "--model_name_or_path", "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+ "--dataset_name", "trl-internal-testing/zen",
+ "--dataset_config", "conversational_prompt_only",
+ "--reward_model_name_or_path", "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+ ],
+ os.environ.copy(),
+ )
+ # fmt: on
+
+ @pytest.mark.parametrize(
+ "config",
+ [
+ "ddp",
+ pytest.param(
+ "zero2",
+ marks=pytest.mark.xfail(
+ Version(transformers.__version__) == Version("5.1.0"),
+ reason="Upstream incompatibility: deepspeed and transformers==5.1.0 (see transformers#43780)",
+ ),
+ ),
+ pytest.param(
+ "zero3",
+ marks=pytest.mark.xfail(
+ Version("5.0.0") <= Version(transformers.__version__) < Version("5.5.4"),
+ reason="ZeRO-3 fails with transformers >= 5.0.0 and < 5.5.4 (fixed in transformers#45414), see #4899",
+ strict=True,
+ ),
+ ),
+ "fsdp2",
+ ],
+ )
+ def test_grpo(self, config, get_config_path):
+ # fmt: off
+ run_command(
+ [
+ "accelerate", "launch", "--config_file", get_config_path(config), "trl/scripts/grpo.py",
+ "--output_dir", self.tmp_dir,
+ "--model_name_or_path", "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+ "--dataset_name", "trl-internal-testing/zen",
+ "--dataset_config", "conversational_prompt_only",
+ "--reward_model_name_or_path", "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+ ],
+ os.environ.copy(),
+ )
+ # fmt: on
+
+ @require_liger_kernel
+ @pytest.mark.parametrize(
+ "config",
+ [
+ "ddp",
+ pytest.param(
+ "zero2",
+ marks=pytest.mark.xfail(
+ Version(transformers.__version__) == Version("5.1.0"),
+ reason="Upstream incompatibility: deepspeed and transformers==5.1.0 (see transformers#43780)",
+ ),
+ ),
+ pytest.param(
+ "zero3",
+ marks=pytest.mark.xfail(
+ Version("5.0.0") <= Version(transformers.__version__) < Version("5.5.4"),
+ reason="ZeRO-3 fails with transformers >= 5.0.0 and < 5.5.4 (fixed in transformers#45414), see #4899",
+ strict=True,
+ ),
+ ),
+ "fsdp2",
+ ],
+ )
+ def test_grpo_liger(self, config, get_config_path):
+ # fmt: off
+ run_command(
+ [
+ "accelerate", "launch", "--config_file", get_config_path(config), "trl/scripts/grpo.py",
+ "--output_dir", self.tmp_dir,
+ "--model_name_or_path", "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+ "--dataset_name", "trl-internal-testing/zen",
+ "--dataset_config", "conversational_prompt_only",
+ "--reward_model_name_or_path", "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+ "--use_liger_kernel",
+ ],
+ os.environ.copy(),
+ )
+ # fmt: on
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/__init__.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d2777dd0eb21a0ea67dce8775337a27ea8499da2
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/__init__.py
@@ -0,0 +1,13 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/_openreward_echo_env.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/_openreward_echo_env.py
new file mode 100644
index 0000000000000000000000000000000000000000..967b2287d30fc71f48e01f37f56336b7df2e1d47
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/_openreward_echo_env.py
@@ -0,0 +1,126 @@
+# 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.
+
+"""Spawn target for `tests/experimental/test_openreward.py`.
+
+Implements a minimal, deterministic Open Reward Standard environment so the adapter can be exercised end-to-end without
+hitting the network. The same definition is also published as a Hugging Face Space at
+`trl-internal-testing/openreward-echo-env` for the optional integration test.
+
+The model is given a target string and must call `echo(text=...)` with exactly that string. Reward is `1.0` on match,
+`0.0` otherwise; the episode finishes on a correct echo.
+"""
+
+from openreward.environments import (
+ Environment,
+ JSONObject,
+ ListToolsOutput,
+ Server,
+ TextBlock,
+ ToolOutput,
+ ToolSpec,
+ tool,
+)
+from pydantic import BaseModel
+
+
+TRAIN_TASKS: list[JSONObject] = [
+ {"id": "echo-0", "target": "hello"},
+ {"id": "echo-1", "target": "world"},
+ {"id": "echo-2", "target": "trl"},
+ {"id": "echo-3", "target": "openreward"},
+]
+
+
+class EchoTaskSpec(BaseModel):
+ id: str
+ target: str
+
+
+class EchoParams(BaseModel):
+ text: str
+
+
+class HintParams(BaseModel):
+ """Parameters for the optional hint tool (session-only via ``list_task_tools``)."""
+
+ pass
+
+
+class EchoEnvironment(Environment):
+ """Tiny deterministic ORS env: echo the target string to win."""
+
+ def __init__(self, task_spec: JSONObject = {}, secrets: dict[str, str] = {}): # noqa: B006 - signature dictated by openreward.environments.Environment
+ super().__init__(task_spec)
+ self.config = EchoTaskSpec.model_validate(task_spec)
+
+ @classmethod
+ def list_splits(cls) -> list[str]:
+ return ["train"]
+
+ @classmethod
+ def list_tasks(cls, split: str) -> list[JSONObject]:
+ if split != "train":
+ raise ValueError(f"unknown split: {split}")
+ return TRAIN_TASKS
+
+ def get_prompt(self) -> list[TextBlock]:
+ return [
+ TextBlock(
+ type="text",
+ text=f"Call the `echo` tool with text='{self.config.target}' to win.",
+ )
+ ]
+
+ def list_task_tools(self) -> ListToolsOutput:
+ """Expose ``hint`` only on GET /task_tools (merged into ``session.list_tools()``)."""
+ return ListToolsOutput(
+ tools=[
+ ToolSpec(
+ name="hint",
+ description="Cheap hint for tests exercising ORS /task_tools discovery.",
+ input_schema=HintParams.model_json_schema(),
+ )
+ ]
+ )
+
+ @tool
+ async def echo(self, params: EchoParams) -> ToolOutput:
+ """Submit a string. Reward 1.0 + finished if it matches the target.
+
+ Args:
+ text: The string to echo back.
+ """
+ correct = params.text == self.config.target
+ return ToolOutput(
+ blocks=[
+ TextBlock(
+ type="text",
+ text="match" if correct else f"no match (got {params.text!r})",
+ )
+ ],
+ reward=1.0 if correct else 0.0,
+ finished=correct,
+ )
+
+ @tool(shared=False)
+ async def hint(self, params: HintParams) -> ToolOutput:
+ """Session-advertised helper (spec comes from ``list_task_tools``)."""
+ return ToolOutput(blocks=[TextBlock(text="try echo(text=...)")])
+
+
+if __name__ == "__main__":
+ import os
+
+ Server([EchoEnvironment]).run(host="127.0.0.1", port=int(os.environ["PORT"]))
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_a2po_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_a2po_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..b99734d6953f55a47ecbb5022e5c384b08149c43
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_a2po_trainer.py
@@ -0,0 +1,165 @@
+# 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 trl.experimental.a2po import A2POConfig, A2POTrainer
+
+from ..testing_utils import TrlTestCase
+
+
+def completion_parity_reward(completions, **kwargs):
+ """Completion-dependent binary reward, so samples within a prompt vary (nonzero advantages)."""
+ return [float(len(completion) % 2 == 0) for completion in completions]
+
+
+class TestA2POTrainer(TrlTestCase):
+ def test_trust_remote_code(self):
+ dataset = Dataset.from_dict({"prompt": ["The capital of France is", "Two plus two equals"]})
+ model_id = "trl-internal-testing/tiny-RemoteForCausalLM"
+
+ with pytest.raises(ValueError, match="custom code"):
+ A2POTrainer(
+ model=model_id,
+ reward_funcs=completion_parity_reward,
+ args=A2POConfig(output_dir=self.tmp_dir, report_to="none"),
+ train_dataset=dataset,
+ )
+
+ trainer = A2POTrainer(
+ model=model_id,
+ reward_funcs=completion_parity_reward,
+ args=A2POConfig(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):
+ # Main two-stage smoke test: Stage 1 estimates V*, Stage 2 regresses on a single on-policy generation.
+ dataset = Dataset.from_dict(
+ {"prompt": ["The capital of France is", "Two plus two equals", "Water is made of", "The sky is"]}
+ )
+ training_args = A2POConfig(
+ 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, # reduce the batch size to reduce memory usage
+ max_completion_length=8, # reduce the completion length to reduce memory usage
+ num_value_samples=2, # reduce Stage 1 sampling to reduce memory usage
+ filter_all_incorrect=False, # keep all training prompts (the dummy reward may score a prompt all-zero)
+ report_to="none",
+ )
+ trainer = A2POTrainer(
+ model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+ reward_funcs=completion_parity_reward,
+ 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
+ assert trainer._optimal_values is not None and len(trainer._optimal_values) == len(dataset)
+
+ 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_kwargs_are_forwarded(self):
+ # Regression test: extra dataset columns must reach the reward function (e.g. a verifier needs `solution`).
+ received_subjects = []
+
+ def reward_using_extra_column(prompts, completions, subject, **kwargs):
+ received_subjects.extend(subject)
+ return [1.0] * len(prompts)
+
+ dataset = Dataset.from_dict({"prompt": ["q1", "q2", "q3", "q4"], "subject": ["math", "geo", "chem", "phys"]})
+ training_args = A2POConfig(
+ 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, # reduce the batch size to reduce memory usage
+ max_completion_length=8, # reduce the completion length to reduce memory usage
+ num_value_samples=2, # reduce Stage 1 sampling to reduce memory usage
+ filter_all_incorrect=False, # keep all training prompts (the dummy reward may score a prompt all-zero)
+ report_to="none",
+ )
+ trainer = A2POTrainer(
+ model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+ reward_funcs=reward_using_extra_column,
+ args=training_args,
+ train_dataset=dataset,
+ )
+ trainer.train()
+
+ # Stage 1 repeats each prompt's column value `num_value_samples` times; the column must have been forwarded.
+ assert received_subjects, "reward function never received the `subject` column"
+ assert set(received_subjects) <= {"math", "geo", "chem", "phys"}
+
+ def test_filter_all_incorrect_drops_prompts(self):
+ # Regression test: prompts whose reference samples all score zero must be dropped, not crash Stage 2.
+ def reward_from_target(prompts, completions, target, **kwargs):
+ return [float(t) for t in target]
+
+ dataset = Dataset.from_dict({"prompt": ["solvable a", "unsolvable", "solvable b"], "target": [1, 0, 1]})
+ training_args = A2POConfig(
+ 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, # reduce the batch size to reduce memory usage
+ max_completion_length=8, # reduce the completion length to reduce memory usage
+ num_value_samples=2, # reduce Stage 1 sampling to reduce memory usage
+ filter_all_incorrect=True,
+ report_to="none",
+ )
+ trainer = A2POTrainer(
+ model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+ reward_funcs=reward_from_target,
+ args=training_args,
+ train_dataset=dataset,
+ )
+
+ # Should run without raising a KeyError for the dropped prompt.
+ trainer.train()
+
+ assert len(trainer.train_dataset) == 2
+ assert "unsolvable" not in list(trainer.train_dataset["prompt"])
+
+ def test_evaluate(self):
+ # Regression test: eval prompts (never seen in training) must also get a cached V*, and evaluating
+ # without a preceding train() must not raise.
+ train_dataset = Dataset.from_dict({"prompt": ["alpha", "beta"]})
+ eval_dataset = Dataset.from_dict({"prompt": ["gamma", "delta"]})
+ training_args = A2POConfig(
+ 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, # reduce the batch size to reduce memory usage
+ max_completion_length=8, # reduce the completion length to reduce memory usage
+ num_value_samples=2, # reduce Stage 1 sampling to reduce memory usage
+ filter_all_incorrect=False, # keep all training prompts (the dummy reward may score a prompt all-zero)
+ report_to="none",
+ )
+ trainer = A2POTrainer(
+ model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+ reward_funcs=completion_parity_reward,
+ args=training_args,
+ train_dataset=train_dataset,
+ eval_dataset=eval_dataset,
+ )
+
+ metrics = trainer.evaluate()
+
+ assert "eval_loss" in metrics
+ assert "gamma" in trainer._optimal_values and "delta" in trainer._optimal_values
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_async_grpo_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_async_grpo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ee3634e20040cdefaff28c8056475353d3fc4a3
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_async_grpo_trainer.py
@@ -0,0 +1,136 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import itertools
+import queue
+
+import numpy as np
+import pytest
+import torch
+from datasets import load_dataset
+from transformers import AutoTokenizer
+from transformers.testing_utils import torch_device
+
+from trl.experimental.async_grpo import AsyncGRPOConfig, AsyncGRPOTrainer
+from trl.experimental.async_grpo.async_rollout_worker import RolloutSample
+
+from ..testing_utils import TrlTestCase, is_ampere_or_newer
+
+
+def dummy_reward_func(completions, **kwargs):
+ return [float(hash(c[0]["content"]) % 100) / 100.0 for c in completions]
+
+
+class _StubRolloutWorker:
+ """Minimal rollout worker stub for testing the trainer in isolation."""
+
+ def __init__(self, tokenizer, dataset, num_generations: int = 8, samples_per_weight_sync: int = 10):
+ self.rollout_buffer = queue.Queue()
+ self._samples_per_weight_sync = samples_per_weight_sync
+ self._model_version = 0
+ self._sample_iter = self._make_sample_iter(tokenizer, dataset, num_generations)
+
+ def _make_sample_iter(self, tokenizer, dataset, num_generations):
+ for row in itertools.cycle(dataset):
+ completions = [
+ [{"role": "assistant", "content": f"{row['completion'][0]['content']} {idx}"}]
+ for idx in range(num_generations)
+ ]
+ prompt_completions = [row["prompt"] + completion for completion in completions]
+ prompt_ids = tokenizer.apply_chat_template(
+ row["prompt"], tokenize=True, add_generation_prompt=True, return_dict=False
+ )
+ prompt_completion_ids = tokenizer.apply_chat_template(
+ prompt_completions, tokenize=True, add_generation_prompt=False, return_dict=False
+ )
+ rewards = np.array(dummy_reward_func(completions))
+ advantages = (rewards - rewards.mean()) / rewards.std()
+ for idx in range(num_generations):
+ completion_ids = prompt_completion_ids[idx][len(prompt_ids) :]
+ yield RolloutSample(
+ prompt=row["prompt"],
+ completion=completions[idx],
+ input_ids=prompt_ids + completion_ids,
+ completion_mask=[0] * len(prompt_ids) + [1] * len(completion_ids),
+ old_log_probs=[0.0] * len(prompt_ids) + [-0.5] * len(completion_ids),
+ advantage=float(advantages[idx]),
+ model_version=self._model_version,
+ metrics={"reward": float(rewards[idx]), "reward_std": float(rewards.std())},
+ )
+
+ def _fill_queue(self):
+ for _ in range(self._samples_per_weight_sync):
+ self.rollout_buffer.put(next(self._sample_iter))
+
+ def start(self):
+ self._fill_queue()
+
+ def update_model_version(self, version):
+ self._model_version = version
+ self._fill_queue()
+
+ def stop(self):
+ pass
+
+ def check_health(self, stale_after_s):
+ pass
+
+
+@pytest.mark.skipif(
+ not is_ampere_or_newer() and torch_device != "xpu",
+ reason="Flash Attention 2 requires Ampere or newer GPU, or XPU",
+)
+class TestAsyncGRPOTrainer(TrlTestCase):
+ def test_init_minimal(self):
+ # Test that AsyncGRPOTrainer can be instantiated with only model, reward_model and train_dataset
+ model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+ dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_completion", split="train")
+ AsyncGRPOTrainer(
+ model=model_id,
+ reward_funcs=dummy_reward_func,
+ train_dataset=dataset,
+ rollout_worker=_StubRolloutWorker(AutoTokenizer.from_pretrained(model_id), dataset, num_generations=3),
+ )
+
+ def test_train(self):
+ model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+ dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_completion", split="train")
+
+ training_args = AsyncGRPOConfig(
+ 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
+ vllm_server_timeout=5.0, # short timeout so test fails fast if queue runs dry
+ report_to="none",
+ )
+ trainer = AsyncGRPOTrainer(
+ model=model_id,
+ reward_funcs=dummy_reward_func, # unused: the stub pre-computes rewards, but the trainer requires this argument
+ args=training_args,
+ train_dataset=dataset,
+ rollout_worker=_StubRolloutWorker(AutoTokenizer.from_pretrained(model_id), dataset, num_generations=3),
+ )
+
+ 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."
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_bco_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_bco_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..13f04f148f99ec672b3fe92797bb10add87504ab
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_bco_trainer.py
@@ -0,0 +1,463 @@
+# 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 functools import partial
+
+import pytest
+import torch
+from accelerate import Accelerator
+from datasets import load_dataset
+from transformers import AutoModel, AutoModelForCausalLM, AutoTokenizer
+from transformers.utils import is_peft_available
+
+from trl.experimental.bco import BCOConfig, BCOTrainer
+from trl.experimental.bco.bco_trainer import _process_tokens, _tokenize
+
+from ..testing_utils import TrlTestCase, require_no_wandb, require_peft, require_sklearn
+
+
+if is_peft_available():
+ from peft import LoraConfig
+
+
+@pytest.mark.low_priority
+class TestBCOTrainer(TrlTestCase):
+ @require_sklearn
+ 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"
+ tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
+
+ with pytest.raises(ValueError, match="custom code"):
+ BCOTrainer(
+ model=model_id,
+ args=BCOConfig(output_dir=self.tmp_dir, report_to="none"),
+ processing_class=tokenizer,
+ train_dataset=dataset,
+ )
+
+ trainer = BCOTrainer(
+ model=model_id,
+ args=BCOConfig(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(
+ "config_name",
+ [
+ "standard_preference",
+ "standard_implicit_prompt_preference",
+ "standard_unpaired_preference",
+ "conversational_preference",
+ "conversational_implicit_prompt_preference",
+ "conversational_unpaired_preference",
+ ],
+ )
+ @require_sklearn
+ def test_train(self, config_name):
+ model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+ model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+ ref_model = AutoModelForCausalLM.from_pretrained(model_id)
+ tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+ dataset = load_dataset("trl-internal-testing/zen", config_name, split="train")
+
+ training_args = BCOConfig(
+ output_dir=self.tmp_dir,
+ remove_unused_columns=False, # warning raised if not set to False
+ learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates
+ report_to="none",
+ )
+
+ trainer = BCOTrainer(
+ model=model,
+ ref_model=ref_model,
+ args=training_args,
+ processing_class=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.cpu(), new_param.cpu())
+
+ @require_sklearn
+ def test_train_with_precompute(self):
+ model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+ model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+ ref_model = AutoModelForCausalLM.from_pretrained(model_id)
+ tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+ dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference", split="train")
+
+ training_args = BCOConfig(
+ output_dir=self.tmp_dir,
+ remove_unused_columns=False, # warning raised if not set to False
+ learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates
+ precompute_ref_log_probs=True,
+ report_to="none",
+ )
+
+ trainer = BCOTrainer(
+ model=model,
+ ref_model=ref_model,
+ args=training_args,
+ processing_class=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.cpu(), new_param.cpu())
+
+ @require_sklearn
+ def test_train_eval(self):
+ model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+ model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+ ref_model = AutoModelForCausalLM.from_pretrained(model_id)
+ tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+ dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference")
+
+ training_args = BCOConfig(
+ output_dir=self.tmp_dir,
+ remove_unused_columns=False, # warning raised if not set to False
+ eval_strategy="steps",
+ eval_steps=3,
+ report_to="none",
+ )
+
+ trainer = BCOTrainer(
+ model=model,
+ ref_model=ref_model,
+ args=training_args,
+ processing_class=tokenizer,
+ train_dataset=dataset["train"],
+ eval_dataset=dataset["test"],
+ )
+
+ trainer.train()
+
+ @require_sklearn
+ def test_init_with_ref_model_is_model(self):
+ model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+ model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+ tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+ dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference", split="train")
+
+ training_args = BCOConfig(
+ output_dir=self.tmp_dir,
+ remove_unused_columns=False, # warning raised if not set to False
+ report_to="none",
+ )
+
+ with pytest.raises(ValueError):
+ BCOTrainer(
+ model=model,
+ ref_model=model, # ref_model can't be the same as model
+ args=training_args,
+ processing_class=tokenizer,
+ train_dataset=dataset,
+ )
+
+ @require_sklearn
+ def test_tokenize_and_process_tokens(self):
+ model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+ model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+ ref_model = AutoModelForCausalLM.from_pretrained(model_id)
+ tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+ dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference", split="train")
+
+ training_args = BCOConfig(
+ output_dir=self.tmp_dir,
+ remove_unused_columns=False, # warning raised if not set to False
+ report_to="none",
+ )
+
+ trainer = BCOTrainer(
+ model=model,
+ ref_model=ref_model,
+ args=training_args,
+ processing_class=tokenizer,
+ train_dataset=dataset,
+ )
+
+ tokenized_dataset = dataset.map(
+ _tokenize,
+ fn_kwargs={"tokenizer": trainer.processing_class},
+ batched=True,
+ batch_size=2,
+ )
+ assert tokenized_dataset["prompt"][:] == dataset["prompt"][:]
+ assert tokenized_dataset["completion"][:] == dataset["completion"][:]
+ assert tokenized_dataset["label"][:] == dataset["label"][:]
+ assert tokenized_dataset["prompt_input_ids"][0] == [46518, 374, 2664, 1091]
+ assert tokenized_dataset["prompt_attention_mask"][0] == [1, 1, 1, 1]
+ assert tokenized_dataset["answer_input_ids"][0] == [27261, 13]
+ assert tokenized_dataset["answer_attention_mask"][0] == [1, 1]
+
+ fn_kwargs = {
+ "prefix": "",
+ "is_encoder_decoder": trainer.is_encoder_decoder,
+ "tokenizer": trainer.processing_class,
+ "max_length": trainer.max_length,
+ }
+ processed_dataset = tokenized_dataset.map(_process_tokens, fn_kwargs=fn_kwargs)
+ assert processed_dataset["prompt"][:] == dataset["prompt"][:]
+ assert processed_dataset["completion"][:] == dataset["completion"][:]
+ assert processed_dataset["label"][:] == dataset["label"][:]
+ assert processed_dataset["prompt_input_ids"][0] == [46518, 374, 2664, 1091]
+ assert processed_dataset["prompt_attention_mask"][0] == [1, 1, 1, 1]
+ assert processed_dataset["completion_input_ids"][0] == [46518, 374, 2664, 1091, 27261, 13, 151645]
+ assert processed_dataset["completion_attention_mask"][0] == [1, 1, 1, 1, 1, 1, 1]
+ assert processed_dataset["completion_labels"][0] == [-100, -100, -100, -100, 27261, 13, 151645]
+
+ @require_sklearn
+ def test_train_without_providing_ref_model(self):
+ model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+ model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+ tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+ dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference", split="train")
+
+ training_args = BCOConfig(
+ output_dir=self.tmp_dir,
+ remove_unused_columns=False, # warning raised if not set to False
+ learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates
+ report_to="none",
+ )
+
+ trainer = BCOTrainer(
+ model=model,
+ args=training_args,
+ processing_class=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.cpu(), new_param.cpu())
+
+ @require_sklearn
+ def test_train_udm(self):
+ model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+ model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+ tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+ # Get embedding model
+ embedding_model_id = "trl-internal-testing/tiny-BartModel"
+ embedding_model = AutoModel.from_pretrained(embedding_model_id)
+ embedding_tokenizer = AutoTokenizer.from_pretrained(embedding_model_id)
+
+ def embed_prompt(input_ids, attention_mask, model):
+ outputs = model(input_ids=input_ids, attention_mask=attention_mask)
+
+ return outputs.last_hidden_state.mean(dim=1)
+
+ embedding_model = Accelerator().prepare_model(embedding_model)
+ embedding_func = partial(embed_prompt, model=embedding_model)
+
+ dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference", split="train")
+
+ training_args = BCOConfig(
+ output_dir=self.tmp_dir,
+ remove_unused_columns=False, # warning raised if not set to False
+ learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates
+ report_to="none",
+ )
+
+ trainer = BCOTrainer(
+ model=model,
+ args=training_args,
+ processing_class=tokenizer,
+ train_dataset=dataset,
+ embedding_func=embedding_func,
+ embedding_tokenizer=embedding_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)
+ if param.sum() != 0: # ignore 0 biases
+ assert not torch.equal(param.cpu(), new_param.cpu())
+
+ @require_sklearn
+ @require_peft
+ def test_train_without_providing_ref_model_with_lora(self):
+ model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+ model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+ lora_config = LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05, task_type="CAUSAL_LM")
+ tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+ dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference", split="train")
+
+ training_args = BCOConfig(
+ output_dir=self.tmp_dir,
+ remove_unused_columns=False, # warning raised if not set to False
+ learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates
+ report_to="none",
+ )
+
+ trainer = BCOTrainer(
+ model=model,
+ args=training_args,
+ processing_class=tokenizer,
+ 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 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.cpu(), new_param.cpu())
+
+ @require_sklearn
+ @require_no_wandb
+ def test_generate_during_eval_no_wandb(self):
+ model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+ model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+ tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+ dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference")
+
+ training_args = BCOConfig(
+ output_dir=self.tmp_dir,
+ remove_unused_columns=False, # warning raised if not set to False
+ eval_strategy="steps",
+ eval_steps=3,
+ generate_during_eval=True,
+ report_to="none",
+ )
+
+ with pytest.raises(
+ ValueError,
+ match="`generate_during_eval=True` requires Weights and Biases or Comet to be installed."
+ " Please install `wandb` or `comet-ml` to resolve.",
+ ):
+ BCOTrainer(
+ model=model,
+ args=training_args,
+ processing_class=tokenizer,
+ train_dataset=dataset["train"],
+ eval_dataset=dataset["test"],
+ )
+
+ @require_sklearn
+ @require_peft
+ def test_lora_train_and_save(self):
+ model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+ model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+ lora_config = LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05, task_type="CAUSAL_LM")
+ tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+ dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference", split="train")
+
+ training_args = BCOConfig(
+ output_dir=self.tmp_dir,
+ remove_unused_columns=False, # warning raised if not set to False
+ report_to="none",
+ )
+
+ trainer = BCOTrainer(
+ model=model,
+ args=training_args,
+ processing_class=tokenizer,
+ train_dataset=dataset,
+ peft_config=lora_config,
+ )
+
+ # train the model
+ trainer.train()
+
+ # save peft adapter
+ trainer.save_model()
+
+ # assert that the model is loaded without giving OSError
+ AutoModelForCausalLM.from_pretrained(self.tmp_dir)
+
+ @require_sklearn
+ def test_compute_metrics(self):
+ model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+ model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32")
+ ref_model = AutoModelForCausalLM.from_pretrained(model_id)
+ tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+ dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference")
+
+ def dummy_compute_metrics(*args, **kwargs):
+ return {"test": 0.0}
+
+ training_args = BCOConfig(
+ output_dir=self.tmp_dir,
+ remove_unused_columns=False, # warning raised if not set to False
+ eval_strategy="steps",
+ eval_steps=3,
+ report_to="none",
+ )
+
+ trainer = BCOTrainer(
+ 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
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_cpo_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_cpo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..af4438dc569bf81d0c620d4cb5abe16e71ba6a2c
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_cpo_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
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoModelForSeq2SeqLM, AutoTokenizer
+
+from trl.experimental.cpo import CPOConfig, CPOTrainer
+
+from ..testing_utils import TrlTestCase, require_peft
+
+
+class TestCPOTrainer(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"):
+ CPOTrainer(
+ model=model_id,
+ args=CPOConfig(output_dir=self.tmp_dir, report_to="none"),
+ processing_class=tokenizer,
+ train_dataset=dataset,
+ )
+
+ trainer = CPOTrainer(
+ model=model_id,
+ args=CPOConfig(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, loss_type, config_name",
+ [
+ ("qwen", "sigmoid", "standard_preference"),
+ ("t5", "hinge", "standard_implicit_prompt_preference"),
+ ("qwen", "ipo", "conversational_preference"),
+ ("qwen", "simpo", "standard_preference"),
+ ("t5", "simpo", "standard_implicit_prompt_preference"),
+ ("qwen", "hinge", "conversational_preference"),
+ ],
+ )
+ def test_cpo_trainer(self, name, loss_type, config_name):
+ training_args = CPOConfig(
+ 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,
+ loss_type=loss_type,
+ cpo_alpha=1.0,
+ 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 = CPOTrainer(
+ 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_cpo_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 = CPOConfig(
+ 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,
+ cpo_alpha=1.0,
+ report_to="none",
+ )
+
+ dataset = load_dataset("trl-internal-testing/zen", config_name)
+
+ trainer = CPOTrainer(
+ 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):
+ dataset = load_dataset("trl-internal-testing/zen", "standard_preference")
+
+ def dummy_compute_metrics(*args, **kwargs):
+ return {"test": 0.0}
+
+ training_args = CPOConfig(
+ output_dir=self.tmp_dir,
+ per_device_train_batch_size=2,
+ remove_unused_columns=False,
+ do_eval=True,
+ eval_strategy="steps",
+ eval_steps=1,
+ per_device_eval_batch_size=2,
+ report_to="none",
+ )
+
+ trainer = CPOTrainer(
+ model=self.model,
+ args=training_args,
+ processing_class=self.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
+
+ def test_alphapo_trainer(self):
+ training_args = CPOConfig(
+ 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,
+ loss_type="alphapo",
+ alpha=0.5,
+ simpo_gamma=0.5,
+ report_to="none",
+ )
+
+ dataset = load_dataset("trl-internal-testing/zen", "standard_preference")
+
+ trainer = CPOTrainer(
+ model=self.model,
+ 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
+
+ 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)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_distillation_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_distillation_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..a42e2b9fedb8e1f5009d35b0edba9582a9e8aa4d
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_distillation_trainer.py
@@ -0,0 +1,653 @@
+# 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 math
+import os
+from unittest.mock import MagicMock
+
+import pytest
+import torch
+import torch.nn.functional as F
+from datasets import Dataset, load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from trl.experimental.distillation import DistillationConfig, DistillationTrainer
+from trl.experimental.distillation.distillation_trainer import (
+ _add_tail_bucket,
+ _jsd_divergence,
+ _RepeatBatchDataLoader,
+ build_teacher_request_inputs,
+)
+
+from ..testing_utils import TrlTestCase, require_liger_kernel, require_torch_accelerator
+
+
+def _make_distillation_config_kwargs(tmp_path):
+ return {"output_dir": str(tmp_path), "report_to": "none", "use_cpu": True, "bf16": False}
+
+
+def _build_server_result(teacher_logits, inputs, temperature=1.0):
+ """Simulate a vLLM server response with variable-length per-sample completions."""
+ _, _, completion_lengths = build_teacher_request_inputs(
+ inputs["input_ids"],
+ inputs["attention_mask"],
+ prompt_attention_mask=inputs.get("prompt_attention_mask"),
+ labels=inputs.get("labels"),
+ )
+
+ label_mask = inputs["labels"] != -100
+ actual_logprobs = []
+ logprobs = []
+ logprob_token_ids = []
+
+ for i, comp_len in enumerate(completion_lengths):
+ if comp_len == 0:
+ actual_logprobs.append([])
+ logprobs.append([])
+ logprob_token_ids.append([])
+ continue
+
+ comp_start = int(torch.nonzero(label_mask[i], as_tuple=False)[0].item())
+ sample_logits = teacher_logits[i, comp_start - 1 : comp_start - 1 + comp_len, :]
+ sample_log_probs = F.log_softmax(sample_logits / temperature, dim=-1)
+ comp_tokens = inputs["input_ids"][i, comp_start : comp_start + comp_len]
+
+ top1_ids = sample_logits.argmax(dim=-1, keepdim=True)
+ top1_lps = sample_log_probs.gather(dim=-1, index=top1_ids)
+ actual_lps = sample_log_probs.gather(dim=-1, index=comp_tokens.unsqueeze(-1))
+
+ actual_logprobs.append(actual_lps.tolist())
+ logprobs.append(top1_lps.tolist())
+ logprob_token_ids.append(top1_ids.tolist())
+
+ return {
+ "actual_logprobs": actual_logprobs,
+ "logprobs": logprobs,
+ "logprob_token_ids": logprob_token_ids,
+ }
+
+
+class RecordingTeacherClient:
+ def __init__(self):
+ self.calls = []
+ self.result = None
+
+ def get_sequence_logprobs(self, sequences, prompt_lengths, top_logprobs, temperature):
+ self.calls.append(
+ {
+ "sequences": sequences,
+ "prompt_lengths": prompt_lengths,
+ "top_logprobs": top_logprobs,
+ "temperature": temperature,
+ }
+ )
+ return self.result
+
+
+def _ragged_server_response():
+ # Two samples with completion lengths 1 and 3 respectively; matches the wire format
+ # of VLLMClient.get_sequence_logprobs (per-sample shape (comp_len, top_k=1)).
+ return {
+ "logprobs": [[[-2.3]], [[-1.1], [-0.4], [-3.0]]],
+ "logprob_token_ids": [[[90]], [[90], [9217], [100]]],
+ "actual_logprobs": [[[-2.3]], [[-1.1], [-0.4], [-3.0]]],
+ }
+
+
+def _canned_teacher_logprobs(**kwargs):
+ # Fabricate ragged per-sample logprobs matching the requested sequence shapes.
+ sequences = kwargs["sequences"]
+ prompt_lengths = kwargs["prompt_lengths"]
+ top_k = kwargs.get("top_logprobs", 1)
+ logprobs, token_ids, actual = [], [], []
+ for seq, plen in zip(sequences, prompt_lengths, strict=True):
+ comp_len = len(seq) - plen
+ logprobs.append([[-1.0 - 0.05 * i] * top_k for i in range(comp_len)])
+ token_ids.append([[int(seq[plen + i])] * top_k for i in range(comp_len)])
+ actual.append([[-1.0 - 0.05 * i] for i in range(comp_len)])
+ return {"logprobs": logprobs, "logprob_token_ids": token_ids, "actual_logprobs": actual}
+
+
+def _variable_length_dataset():
+ return Dataset.from_list(
+ [
+ {"messages": [{"role": "user", "content": "What's 2+2?"}, {"role": "assistant", "content": "4."}]},
+ {
+ "messages": [
+ {"role": "user", "content": "Name three primary colors."},
+ {
+ "role": "assistant",
+ "content": "Red, green, and blue are the three primary colors commonly used in additive color mixing.",
+ },
+ ]
+ },
+ ]
+ )
+
+
+def test_distillation_config_rejects_liger_with_teacher_server(tmp_path):
+ with pytest.raises(ValueError, match="use_liger_kernel=True is not supported with use_teacher_server=True"):
+ DistillationConfig(
+ **_make_distillation_config_kwargs(tmp_path),
+ use_teacher_server=True,
+ teacher_model_server_url="http://localhost:8000",
+ use_liger_kernel=True,
+ )
+
+
+def test_distillation_config_rejects_invalid_reverse_kl_top_1_mode(tmp_path):
+ with pytest.raises(ValueError, match="reverse_kl_top_1_mode must be one of"):
+ DistillationConfig(**_make_distillation_config_kwargs(tmp_path), reverse_kl_top_1_mode="invalid")
+
+
+def test_distillation_config_rejects_teacher_server_with_reverse_kl_argmax(tmp_path):
+ with pytest.raises(ValueError, match="reverse_kl_top_1_mode='argmax' is not supported"):
+ DistillationConfig(
+ **_make_distillation_config_kwargs(tmp_path),
+ use_teacher_server=True,
+ teacher_model_server_url="http://localhost:8000",
+ reverse_kl_top_1_mode="argmax",
+ )
+
+
+def test_distillation_config_rejects_teacher_server_mixed_loss_without_top_1(tmp_path):
+ with pytest.raises(ValueError, match="loss_top_k must be 1 when using use_teacher_server=True with beta>0"):
+ DistillationConfig(
+ **_make_distillation_config_kwargs(tmp_path),
+ use_teacher_server=True,
+ teacher_model_server_url="http://localhost:8000",
+ beta=0.5,
+ loss_top_k=2,
+ )
+
+
+def test_distillation_config_requires_teacher_server_url(tmp_path):
+ with pytest.raises(ValueError, match="teacher_model_server_url must be set when use_teacher_server=True"):
+ DistillationConfig(
+ **_make_distillation_config_kwargs(tmp_path),
+ use_teacher_server=True,
+ beta=0.5,
+ loss_top_k=1,
+ )
+
+
+@pytest.mark.parametrize(
+ (
+ "input_ids",
+ "attention_mask",
+ "prompt_attention_mask",
+ "labels",
+ "expected_sequences",
+ "expected_prompt_lengths",
+ "expected_completion_lengths",
+ ),
+ [
+ pytest.param(
+ torch.tensor([[0, 0, 10, 11, 12, 20, 21], [30, 31, 32, 33, 34, 40, 41]], dtype=torch.long),
+ torch.tensor([[0, 0, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1]], dtype=torch.long),
+ None,
+ torch.tensor(
+ [[-100, -100, -100, -100, -100, 20, 21], [-100, -100, -100, -100, -100, 40, 41]],
+ dtype=torch.long,
+ ),
+ [[10, 11, 12, 20, 21], [30, 31, 32, 33, 34, 40, 41]],
+ [3, 5],
+ [2, 2],
+ id="variable_prompt_lengths",
+ ),
+ pytest.param(
+ torch.tensor(
+ [[0, 0, 10, 11, 12, 20, 21, 0, 0], [30, 31, 32, 33, 34, 40, 41, 0, 0]],
+ dtype=torch.long,
+ ),
+ torch.tensor(
+ [[0, 0, 1, 1, 1, 1, 1, 0, 0], [1, 1, 1, 1, 1, 1, 1, 0, 0]],
+ dtype=torch.long,
+ ),
+ torch.tensor([[0, 0, 1, 1, 1], [1, 1, 1, 1, 1]], dtype=torch.long),
+ torch.tensor(
+ [
+ [-100, -100, -100, -100, -100, 20, 21, -100, -100],
+ [-100, -100, -100, -100, -100, 40, 41, -100, -100],
+ ],
+ dtype=torch.long,
+ ),
+ [[10, 11, 12, 20, 21], [30, 31, 32, 33, 34, 40, 41]],
+ [3, 5],
+ [2, 2],
+ id="padded_on_policy_completions",
+ ),
+ pytest.param(
+ torch.tensor([[10, 11, 12]], dtype=torch.long),
+ torch.tensor([[1, 1, 1]], dtype=torch.long),
+ None,
+ torch.tensor([[-100, -100, -100]], dtype=torch.long),
+ [[10, 11, 12]],
+ [3],
+ [0],
+ id="empty_completion",
+ ),
+ ],
+)
+def test_build_teacher_request_inputs(
+ input_ids,
+ attention_mask,
+ prompt_attention_mask,
+ labels,
+ expected_sequences,
+ expected_prompt_lengths,
+ expected_completion_lengths,
+):
+ sequences, prompt_lengths, completion_lengths = build_teacher_request_inputs(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ prompt_attention_mask=prompt_attention_mask,
+ labels=labels,
+ )
+
+ assert sequences == expected_sequences
+ assert prompt_lengths == expected_prompt_lengths
+ assert completion_lengths == expected_completion_lengths
+
+
+class TestGetTeacherTokenLogprobsFromServer(TrlTestCase):
+ def test_variable_lengths_use_neg_inf_sentinel_at_padding(self):
+ mock_self = MagicMock()
+ mock_self.teacher_client.get_sequence_logprobs = MagicMock(return_value=_ragged_server_response())
+ mock_self.loss_top_k = 1
+ mock_self.temperature = 1.0
+
+ inputs = {
+ "input_ids": torch.tensor([[10, 11, 90, 0, 0], [10, 11, 90, 9217, 100]]),
+ "attention_mask": torch.tensor([[1, 1, 1, 0, 0], [1, 1, 1, 1, 1]]),
+ "labels": torch.tensor([[-100, -100, 90, -100, -100], [-100, -100, 90, 9217, 100]]),
+ }
+
+ out = DistillationTrainer._get_teacher_token_logprobs_from_server(mock_self, inputs, aligned_prompt_length=2)
+
+ assert out["actual_logprobs"].shape == (2, 3)
+ assert out["topk_logprobs"].shape == (2, 3, 1)
+
+ # Real completion positions preserved.
+ assert out["actual_logprobs"][0, 0].item() == pytest.approx(-2.3, rel=1e-5)
+ assert out["actual_logprobs"][1, 0].item() == pytest.approx(-1.1, rel=1e-5)
+ assert out["actual_logprobs"][1, 2].item() == pytest.approx(-3.0, rel=1e-5)
+
+ # Sample 0 is 1 token long; positions 1 and 2 are padded with the -inf sentinel.
+ assert out["actual_logprobs"][0, 1].item() == float("-inf")
+ assert out["actual_logprobs"][0, 2].item() == float("-inf")
+ assert out["topk_logprobs"][0, 1, 0].item() == float("-inf")
+
+ # Sample 1 is full-length and fully finite.
+ assert torch.isfinite(out["actual_logprobs"][1, :]).all()
+
+
+class TestServerReverseKLPaddingMask(TrlTestCase):
+ def test_mask_keeps_forward_and_backward_finite(self):
+ # Simulates the getter's output: sample 0 has completion length 1 (positions 1-2
+ # padded with -inf), sample 1 is full-length.
+ teacher_topk = torch.tensor(
+ [[[-2.3], [float("-inf")], [float("-inf")]], [[-1.1], [-0.4], [-3.0]]],
+ dtype=torch.float32,
+ )
+ labels = torch.tensor([[90, -100, -100], [90, 9217, 100]])
+
+ # Strategy B: neutralise -inf at labels == -100 before the divergence math.
+ pad_mask = (labels == -100).unsqueeze(-1)
+ zero = torch.zeros((), dtype=teacher_topk.dtype)
+ teacher_topk = torch.where(pad_mask, zero, teacher_topk)
+
+ valid_mask = torch.ones_like(teacher_topk, dtype=torch.bool)
+ teacher_with_tail, support_mask = _add_tail_bucket(teacher_topk, valid_mask)
+ assert torch.isfinite(teacher_with_tail).all()
+
+ raw_student = torch.randn(2, 3, 2, requires_grad=True)
+ student_log_probs = F.log_softmax(raw_student, dim=-1)
+ loss = _jsd_divergence(student_log_probs, teacher_with_tail, beta=1.0, support_mask=support_mask)
+ assert torch.isfinite(loss).all()
+
+ loss.sum().backward()
+ assert torch.isfinite(raw_student.grad).all()
+
+
+class TestGeneralizedJSDLoss(TrlTestCase):
+ def setup_method(self):
+ self.batch_size = 2
+ self.seq_length = 3
+ self.vocab_size = 5
+ self.student_logits = torch.randn(self.batch_size, self.seq_length, self.vocab_size)
+ self.teacher_logits = torch.randn(self.batch_size, self.seq_length, self.vocab_size)
+
+ def test_uniform_distribution(self):
+ logits = torch.ones(1, 1, self.vocab_size)
+ loss = DistillationTrainer.generalized_jsd_loss(logits, logits)
+ assert round(abs(loss.item() - 0), 5) == 0
+
+ def test_generalized_jsd_loss_edge_cases(self):
+ # Setup
+ student_logits = torch.log(torch.tensor([[0.1, 0.9]])).unsqueeze(0)
+ teacher_logits = torch.log(torch.tensor([[0.9, 0.1]])).unsqueeze(0)
+
+ # Case 1: beta = 1 (should be equivalent to KL(student || teacher))
+ loss_beta_1 = DistillationTrainer.generalized_jsd_loss(student_logits, teacher_logits, beta=1)
+ expected_loss_beta_1 = F.kl_div(
+ F.log_softmax(teacher_logits, dim=-1), F.softmax(student_logits, dim=-1), reduction="batchmean"
+ )
+ assert round(abs(loss_beta_1.item() - expected_loss_beta_1.item()), 5) == 0
+
+ # Case 2: beta = 0 (should be equivalent to KL(teacher || student))
+ loss_beta_0 = DistillationTrainer.generalized_jsd_loss(student_logits, teacher_logits, beta=0)
+ expected_loss_beta_0 = F.kl_div(
+ F.log_softmax(student_logits, dim=-1), F.softmax(teacher_logits, dim=-1), reduction="batchmean"
+ )
+ assert round(abs(loss_beta_0.item() - expected_loss_beta_0.item()), 5) == 0
+
+ def test_output_shape(self):
+ loss = DistillationTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits)
+ assert torch.is_tensor(loss)
+ assert loss.shape == torch.Size([])
+
+ def test_beta_values(self):
+ loss_beta_0 = DistillationTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits, beta=0)
+ loss_beta_1 = DistillationTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits, beta=1)
+ assert loss_beta_0 != loss_beta_1
+
+ def test_temperature_scaling(self):
+ loss_temp_1 = DistillationTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits, temperature=1)
+ loss_temp_2 = DistillationTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits, temperature=2)
+ assert loss_temp_1 != loss_temp_2
+
+ def test_reduction_methods(self):
+ loss_batchmean = DistillationTrainer.generalized_jsd_loss(
+ self.student_logits, self.teacher_logits, reduction="batchmean"
+ )
+ loss_sum = DistillationTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits, reduction="sum")
+ loss_mean = DistillationTrainer.generalized_jsd_loss(
+ self.student_logits, self.teacher_logits, reduction="mean"
+ )
+ loss_none = DistillationTrainer.generalized_jsd_loss(
+ self.student_logits, self.teacher_logits, reduction="none"
+ )
+
+ assert loss_batchmean.shape == torch.Size([])
+ assert loss_sum.shape == torch.Size([])
+ assert loss_mean.shape == torch.Size([])
+ assert loss_none.shape == self.student_logits.shape
+
+ def test_symmetry(self):
+ student_teacher = DistillationTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits, beta=0.1)
+ teacher_student = DistillationTrainer.generalized_jsd_loss(self.teacher_logits, self.student_logits, beta=0.1)
+ assert student_teacher != teacher_student
+
+ student_teacher = DistillationTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits, beta=0.5)
+ teacher_student = DistillationTrainer.generalized_jsd_loss(self.teacher_logits, self.student_logits, beta=0.5)
+ assert student_teacher == teacher_student
+
+ def test_zero_loss_for_identical_inputs(self):
+ identical_logits = torch.randn(self.batch_size, self.seq_length, self.vocab_size)
+ loss = DistillationTrainer.generalized_jsd_loss(identical_logits, identical_logits)
+ assert round(abs(loss.item() - 0), 6) == 0
+
+
+class TestDistillationTrainer(TrlTestCase):
+ def setup_method(self):
+ self.model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+ self.tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+ self.tokenizer.pad_token = self.tokenizer.eos_token
+
+ def _make_args(self, **kwargs):
+ args = {
+ "output_dir": self.tmp_dir,
+ "per_device_train_batch_size": 2,
+ "gradient_accumulation_steps": 1,
+ "max_steps": 1,
+ "save_strategy": "no",
+ "report_to": "none",
+ "disable_tqdm": True,
+ "use_cpu": True,
+ "bf16": False,
+ "lmbda": 0.0,
+ "max_length": 128,
+ "max_completion_length": 32,
+ "model_init_kwargs": {"dtype": "float32", "device_map": None},
+ "teacher_model_init_kwargs": {"dtype": "float32", "device_map": None},
+ }
+ args.update(kwargs)
+ return DistillationConfig(**args)
+
+ def _make_local_trainer(self, **kwargs):
+ dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling", split="train")
+ return DistillationTrainer(
+ model=self.model_id,
+ teacher_model=self.model_id,
+ args=self._make_args(**kwargs),
+ train_dataset=dataset,
+ processing_class=self.tokenizer,
+ )
+
+ def _make_server_trainer(self, **kwargs):
+ dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling", split="train")
+ return DistillationTrainer(
+ model=self.model_id,
+ teacher_model=None,
+ args=self._make_args(use_teacher_server=True, teacher_model_server_url="http://localhost:8000", **kwargs),
+ train_dataset=dataset,
+ processing_class=self.tokenizer,
+ )
+
+ def _make_batch(self, trainer):
+ examples = [trainer.train_dataset[i] for i in range(2)]
+ return trainer.data_collator(examples)
+
+ @staticmethod
+ def _move_batch_to_device(batch, device):
+ return {key: value.to(device) for key, value in batch.items()}
+
+ def test_distillation_trainer_train_runs_with_local_teacher(self):
+ training_args = self._make_args(
+ dataloader_drop_last=True,
+ eval_strategy="steps",
+ max_steps=4,
+ eval_steps=2,
+ save_strategy="steps",
+ save_steps=2,
+ per_device_eval_batch_size=2,
+ )
+ dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling")
+ trainer = DistillationTrainer(
+ model=self.model_id,
+ teacher_model=self.model_id,
+ args=training_args,
+ train_dataset=dataset["train"],
+ eval_dataset=dataset["test"],
+ processing_class=self.tokenizer,
+ )
+
+ train_result = trainer.train()
+
+ assert trainer.state.log_history[-1]["train_loss"] is not None
+ assert trainer.state.log_history[0]["eval_loss"] is not None
+ assert train_result.metrics["train_loss"] >= 0.0
+ assert "model.safetensors" in os.listdir(self.tmp_dir + "/checkpoint-2")
+
+ @pytest.mark.parametrize("loss_top_k", [0, 1])
+ def test_loss_normalizes_by_num_items_in_batch(self, loss_top_k):
+ # When `num_items_in_batch` is passed (as under gradient accumulation), the divergence loss must be reduced as
+ # sum / num_items_in_batch rather than the local per-microbatch mean. See issue #4719. Both the full-vocabulary
+ # JSD path (loss_top_k=0) and the default mixed top-1 path (loss_top_k=1) route through
+ # `_reduce_divergence_loss`, so both must honor `num_items_in_batch`.
+ trainer = self._make_local_trainer(beta=0.5, loss_top_k=loss_top_k)
+
+ # Diverge the teacher from the student so the divergence is well above fp noise (else the loss is ~0).
+ torch.manual_seed(0)
+ with torch.no_grad():
+ for p in trainer.teacher_model.parameters():
+ p.add_(0.5 * torch.randn_like(p))
+
+ batch = self._move_batch_to_device(self._make_batch(trainer), trainer.accelerator.device)
+
+ # Number of valid (non-ignored) tokens in the local batch, sliced the same way `compute_loss` does.
+ prompt_length = trainer._compute_prompt_length(batch)
+ num_valid = (batch["labels"][:, prompt_length:] != -100).sum()
+
+ trainer.model.eval()
+ with torch.no_grad():
+ loss_mean = trainer.compute_loss(trainer.model, batch) # num_items_in_batch=None -> local mean
+ loss_global = trainer.compute_loss(trainer.model, batch, num_items_in_batch=num_valid)
+ loss_double = trainer.compute_loss(trainer.model, batch, num_items_in_batch=num_valid * 2)
+
+ # With num_items_in_batch equal to the local valid-token count, sum/N equals the local mean.
+ torch.testing.assert_close(loss_global, loss_mean, rtol=1e-4, atol=1e-6)
+ # Doubling the global count exactly halves the loss (sum / num_items is linear in 1/num_items).
+ torch.testing.assert_close(loss_double, loss_mean / 2, rtol=1e-4, atol=1e-6)
+
+ @require_liger_kernel
+ @require_torch_accelerator
+ def test_distillation_trainer_with_liger(self):
+ import importlib
+
+ training_args = self._make_args(use_liger_kernel=True, use_cpu=False)
+ dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling", split="train")
+
+ trainer = DistillationTrainer(
+ model=self.model_id,
+ teacher_model=self.model_id,
+ args=training_args,
+ train_dataset=dataset,
+ processing_class=self.tokenizer,
+ )
+
+ try:
+ assert trainer.use_liger_loss is True
+ trainer.train()
+ assert trainer.state.log_history[-1]["train_loss"] is not None
+ finally:
+ importlib.reload(importlib.import_module(trainer.model.__module__))
+
+ def test_sampled_mode_matches_between_local_and_external_teachers(self, monkeypatch):
+ import trl.generation.vllm_client as vllm_client_module
+
+ teacher_client = RecordingTeacherClient()
+ monkeypatch.setattr(vllm_client_module, "VLLMClient", lambda *args, **kwargs: teacher_client)
+
+ local_trainer = self._make_local_trainer(beta=0.5, loss_top_k=1, reverse_kl_top_1_mode="sampled")
+ server_trainer = self._make_server_trainer(beta=0.5, loss_top_k=1)
+
+ cpu_inputs = self._make_batch(local_trainer)
+ expected_sequences, expected_prompt_lengths, _ = build_teacher_request_inputs(
+ cpu_inputs["input_ids"],
+ cpu_inputs["attention_mask"],
+ prompt_attention_mask=cpu_inputs["prompt_attention_mask"],
+ labels=cpu_inputs["labels"],
+ )
+
+ local_inputs = self._move_batch_to_device(cpu_inputs, local_trainer.accelerator.device)
+ server_inputs = self._move_batch_to_device(cpu_inputs, server_trainer.accelerator.device)
+
+ local_trainer.teacher_model.eval()
+ with torch.no_grad():
+ teacher_logits = local_trainer.teacher_model(
+ input_ids=local_inputs["input_ids"],
+ attention_mask=local_inputs["attention_mask"],
+ ).logits
+ teacher_client.result = _build_server_result(
+ teacher_logits,
+ local_inputs,
+ temperature=local_trainer.temperature,
+ )
+ local_loss = local_trainer.compute_loss(local_trainer.model, local_inputs)
+ server_loss = server_trainer.compute_loss(server_trainer.model, server_inputs)
+
+ assert teacher_client.calls[0]["sequences"] == expected_sequences
+ assert teacher_client.calls[0]["prompt_lengths"] == expected_prompt_lengths
+ assert teacher_client.calls[0]["top_logprobs"] == 1
+ torch.testing.assert_close(local_loss, server_loss)
+
+
+class TestDistillationTrainerServerPath(TrlTestCase):
+ @classmethod
+ def setup_class(cls):
+ model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+ cls.device = "cuda" if torch.cuda.is_available() else "cpu"
+ cls.tokenizer = AutoTokenizer.from_pretrained(model_id)
+ cls.tokenizer.pad_token = cls.tokenizer.eos_token
+ cls.model_id = model_id
+
+ def _run_one_step(self, bs, ga, monkeypatch):
+ from trl.generation import vllm_client as vllm_client_module
+
+ fake_client = MagicMock()
+ fake_client.get_sequence_logprobs.side_effect = _canned_teacher_logprobs
+ monkeypatch.setattr(vllm_client_module, "VLLMClient", lambda *a, **kw: fake_client)
+
+ config = DistillationConfig(
+ output_dir=self.tmp_dir,
+ per_device_train_batch_size=bs,
+ gradient_accumulation_steps=ga,
+ learning_rate=1e-4,
+ max_length=64,
+ max_prompt_length=32,
+ max_completion_length=32,
+ use_teacher_server=True,
+ teacher_model_server_url="http://fake-teacher.invalid:8000",
+ loss_top_k=1,
+ beta=1.0,
+ lmbda=0.0,
+ loss_add_tail=True,
+ save_strategy="no",
+ report_to="none",
+ logging_steps=1,
+ use_cpu=not torch.cuda.is_available(),
+ bf16=False,
+ )
+ model = AutoModelForCausalLM.from_pretrained(self.model_id, dtype=torch.float32).to(self.device)
+ trainer = DistillationTrainer(
+ model=model,
+ args=config,
+ train_dataset=_variable_length_dataset(),
+ processing_class=self.tokenizer,
+ )
+ trainer.teacher_client = fake_client
+ trainer.train()
+ return [rec for rec in trainer.state.log_history if "grad_norm" in rec]
+
+ @pytest.mark.parametrize(("bs", "ga"), [(1, 2), (2, 1)])
+ def test_reverse_kl_finite_grad_with_ragged_batch(self, bs, ga, monkeypatch):
+ records = self._run_one_step(bs=bs, ga=ga, monkeypatch=monkeypatch)
+ assert records, "Expected at least one grad_norm log entry during training"
+ for record in records:
+ assert math.isfinite(record["grad_norm"]), f"grad_norm={record['grad_norm']} leaked -inf into backward"
+ assert math.isfinite(record["loss"])
+
+
+def test_repeat_batch_dataloader_delegates_set_epoch_via_getattr():
+ class DummyDataLoader:
+ def __init__(self):
+ self.epoch = None
+
+ def __iter__(self):
+ yield {"x": 1}
+
+ def __len__(self):
+ return 1
+
+ def set_epoch(self, epoch):
+ self.epoch = epoch
+
+ dataloader = DummyDataLoader()
+ wrapper = _RepeatBatchDataLoader(dataloader, repeat_count=2)
+
+ wrapper.set_epoch(7)
+
+ assert dataloader.epoch == 7
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_dppo_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_dppo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..0915d0eaba3b88c313cf012574a8db3dc50773a3
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_dppo_trainer.py
@@ -0,0 +1,184 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+import torch
+from datasets import load_dataset
+
+from trl.experimental.dppo import DPPOConfig, DPPOTrainer
+
+from ..testing_utils import TrlTestCase
+
+
+class TestDPPODivergenceMask:
+ """Unit tests for _compute_divergence_mask with synthetic inputs."""
+
+ @staticmethod
+ def make_trainer(divergence_type="binary_tv", epsilon=0.2, epsilon_high=0.28):
+ """Create a minimal DPPOTrainer-like object with just the attributes needed for _compute_divergence_mask."""
+
+ class Stub:
+ pass
+
+ stub = Stub()
+ stub.divergence_type = divergence_type
+ stub.epsilon_low = epsilon
+ stub.epsilon_high = epsilon_high
+ return stub
+
+ @staticmethod
+ def compute_divergence_mask(
+ trainer_stub,
+ current_logps,
+ sampling_logps,
+ advantages,
+ completion_mask,
+ current_topk_logps=None,
+ sampling_topk_logps=None,
+ ):
+ return DPPOTrainer._compute_divergence_mask(
+ trainer_stub,
+ current_logps,
+ sampling_logps,
+ advantages,
+ completion_mask,
+ current_topk_logps=current_topk_logps,
+ sampling_topk_logps=sampling_topk_logps,
+ )
+
+ def test_binary_tv_no_masking_within_threshold(self):
+ stub = self.make_trainer("binary_tv", epsilon=0.2, epsilon_high=0.28)
+ # Policies are very close — no tokens should be masked
+ sampling_logps = torch.log(torch.tensor([[0.5, 0.3, 0.7]]))
+ current_logps = torch.log(torch.tensor([[0.51, 0.29, 0.71]]))
+ advantages = torch.tensor([[1.0]])
+ completion_mask = torch.ones(1, 3)
+
+ mask = self.compute_divergence_mask(stub, current_logps, sampling_logps, advantages, completion_mask)
+ assert mask.shape == (1, 3)
+ assert (mask == 1.0).all()
+
+ def test_binary_tv_masks_positive_advantage_high_divergence(self):
+ stub = self.make_trainer("binary_tv", epsilon=0.01, epsilon_high=0.01)
+ # π much higher than μ, positive advantage → should be masked (invalid_pos)
+ sampling_logps = torch.log(torch.tensor([[0.1]]))
+ current_logps = torch.log(torch.tensor([[0.5]]))
+ advantages = torch.tensor([[1.0]])
+ completion_mask = torch.ones(1, 1)
+
+ mask = self.compute_divergence_mask(stub, current_logps, sampling_logps, advantages, completion_mask)
+ assert mask.item() == 0.0
+
+ def test_binary_tv_masks_negative_advantage_low_divergence(self):
+ stub = self.make_trainer("binary_tv", epsilon=0.01, epsilon_high=0.01)
+ # π much lower than μ, negative advantage → should be masked (invalid_neg)
+ sampling_logps = torch.log(torch.tensor([[0.5]]))
+ current_logps = torch.log(torch.tensor([[0.1]]))
+ advantages = torch.tensor([[-1.0]])
+ completion_mask = torch.ones(1, 1)
+
+ mask = self.compute_divergence_mask(stub, current_logps, sampling_logps, advantages, completion_mask)
+ assert mask.item() == 0.0
+
+ def test_binary_tv_respects_completion_mask(self):
+ stub = self.make_trainer("binary_tv", epsilon=0.01, epsilon_high=0.01)
+ # Even though divergence is huge, padding tokens stay 0
+ sampling_logps = torch.log(torch.tensor([[0.1, 0.5]]))
+ current_logps = torch.log(torch.tensor([[0.9, 0.9]]))
+ advantages = torch.tensor([[1.0]])
+ completion_mask = torch.tensor([[1.0, 0.0]])
+
+ mask = self.compute_divergence_mask(stub, current_logps, sampling_logps, advantages, completion_mask)
+ assert mask[0, 1].item() == 0.0
+
+ def test_topk_tv_requires_topk_inputs(self):
+ stub = self.make_trainer("topk_tv")
+ B, T, K = 1, 2, 4
+ sampling_logps = torch.log(torch.full((B, T), 0.3))
+ current_logps = torch.log(torch.full((B, T), 0.31))
+ advantages = torch.tensor([[1.0]])
+ completion_mask = torch.ones(B, T)
+
+ # Build top-K distributions that are nearly identical
+ topk_probs = torch.softmax(torch.randn(B, T, K), dim=-1)
+ sampling_topk_logps = torch.log(topk_probs)
+ current_topk_logps = torch.log(topk_probs + 0.001)
+
+ mask = self.compute_divergence_mask(
+ stub,
+ current_logps,
+ sampling_logps,
+ advantages,
+ completion_mask,
+ current_topk_logps=current_topk_logps,
+ sampling_topk_logps=sampling_topk_logps,
+ )
+ assert mask.shape == (B, T)
+ assert (mask == 1.0).all()
+
+
+@pytest.mark.low_priority
+class TestDPPOTrainer(TrlTestCase):
+ @pytest.mark.parametrize("divergence_type", ["binary_tv", "binary_kl"])
+ def test_train_binary(self, divergence_type):
+ dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+ training_args = DPPOConfig(
+ 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
+ divergence_type=divergence_type,
+ report_to="none",
+ )
+ trainer = DPPOTrainer(
+ 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)
+ 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_conversational(self, config_name):
+ dataset = load_dataset("trl-internal-testing/zen", config_name, split="train")
+
+ training_args = DPPOConfig(
+ 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
+ report_to="none",
+ )
+ trainer = DPPOTrainer(
+ model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+ reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+ args=training_args,
+ train_dataset=dataset,
+ )
+
+ trainer.train()
+
+ assert trainer.state.log_history[-1]["train_loss"] is not None
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_gkd_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_gkd_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..78b93d951bc69b92046466f529ebe4ad1d671719
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_gkd_trainer.py
@@ -0,0 +1,538 @@
+# 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 pytest
+import torch
+import torch.nn.functional as F
+from datasets import Dataset, load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig
+
+from trl.experimental.gkd import GKDConfig, GKDTrainer
+
+from ..testing_utils import TrlTestCase, require_liger_kernel, require_torch_accelerator
+
+
+class TestGKDTrainerGenerateOnPolicy(TrlTestCase):
+ @classmethod
+ def setup_class(cls):
+ model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+ cls.device = "cuda" if torch.cuda.is_available() else "cpu"
+ cls.tokenizer = AutoTokenizer.from_pretrained(model_id)
+ cls.tokenizer.pad_token = cls.tokenizer.eos_token
+ cls.model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32").to(cls.device)
+ cls.generation_config = GenerationConfig(
+ max_new_tokens=20,
+ num_return_sequences=1,
+ pad_token_id=cls.tokenizer.pad_token_id,
+ eos_token_id=cls.tokenizer.eos_token_id,
+ )
+
+ def test_generate_on_policy_outputs_deterministic(self):
+ prompts = ["Hello, how are you?", "What's the weather like today?"]
+ tokenized_prompts = self.tokenizer(prompts, return_tensors="pt", padding=True)
+
+ inputs = {
+ "prompts": tokenized_prompts["input_ids"].to(self.device),
+ "prompt_attention_mask": tokenized_prompts["attention_mask"].to(self.device),
+ }
+
+ # Set temperature to 0 for deterministic output
+ deterministic_generation_config = GenerationConfig(
+ max_new_tokens=30,
+ num_return_sequences=1,
+ pad_token_id=self.tokenizer.pad_token_id,
+ eos_token_id=self.tokenizer.eos_token_id,
+ do_sample=False,
+ temperature=0.0,
+ )
+
+ outputs = GKDTrainer.generate_on_policy_outputs(
+ self.model, inputs, deterministic_generation_config, self.tokenizer.pad_token_id
+ )
+
+ new_input_ids, new_attention_mask, new_labels = outputs
+
+ # Decode the generated outputs
+ generated_texts = self.tokenizer.batch_decode(new_input_ids, skip_special_tokens=True)
+
+ # Check if the generated texts start with the original prompts
+ for prompt, generated_text in zip(prompts, generated_texts, strict=True):
+ assert generated_text.startswith(prompt), (
+ f"Generated text '{generated_text}' does not start with prompt '{prompt}'"
+ )
+
+ # Run the generation twice and check if the outputs are identical
+ outputs2 = GKDTrainer.generate_on_policy_outputs(
+ self.model, inputs, deterministic_generation_config, self.tokenizer.pad_token_id
+ )
+
+ new_input_ids2, new_attention_mask2, new_labels2 = outputs2
+
+ # Check if the two generations are identical
+ assert torch.all(new_input_ids.eq(new_input_ids2)), "Deterministic generations are not identical"
+ assert torch.all(new_attention_mask.eq(new_attention_mask2)), (
+ "Attention masks for deterministic generations are not identical"
+ )
+ assert torch.all(new_labels.eq(new_labels2)), "Labels for deterministic generations are not identical"
+
+ def test_generate_on_policy_outputs(self):
+ prompts = ["Hello, how are you?", "What's the weather like today?"]
+ tokenized_prompts = self.tokenizer(prompts, return_tensors="pt", padding=True)
+
+ inputs = {
+ "prompts": tokenized_prompts["input_ids"].to(self.device),
+ "attention_mask": tokenized_prompts["attention_mask"].to(self.device),
+ }
+
+ outputs = GKDTrainer.generate_on_policy_outputs(
+ self.model, inputs, self.generation_config, self.tokenizer.pad_token_id
+ )
+
+ # Check that outputs is a tuple of three tensors
+ assert isinstance(outputs, tuple)
+ assert len(outputs) == 3
+
+ new_input_ids, new_attention_mask, new_labels = outputs
+
+ # Check shapes
+ batch_size = len(prompts)
+ assert new_input_ids.shape[0] == batch_size
+ assert new_attention_mask.shape[0] == batch_size
+ assert new_labels.shape[0] == batch_size
+
+ # Check types
+ assert isinstance(new_input_ids, torch.Tensor)
+ assert isinstance(new_attention_mask, torch.Tensor)
+ assert isinstance(new_labels, torch.Tensor)
+
+ # Check that new_input_ids and new_attention_mask have the same shape
+ assert new_input_ids.shape == new_attention_mask.shape
+ assert new_labels.shape == new_attention_mask.shape
+
+ def test_generate_on_policy_outputs_masks_prompt(self):
+ # The on-policy / seq-KD labels must mask the prompt with -100, matching the collator
+ # convention (labels[:len(prompt)] = -100). Otherwise `compute_loss`, which relies on the
+ # -100 mask to skip prompts, would apply the JSD loss to prompt positions too.
+ # Prompts have different lengths so batched left-padding is exercised (the bug condition).
+ prompts = ["Hello, how are you doing today?", "Hi"]
+ self.tokenizer.padding_side = "left"
+ tokenized_prompts = self.tokenizer(prompts, return_tensors="pt", padding=True)
+ prompt_width = tokenized_prompts["input_ids"].shape[1]
+
+ inputs = {
+ "prompts": tokenized_prompts["input_ids"].to(self.device),
+ "prompt_attention_mask": tokenized_prompts["attention_mask"].to(self.device),
+ }
+
+ # Force a non-trivial completion so the completion region is not all padding (which would
+ # let the prompt-masking assertion pass for the wrong reason).
+ generation_config = GenerationConfig(
+ max_new_tokens=16,
+ min_new_tokens=8,
+ num_return_sequences=1,
+ pad_token_id=self.tokenizer.pad_token_id,
+ eos_token_id=self.tokenizer.eos_token_id,
+ do_sample=False,
+ )
+
+ _, _, new_labels = GKDTrainer.generate_on_policy_outputs(
+ self.model, inputs, generation_config, self.tokenizer.pad_token_id
+ )
+
+ # Every prompt position (the first `prompt_width` columns) must be masked.
+ assert (new_labels[:, :prompt_width] == -100).all(), "Prompt positions are not fully masked"
+ # The completion region must still carry signal (not entirely masked away).
+ assert (new_labels[:, prompt_width:] != -100).any(), "Completion tokens were unexpectedly all masked"
+
+
+class TestGeneralizedJSDLoss(TrlTestCase):
+ def setup_method(self):
+ self.batch_size = 2
+ self.seq_length = 3
+ self.vocab_size = 5
+ self.student_logits = torch.randn(self.batch_size, self.seq_length, self.vocab_size)
+ self.teacher_logits = torch.randn(self.batch_size, self.seq_length, self.vocab_size)
+
+ def test_uniform_distribution(self):
+ logits = torch.ones(1, 1, self.vocab_size)
+ loss = GKDTrainer.generalized_jsd_loss(logits, logits)
+ assert round(abs(loss.item() - 0), 5) == 0
+
+ def test_generalized_jsd_loss_edge_cases(self):
+ # Setup
+ student_logits = torch.log(torch.tensor([[0.1, 0.9]])).unsqueeze(0)
+ teacher_logits = torch.log(torch.tensor([[0.9, 0.1]])).unsqueeze(0)
+
+ # Case 1: beta = 1 (should be equivalent to KL(student || teacher))
+ loss_beta_1 = GKDTrainer.generalized_jsd_loss(student_logits, teacher_logits, beta=1)
+ expected_loss_beta_1 = F.kl_div(
+ F.log_softmax(teacher_logits, dim=-1), F.softmax(student_logits, dim=-1), reduction="batchmean"
+ )
+ assert round(abs(loss_beta_1.item() - expected_loss_beta_1.item()), 5) == 0
+
+ # Case 2: beta = 0 (should be equivalent to KL(teacher || student))
+ loss_beta_0 = GKDTrainer.generalized_jsd_loss(student_logits, teacher_logits, beta=0)
+ expected_loss_beta_0 = F.kl_div(
+ F.log_softmax(student_logits, dim=-1), F.softmax(teacher_logits, dim=-1), reduction="batchmean"
+ )
+ assert round(abs(loss_beta_0.item() - expected_loss_beta_0.item()), 5) == 0
+
+ def test_output_shape(self):
+ loss = GKDTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits)
+ assert torch.is_tensor(loss)
+ assert loss.shape == torch.Size([])
+
+ def test_beta_values(self):
+ loss_beta_0 = GKDTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits, beta=0)
+ loss_beta_1 = GKDTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits, beta=1)
+ assert loss_beta_0 != loss_beta_1
+
+ def test_temperature_scaling(self):
+ loss_temp_1 = GKDTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits, temperature=1)
+ loss_temp_2 = GKDTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits, temperature=2)
+ assert loss_temp_1 != loss_temp_2
+
+ def test_reduction_methods(self):
+ loss_batchmean = GKDTrainer.generalized_jsd_loss(
+ self.student_logits, self.teacher_logits, reduction="batchmean"
+ )
+ loss_sum = GKDTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits, reduction="sum")
+ loss_mean = GKDTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits, reduction="mean")
+ loss_none = GKDTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits, reduction="none")
+
+ assert loss_batchmean.shape == torch.Size([])
+ assert loss_sum.shape == torch.Size([])
+ assert loss_mean.shape == torch.Size([])
+ assert loss_none.shape == self.student_logits.shape
+
+ def test_symmetry(self):
+ student_teacher = GKDTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits, beta=0.1)
+ teacher_student = GKDTrainer.generalized_jsd_loss(self.teacher_logits, self.student_logits, beta=0.1)
+ assert student_teacher != teacher_student
+
+ student_teacher = GKDTrainer.generalized_jsd_loss(self.student_logits, self.teacher_logits, beta=0.5)
+ teacher_student = GKDTrainer.generalized_jsd_loss(self.teacher_logits, self.student_logits, beta=0.5)
+ assert student_teacher == teacher_student
+
+ def test_zero_loss_for_identical_inputs(self):
+ identical_logits = torch.randn(self.batch_size, self.seq_length, self.vocab_size)
+ loss = GKDTrainer.generalized_jsd_loss(identical_logits, identical_logits)
+ assert round(abs(loss.item() - 0), 6) == 0
+
+
+class TestGKDTrainer(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.teacher_model = AutoModelForCausalLM.from_pretrained(self.model_id)
+ self.tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+ self.tokenizer.pad_token = self.tokenizer.eos_token
+
+ def test_gkd_trainer(self):
+ training_args = GKDConfig(
+ output_dir=self.tmp_dir,
+ dataloader_drop_last=True,
+ eval_strategy="steps",
+ max_steps=4,
+ eval_steps=2,
+ save_steps=2,
+ per_device_train_batch_size=2,
+ per_device_eval_batch_size=2,
+ report_to="none",
+ )
+ dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling")
+
+ trainer = GKDTrainer(
+ model=self.model_id,
+ teacher_model=self.model_id,
+ args=training_args,
+ train_dataset=dataset["train"],
+ eval_dataset=dataset["test"],
+ processing_class=self.tokenizer,
+ )
+
+ trainer.train()
+
+ assert trainer.state.log_history[(-1)]["train_loss"] is not None
+ assert trainer.state.log_history[0]["eval_loss"] is not None
+ assert "model.safetensors" in os.listdir(self.tmp_dir + "/checkpoint-2")
+
+ @require_liger_kernel
+ def test_gkd_trainer_with_liger(self):
+ training_args = GKDConfig(
+ output_dir=self.tmp_dir,
+ per_device_train_batch_size=2,
+ max_length=64,
+ report_to="none",
+ use_liger_kernel=True,
+ )
+ dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling", split="train")
+
+ trainer = GKDTrainer(
+ model=self.model_id,
+ teacher_model=self.model_id,
+ args=training_args,
+ train_dataset=dataset,
+ processing_class=self.tokenizer,
+ )
+
+ # Ensure liger fused JSD path is enabled; if not, skip (runtime may lack system libs)
+ if not getattr(trainer, "use_liger_gkd_loss", False):
+ pytest.skip("Liger fused JSD not enabled at runtime; skipping fused-loss assertion")
+
+ trainer.train()
+
+ # Check we logged a train loss
+ assert trainer.state.log_history[-1]["train_loss"] is not None
+
+ def test_generation_config_init(self):
+ training_args = GKDConfig(output_dir=self.tmp_dir)
+ dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling")
+
+ trainer = GKDTrainer(
+ model=self.model_id,
+ teacher_model=self.model_id,
+ args=training_args,
+ train_dataset=dataset["train"],
+ eval_dataset=dataset["test"],
+ processing_class=self.tokenizer,
+ )
+
+ assert trainer.generation_config.pad_token_id == self.tokenizer.eos_token_id
+ assert trainer.generation_config.eos_token_id == self.model.generation_config.eos_token_id
+ assert trainer.generation_config.max_new_tokens == training_args.max_new_tokens
+ assert trainer.generation_config.temperature == training_args.temperature
+ assert trainer.generation_config.top_k == 0
+
+ @require_liger_kernel
+ def test_compute_loss_return_outputs_with_liger(self):
+ """Test that return_outputs=True works correctly with Liger kernel path."""
+ training_args = GKDConfig(
+ output_dir=self.tmp_dir,
+ report_to="none",
+ use_liger_kernel=True,
+ max_steps=2,
+ eval_strategy="steps",
+ eval_steps=1,
+ per_device_train_batch_size=2,
+ per_device_eval_batch_size=2,
+ )
+ dummy_dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling")
+
+ trainer = GKDTrainer(
+ model=self.model_id,
+ teacher_model=self.model_id,
+ args=training_args,
+ train_dataset=dummy_dataset["train"],
+ eval_dataset=dummy_dataset["test"],
+ processing_class=self.tokenizer,
+ )
+
+ # evaluate() calls compute_loss with return_outputs=True; must not raise UnboundLocalError
+ eval_results = trainer.evaluate()
+ assert "eval_loss" in eval_results
+ assert eval_results["eval_loss"] is not None
+
+ @require_liger_kernel
+ @require_torch_accelerator
+ def test_liger_loss_matches_non_liger_loss(self):
+ # The Liger fused JSD path must compute the same loss as the non-Liger path
+ # (LigerFusedLinearJSDLoss defaults mix 0.5 * CE + 0.5 * JSD, but GKD wants pure JSD).
+ common = dict(output_dir=self.tmp_dir, report_to="none", per_device_train_batch_size=2, max_length=64)
+ dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling", split="train").select(
+ range(2)
+ )
+
+ ref_trainer = GKDTrainer(
+ model=self.model_id,
+ teacher_model=self.model_id,
+ args=GKDConfig(use_liger_kernel=False, **common),
+ train_dataset=dataset,
+ processing_class=self.tokenizer,
+ )
+ liger_trainer = GKDTrainer(
+ model=self.model_id,
+ teacher_model=self.model_id,
+ args=GKDConfig(use_liger_kernel=True, **common),
+ train_dataset=dataset,
+ processing_class=self.tokenizer,
+ )
+
+ # Force student/teacher weights identical between trainers, then diverge teacher
+ # so JSD is well above fp noise.
+ liger_trainer.model.load_state_dict(ref_trainer.model.state_dict())
+ torch.manual_seed(0)
+ with torch.no_grad():
+ for p in ref_trainer.teacher_model.parameters():
+ p.add_(0.5 * torch.randn_like(p))
+ liger_trainer.teacher_model.load_state_dict(ref_trainer.teacher_model.state_dict())
+
+ device = next(ref_trainer.model.parameters()).device
+ batch = ref_trainer.data_collator([ref_trainer.train_dataset[i] for i in range(2)])
+ batch = {k: v.to(device) for k, v in batch.items() if isinstance(v, torch.Tensor)}
+
+ 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,
+ )
+
+ @require_torch_accelerator
+ def test_loss_normalizes_by_num_items_in_batch(self):
+ # When `num_items_in_batch` is passed (as under gradient accumulation), the loss must be the JSD summed over
+ # valid tokens divided by that global count, rather than the local per-microbatch mean. See issue #4719.
+ # GPU-gated like `test_liger_loss_matches_non_liger_loss`: GKD's loss path is accelerator-affine, so the model
+ # runs on the device rather than being forced to CPU.
+ common = dict(
+ output_dir=self.tmp_dir,
+ report_to="none",
+ per_device_train_batch_size=2,
+ max_length=64,
+ )
+ dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling", split="train").select(
+ range(2)
+ )
+ trainer = GKDTrainer(
+ model=self.model_id,
+ teacher_model=self.model_id,
+ args=GKDConfig(use_liger_kernel=False, **common),
+ train_dataset=dataset,
+ processing_class=self.tokenizer,
+ )
+
+ # Diverge the teacher from the student so JSD is well above fp noise (else the loss is identically 0).
+ torch.manual_seed(0)
+ with torch.no_grad():
+ for p in trainer.teacher_model.parameters():
+ p.add_(0.5 * torch.randn_like(p))
+
+ device = next(trainer.model.parameters()).device
+ batch = trainer.data_collator([trainer.train_dataset[i] for i in range(2)])
+ batch = {k: v.to(device) for k, v in batch.items() if isinstance(v, torch.Tensor)}
+
+ # Number of valid (non-ignored) tokens in the local batch, sliced the same way `compute_loss` does.
+ prompt_lengths = batch["prompts"].shape[1]
+ num_valid = (batch["labels"][:, prompt_lengths:] != -100).sum()
+
+ trainer.model.eval()
+ with torch.no_grad():
+ loss_mean = trainer.compute_loss(trainer.model, batch) # num_items_in_batch=None -> local mean
+ loss_global = trainer.compute_loss(trainer.model, batch, num_items_in_batch=num_valid)
+
+ # With num_items_in_batch equal to the local valid-token count, sum/N equals the local mean.
+ torch.testing.assert_close(loss_global, loss_mean, rtol=1e-4, atol=1e-6)
+
+ # Passing a different global count rescales the loss exactly by num_valid / num_items_in_batch. This is the
+ # gradient-accumulation-correct behavior: a microbatch contributes its token-sum divided by the *global* count.
+ loss_double = trainer.compute_loss(trainer.model, batch, num_items_in_batch=num_valid * 2)
+ torch.testing.assert_close(loss_double, loss_mean / 2, rtol=1e-4, atol=1e-6)
+
+ @require_torch_accelerator
+ def test_loss_covers_all_completion_tokens_with_variable_length_prompts(self):
+ # The loss must be computed over EVERY valid completion token, even when prompts have different lengths.
+ # A previous implementation sliced logits/labels by `inputs["prompts"].shape[1]` (the batch-max prompt
+ # width); because `labels` is padded to the full-sequence width independently of `prompts`, that slice
+ # dropped completion tokens for samples whose prompt was shorter than the batch maximum, mis-scaling the
+ # loss when normalized by `num_items_in_batch`. See issue #4719.
+ common = dict(output_dir=self.tmp_dir, report_to="none", per_device_train_batch_size=2, max_length=64)
+ # Two conversations with deliberately different prompt lengths.
+ dataset = Dataset.from_dict(
+ {
+ "messages": [
+ [{"role": "user", "content": "Hi"}, {"role": "assistant", "content": "Hello there, how are you?"}],
+ [
+ {"role": "user", "content": "Please explain in detail the theory of general relativity"},
+ {"role": "assistant", "content": "OK"},
+ ],
+ ]
+ }
+ )
+ trainer = GKDTrainer(
+ model=self.model_id,
+ teacher_model=self.model_id,
+ args=GKDConfig(use_liger_kernel=False, **common),
+ train_dataset=dataset,
+ processing_class=self.tokenizer,
+ )
+
+ torch.manual_seed(0)
+ with torch.no_grad():
+ for p in trainer.teacher_model.parameters():
+ p.add_(0.5 * torch.randn_like(p))
+
+ device = next(trainer.model.parameters()).device
+ batch = trainer.data_collator([trainer.train_dataset[i] for i in range(2)])
+ batch = {k: v.to(device) for k, v in batch.items() if isinstance(v, torch.Tensor)}
+
+ # The prompts are different lengths, so the batch-max prompt width exceeds at least one sample's prompt.
+ assert batch["prompts"].shape[1] > (batch["labels"][0] != -100).nonzero()[0].item()
+
+ # All valid completion tokens across the batch — what num_items_in_batch counts.
+ num_valid = (batch["labels"] != -100).sum()
+
+ trainer.model.eval()
+ with torch.no_grad():
+ loss_mean = trainer.compute_loss(trainer.model, batch) # None -> local mean over the tokens it summed
+ loss_global = trainer.compute_loss(trainer.model, batch, num_items_in_batch=num_valid)
+
+ # If the loss covers every valid completion token, the global-count reduction (sum / num_valid) equals the
+ # local mean. The old prompt-width slice summed FEWER tokens than num_valid, so loss_global != loss_mean.
+ torch.testing.assert_close(loss_global, loss_mean, rtol=1e-4, atol=1e-6)
+
+ @require_liger_kernel
+ @require_torch_accelerator
+ def test_liger_loss_normalizes_by_num_items_in_batch(self):
+ # The Liger fused JSD path normalizes by the local valid-token count internally; passing num_items_in_batch
+ # must rescale it to the global count (see issue #4719). Mirrors the non-Liger test on the Liger path.
+ common = dict(output_dir=self.tmp_dir, report_to="none", per_device_train_batch_size=2, max_length=64)
+ dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling", split="train").select(
+ range(2)
+ )
+ trainer = GKDTrainer(
+ model=self.model_id,
+ teacher_model=self.model_id,
+ args=GKDConfig(use_liger_kernel=True, **common),
+ train_dataset=dataset,
+ processing_class=self.tokenizer,
+ )
+ if not getattr(trainer, "use_liger_gkd_loss", False):
+ pytest.skip("Liger fused JSD not enabled at runtime; skipping fused-loss assertion")
+
+ torch.manual_seed(0)
+ with torch.no_grad():
+ for p in trainer.teacher_model.parameters():
+ p.add_(0.5 * torch.randn_like(p))
+
+ device = next(trainer.model.parameters()).device
+ batch = trainer.data_collator([trainer.train_dataset[i] for i in range(2)])
+ batch = {k: v.to(device) for k, v in batch.items() if isinstance(v, torch.Tensor)}
+
+ trainer.model.eval()
+ with torch.no_grad():
+ loss_mean = trainer.compute_loss(trainer.model, batch) # num_items_in_batch=None -> local mean
+ loss_k = trainer.compute_loss(trainer.model, batch, num_items_in_batch=100)
+ loss_2k = trainer.compute_loss(trainer.model, batch, num_items_in_batch=200)
+
+ # Doubling the global count exactly halves the loss; the rescaled loss differs from the local mean.
+ torch.testing.assert_close(loss_2k, loss_k / 2, rtol=1e-4, atol=1e-6)
+ assert not torch.allclose(loss_k, loss_mean)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_gmpo_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_gmpo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..336be8bc21387b6b82785104c8f271b3a644074f
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_gmpo_trainer.py
@@ -0,0 +1,118 @@
+# 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.gmpo import GMPOConfig, GMPOTrainer
+
+from ..testing_utils import TrlTestCase
+
+
+class TestGMPOConfig:
+ def test_default_epsilon_is_log_space(self):
+ # GMPO expresses the clip range in log space; default is the paper's (exp(-0.4), exp(0.4)).
+ args = GMPOConfig("dummy")
+ assert args.epsilon == 0.4
+ # epsilon_high is inherited from GRPOConfig and defaults to None, so the range is symmetric.
+ assert args.epsilon_high is None
+
+
+class TestGMPOTrainer(TrlTestCase):
+ def test_train(self):
+ dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+ training_args = GMPOConfig(
+ 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
+ report_to="none",
+ )
+ trainer = GMPOTrainer(
+ 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."
+
+ @pytest.mark.parametrize("config_name", ["standard_prompt_only", "conversational_prompt_only"])
+ def test_train_conversational(self, config_name):
+ dataset = load_dataset("trl-internal-testing/zen", config_name, split="train")
+
+ training_args = GMPOConfig(
+ 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
+ num_iterations=2, # the importance sampling weights won't be 0 in this case
+ report_to="none",
+ )
+ trainer = GMPOTrainer(
+ model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+ reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-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_kl(self):
+ # GMPO sequence-averages the KL when beta > 0; exercise that path.
+ dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+ training_args = GMPOConfig(
+ 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
+ beta=0.1, # enable KL regularization toward the reference model
+ report_to="none",
+ )
+ trainer = GMPOTrainer(
+ 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
+ assert "kl" in trainer.state.log_history[-1] # KL is logged when beta > 0
+
+ # 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."
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_gold_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_gold_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad77112b319f1d145ac6b3dd77ff4affed9fe7fe
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_gold_trainer.py
@@ -0,0 +1,1325 @@
+# 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 functools import partial
+from types import SimpleNamespace
+
+import pytest
+import torch
+from datasets import Dataset, load_dataset
+from transformers import AutoTokenizer
+
+from trl.experimental.gold import GOLDConfig
+from trl.experimental.gold import gold_trainer as gold_trainer_module
+from trl.experimental.gold.gold_trainer import GOLDTrainer, ULDLoss, build_teacher_inputs_from_texts
+from trl.experimental.utils import (
+ DataCollatorForChatML,
+ encode_with_byte_offsets,
+ pad_byte_offsets,
+)
+
+from ..testing_utils import TrlTestCase
+
+
+@pytest.fixture(scope="module")
+def openr1_examples():
+ try:
+ dataset = load_dataset(
+ "HuggingFaceTB/OpenR1-Math-220k-default-verified",
+ "all",
+ split="train[:3]",
+ )
+ except Exception as exc: # pragma: no cover - network/environment dependent
+ pytest.skip(f"OpenR1 dataset unavailable: {exc}")
+ return [{"messages": row["messages"]} for row in dataset]
+
+
+@pytest.fixture(scope="module")
+def countdown_examples():
+ try:
+ dataset = load_dataset(
+ "HuggingFaceTB/Countdown-Tasks-3to4",
+ "gkd_verified_Qwen2.5-7B-Instruct",
+ split="train[:3]",
+ )
+ except Exception as exc: # pragma: no cover - network/environment dependent
+ pytest.skip(f"Countdown dataset unavailable: {exc}")
+ return [{"messages": row["messages"]} for row in dataset]
+
+
+def _teacher_inputs_from_collator(student_tok, teacher_tok, batch):
+ prompt_texts = []
+ completion_texts = []
+
+ pad_token_id = student_tok.pad_token_id
+ for prompt_ids_tensor, input_ids_tensor, labels_tensor in zip(
+ batch["prompts"], batch["input_ids"], batch["labels"], strict=True
+ ):
+ prompt_ids = prompt_ids_tensor.tolist()
+ if pad_token_id is not None:
+ prompt_ids = [tok for tok in prompt_ids if tok != pad_token_id]
+ prompt_texts.append(student_tok.decode(prompt_ids, skip_special_tokens=False))
+
+ input_ids = input_ids_tensor.tolist()
+ labels = labels_tensor.tolist()
+ completion_token_ids = [tok for tok, label in zip(input_ids, labels, strict=True) if label != -100]
+ completion_texts.append(student_tok.decode(completion_token_ids, skip_special_tokens=False))
+
+ teacher_input_ids, teacher_labels, _, teacher_byte_offsets = build_teacher_inputs_from_texts(
+ teacher_tok, prompt_texts, completion_texts
+ )
+ return teacher_input_ids, teacher_labels, completion_texts, teacher_byte_offsets
+
+
+def _assert_alignment_covers_completion(loss_fn, batch, teacher_input_ids, teacher_labels, teacher_byte_offsets):
+ """Assert byte-offset alignment groups cover every answer-region position."""
+ for idx in range(batch["input_ids"].shape[0]):
+ s_positions = (batch["labels"][idx] != -100).nonzero(as_tuple=True)[0]
+ t_positions = (teacher_labels[idx] != -100).nonzero(as_tuple=True)[0]
+ s_answer = batch["byte_offsets"][idx, s_positions[0] : s_positions[-1] + 1].tolist()
+ t_answer = teacher_byte_offsets[idx, t_positions[0] : t_positions[-1] + 1].tolist()
+ student_groups, teacher_groups = loss_fn._align_by_byte_offsets(s_answer, t_answer)
+ assert student_groups and teacher_groups
+ assert sorted(k for group in student_groups for k in group) == list(range(len(s_answer)))
+ assert sorted(k for group in teacher_groups for k in group) == list(range(len(t_answer)))
+
+
+@pytest.mark.slow
+def test_chatml_collator_preserves_completion_llama(llama_tokenizer, qwen_tokenizer, openr1_examples):
+ collator = DataCollatorForChatML(tokenizer=llama_tokenizer, max_length=512)
+ batch = collator(openr1_examples)
+
+ assistant_texts = [example["messages"][-1]["content"] for example in openr1_examples]
+ decoded_batch = llama_tokenizer.batch_decode(batch["input_ids"], skip_special_tokens=False)
+ for decoded, assistant in zip(decoded_batch, assistant_texts, strict=True):
+ assert assistant.strip() in decoded
+
+ teacher_input_ids, teacher_labels, completion_texts, teacher_byte_offsets = _teacher_inputs_from_collator(
+ llama_tokenizer, qwen_tokenizer, batch
+ )
+ for completion, assistant in zip(completion_texts, assistant_texts, strict=True):
+ assert assistant.strip() in completion
+ assert completion.strip()
+
+ config = build_config(
+ uld_use_hybrid_loss=True,
+ uld_hybrid_matched_weight=0.6,
+ uld_hybrid_unmatched_weight=0.4,
+ )
+ loss_fn = ULDLoss(config, student_tokenizer=llama_tokenizer, teacher_tokenizer=qwen_tokenizer)
+
+ _assert_alignment_covers_completion(loss_fn, batch, teacher_input_ids, teacher_labels, teacher_byte_offsets)
+
+ torch.manual_seed(0)
+ student_vocab = len(llama_tokenizer)
+ teacher_vocab = len(qwen_tokenizer)
+ batch_size, seq_len = batch["input_ids"].shape
+ student_logits = torch.randn(batch_size, seq_len, student_vocab)
+ teacher_logits = torch.randn(batch_size, teacher_input_ids.shape[1], teacher_vocab)
+
+ loss = loss_fn(
+ student_logits=student_logits,
+ teacher_logits=teacher_logits,
+ student_labels=batch["labels"],
+ teacher_labels=teacher_labels,
+ student_input_ids=batch["input_ids"],
+ teacher_input_ids=teacher_input_ids,
+ student_byte_offsets=batch["byte_offsets"],
+ teacher_byte_offsets=teacher_byte_offsets,
+ )
+
+ assert torch.isfinite(loss)
+
+
+@pytest.mark.slow
+def test_chatml_collator_preserves_completion_llama_countdown(llama_tokenizer, qwen_tokenizer, countdown_examples):
+ collator = DataCollatorForChatML(tokenizer=llama_tokenizer, max_length=512)
+ batch = collator(countdown_examples)
+
+ assistant_texts = [example["messages"][-1]["content"] for example in countdown_examples]
+ decoded_batch = llama_tokenizer.batch_decode(batch["input_ids"], skip_special_tokens=False)
+ for decoded, assistant in zip(decoded_batch, assistant_texts, strict=True):
+ assert assistant.strip() in decoded
+
+ teacher_input_ids, teacher_labels, completion_texts, teacher_byte_offsets = _teacher_inputs_from_collator(
+ llama_tokenizer, qwen_tokenizer, batch
+ )
+ for completion, assistant in zip(completion_texts, assistant_texts, strict=True):
+ assert assistant.strip() in completion
+ assert completion.strip()
+
+ config = build_config(
+ uld_use_hybrid_loss=True,
+ uld_hybrid_matched_weight=0.6,
+ uld_hybrid_unmatched_weight=0.4,
+ )
+ loss_fn = ULDLoss(config, student_tokenizer=llama_tokenizer, teacher_tokenizer=qwen_tokenizer)
+
+ _assert_alignment_covers_completion(loss_fn, batch, teacher_input_ids, teacher_labels, teacher_byte_offsets)
+
+ torch.manual_seed(2)
+ student_vocab = len(llama_tokenizer)
+ teacher_vocab = len(qwen_tokenizer)
+ batch_size, seq_len = batch["input_ids"].shape
+ student_logits = torch.randn(batch_size, seq_len, student_vocab)
+ teacher_logits = torch.randn(batch_size, teacher_input_ids.shape[1], teacher_vocab)
+
+ loss = loss_fn(
+ student_logits=student_logits,
+ teacher_logits=teacher_logits,
+ student_labels=batch["labels"],
+ teacher_labels=teacher_labels,
+ student_input_ids=batch["input_ids"],
+ teacher_input_ids=teacher_input_ids,
+ student_byte_offsets=batch["byte_offsets"],
+ teacher_byte_offsets=teacher_byte_offsets,
+ )
+
+ assert torch.isfinite(loss)
+
+
+@pytest.mark.slow
+def test_chatml_collator_preserves_completion_smollm(smollm_tokenizer, qwen_tokenizer, openr1_examples):
+ collator = DataCollatorForChatML(tokenizer=smollm_tokenizer, max_length=512)
+ batch = collator(openr1_examples)
+
+ assistant_texts = [example["messages"][-1]["content"] for example in openr1_examples]
+ decoded_batch = smollm_tokenizer.batch_decode(batch["input_ids"], skip_special_tokens=False)
+ for decoded, assistant in zip(decoded_batch, assistant_texts, strict=True):
+ assert assistant.strip() in decoded
+
+ teacher_input_ids, teacher_labels, completion_texts, teacher_byte_offsets = _teacher_inputs_from_collator(
+ smollm_tokenizer, qwen_tokenizer, batch
+ )
+ for completion, assistant in zip(completion_texts, assistant_texts, strict=True):
+ assert assistant.strip() in completion
+ assert completion.strip()
+
+ config = build_config(
+ uld_use_hybrid_loss=True,
+ uld_hybrid_matched_weight=0.5,
+ uld_hybrid_unmatched_weight=0.5,
+ )
+ loss_fn = ULDLoss(config, student_tokenizer=smollm_tokenizer, teacher_tokenizer=qwen_tokenizer)
+
+ _assert_alignment_covers_completion(loss_fn, batch, teacher_input_ids, teacher_labels, teacher_byte_offsets)
+
+ torch.manual_seed(1)
+ student_vocab = len(smollm_tokenizer)
+ teacher_vocab = len(qwen_tokenizer)
+ batch_size, seq_len = batch["input_ids"].shape
+ student_logits = torch.randn(batch_size, seq_len, student_vocab)
+ teacher_logits = torch.randn(batch_size, teacher_input_ids.shape[1], teacher_vocab)
+
+ loss = loss_fn(
+ student_logits=student_logits,
+ teacher_logits=teacher_logits,
+ student_labels=batch["labels"],
+ teacher_labels=teacher_labels,
+ student_input_ids=batch["input_ids"],
+ teacher_input_ids=teacher_input_ids,
+ student_byte_offsets=batch["byte_offsets"],
+ teacher_byte_offsets=teacher_byte_offsets,
+ )
+
+ assert torch.isfinite(loss)
+
+
+def build_config(**overrides):
+ base = dict(
+ uld_crossentropy_weight=0.0,
+ uld_distillation_weight=1.0,
+ uld_student_temperature=1.0,
+ uld_teacher_temperature=1.0,
+ uld_skip_student_eos=False,
+ uld_skip_teacher_eos=False,
+ use_extended_uld=True,
+ uld_use_hybrid_loss=False,
+ uld_hybrid_matched_weight=None,
+ uld_hybrid_unmatched_weight=None,
+ beta=0.5,
+ )
+ base.update(overrides)
+ return SimpleNamespace(**base)
+
+
+@pytest.fixture(scope="session")
+def llama_tokenizer():
+ tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-LlamaForCausalLM-3.2")
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+ return tokenizer
+
+
+@pytest.fixture(scope="session")
+def qwen_tokenizer():
+ tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+ return tokenizer
+
+
+@pytest.fixture(scope="session")
+def smollm_tokenizer():
+ tokenizer = AutoTokenizer.from_pretrained("HuggingFaceTB/SmolLM3-3B")
+ if tokenizer.pad_token is None:
+ tokenizer.pad_token = tokenizer.eos_token
+ return tokenizer
+
+
+def encode_prompt_completion(tokenizer, prompt, completion):
+ """Build input_ids, labels, and per-token byte offsets for a (prompt, completion) pair.
+
+ Byte offsets are computed via `encode_with_byte_offsets` on the completion text only, then padded with (0, 0) for
+ prompt positions and a final (content_len, content_len) for the appended EOS — matching the shape produced by
+ DataCollatorForChatML and build_teacher_inputs_from_texts.
+ """
+ prompt_ids = tokenizer(prompt, add_special_tokens=False)["input_ids"]
+ [(enc_ids, enc_offsets)] = encode_with_byte_offsets(
+ tokenizer.backend_tokenizer, [completion], add_special_tokens=False
+ )
+ completion_ids = list(enc_ids)
+ completion_offsets = list(enc_offsets)
+ content_len = len(completion.encode("utf-8"))
+ eos_id = tokenizer.eos_token_id
+ if eos_id is not None:
+ completion_ids = completion_ids + [eos_id]
+ completion_offsets = completion_offsets + [(content_len, content_len)]
+ input_ids = prompt_ids + completion_ids
+ labels = [-100] * len(prompt_ids) + completion_ids
+ byte_offsets = [(0, 0)] * len(prompt_ids) + completion_offsets
+ return input_ids, labels, byte_offsets
+
+
+def pad_tokens(ids, pad_id, target_length):
+ return ids + [pad_id] * (target_length - len(ids))
+
+
+def pad_labels(labels, target_length):
+ return labels + [-100] * (target_length - len(labels))
+
+
+def test_process_completions_to_buffer_left_pads_prompt_ids():
+ class RecordingTokenizer:
+ pad_token_id = 0
+ pad_token = ""
+
+ def batch_decode(self, sequences, skip_special_tokens=False, clean_up_tokenization_spaces=False):
+ del skip_special_tokens, clean_up_tokenization_spaces
+ return [" ".join(str(token) for token in sequence) for sequence in sequences]
+
+ def decode(self, ids, skip_special_tokens=False, clean_up_tokenization_spaces=False):
+ del skip_special_tokens, clean_up_tokenization_spaces
+ return " ".join(str(token) for token in ids)
+
+ trainer = GOLDTrainer.__new__(GOLDTrainer)
+ trainer.accelerator = SimpleNamespace(device=torch.device("cpu"))
+ trainer.processing_class = RecordingTokenizer()
+ trainer.args = SimpleNamespace(max_length=None)
+ trainer.use_uld_loss = False
+ trainer._buffered_inputs = [None]
+ trainer._buffered_text_logs = [None]
+
+ GOLDTrainer._process_completions_to_buffer(
+ trainer,
+ slices=[{"slice": "original"}],
+ on_policy_indices=[0],
+ local_slice_indices=[0, 0],
+ completion_ids=[[31], [41]],
+ prompt_ids_list=[[11], [21, 22]],
+ prompts_text=["short", "longer"],
+ max_completion_length=1,
+ )
+
+ buffered_inputs = trainer._buffered_inputs[0]
+ assert torch.equal(buffered_inputs["input_ids"], torch.tensor([[0, 11, 31], [21, 22, 41]], dtype=torch.long))
+ assert torch.equal(buffered_inputs["attention_mask"], torch.tensor([[0, 1, 1], [1, 1, 1]], dtype=torch.long))
+ assert torch.equal(buffered_inputs["labels"], torch.tensor([[-100, -100, 31], [-100, -100, 41]]))
+
+
+def test_generate_on_policy_for_slices_uses_prompt_attention_mask_for_vllm_prompts():
+ class RecordingVLLMGeneration:
+ def __init__(self):
+ self.prompts = None
+ self.sync_calls = 0
+
+ def sync_weights(self):
+ self.sync_calls += 1
+
+ def generate(self, prompts, images, num_generations):
+ self.prompts = prompts
+ assert images is None
+ assert num_generations == 1
+ return None, [[42]], None, None
+
+ class RecordingTokenizer:
+ pad_token_id = 9
+ pad_token = ""
+
+ def batch_decode(self, sequences, skip_special_tokens=False, clean_up_tokenization_spaces=False):
+ del clean_up_tokenization_spaces
+ decoded = []
+ token_map = {5: "A", 6: "B", 9: ""}
+ for sequence in sequences:
+ tokens = []
+ for token in sequence:
+ token = int(token)
+ if skip_special_tokens and token == 9:
+ continue
+ tokens.append(token_map[token])
+ decoded.append(" ".join(tokens))
+ return decoded
+
+ def decode(self, ids, skip_special_tokens=False, clean_up_tokenization_spaces=False):
+ return self.batch_decode([ids], skip_special_tokens, clean_up_tokenization_spaces)[0]
+
+ captured = {}
+
+ def capture_process_completions(
+ slices,
+ on_policy_indices,
+ local_slice_indices,
+ completion_ids,
+ prompt_ids_list,
+ prompts_text,
+ max_completion_length,
+ ):
+ captured["slices"] = slices
+ captured["on_policy_indices"] = on_policy_indices
+ captured["local_slice_indices"] = local_slice_indices
+ captured["completion_ids"] = completion_ids
+ captured["prompt_ids_list"] = prompt_ids_list
+ captured["prompts_text"] = prompts_text
+ captured["max_completion_length"] = max_completion_length
+
+ trainer = GOLDTrainer.__new__(GOLDTrainer)
+ trainer.accelerator = SimpleNamespace(is_main_process=True)
+ trainer.args = SimpleNamespace(report_to=[])
+ trainer.processing_class = RecordingTokenizer()
+ trainer.use_vllm = True
+ trainer.vllm_generation = RecordingVLLMGeneration()
+ trainer.vllm_sync_frequency = 1
+ trainer._last_vllm_sync_step = -1
+ trainer.state = SimpleNamespace(global_step=0)
+ trainer.num_generations = 1
+ trainer.generation_config = SimpleNamespace(max_new_tokens=1)
+ trainer._process_completions_to_buffer = capture_process_completions
+
+ slices = [
+ {
+ "prompts": torch.tensor([[9, 9, 5, 9, 6]], dtype=torch.long),
+ "prompt_attention_mask": torch.tensor([[0, 0, 1, 1, 1]], dtype=torch.long),
+ }
+ ]
+
+ GOLDTrainer._generate_on_policy_for_slices(trainer, slices, [0])
+
+ assert trainer.vllm_generation.prompts == [[5, 9, 6]]
+ assert trainer.vllm_generation.sync_calls == 1
+ assert captured["completion_ids"] == [[42]]
+ assert captured["prompt_ids_list"] == [[5, 9, 6]]
+ assert captured["prompts_text"] == ["A B"]
+
+
+def test_generate_on_policy_for_slices_reconstructs_prompt_with_special_tokens():
+ class RecordingVLLMGeneration:
+ def __init__(self):
+ self.prompts = None
+ self.sync_calls = 0
+
+ def sync_weights(self):
+ self.sync_calls += 1
+
+ def generate(self, prompts, images, num_generations):
+ self.prompts = prompts
+ assert images is None
+ assert num_generations == 1
+ return None, [[42]], None, None
+
+ class RecordingTokenizer:
+ pad_token_id = 0
+ pad_token = ""
+
+ def __init__(self):
+ self.truncation_side = "right"
+
+ def batch_decode(self, sequences, skip_special_tokens=False, clean_up_tokenization_spaces=False):
+ del clean_up_tokenization_spaces
+ token_map = {0: "", 5: "A", 6: "B", 13: "", 42: "C"}
+ decoded = []
+ for sequence in sequences:
+ tokens = []
+ for token in sequence:
+ token = int(token)
+ if skip_special_tokens and token == 13:
+ continue
+ if token == 0:
+ continue
+ tokens.append(token_map[token])
+ decoded.append(" ".join(tokens))
+ return decoded
+
+ def decode(self, ids, skip_special_tokens=False, clean_up_tokenization_spaces=False):
+ return self.batch_decode([ids], skip_special_tokens, clean_up_tokenization_spaces)[0]
+
+ trainer = GOLDTrainer.__new__(GOLDTrainer)
+ trainer.accelerator = SimpleNamespace(device=torch.device("cpu"), is_main_process=True)
+ trainer.processing_class = RecordingTokenizer()
+ trainer.args = SimpleNamespace(max_length=None, report_to=[])
+ trainer.use_vllm = True
+ trainer.use_uld_loss = False
+ trainer.vllm_generation = RecordingVLLMGeneration()
+ trainer.vllm_sync_frequency = 1
+ trainer._last_vllm_sync_step = -1
+ trainer.state = SimpleNamespace(global_step=0)
+ trainer.num_generations = 1
+ trainer.generation_config = SimpleNamespace(max_new_tokens=1)
+ trainer._buffered_inputs = [None]
+ trainer._buffered_text_logs = [None]
+
+ slices = [
+ {
+ "slice": "original",
+ "prompts": torch.tensor([[0, 0, 5, 13, 6]], dtype=torch.long),
+ "prompt_attention_mask": torch.tensor([[0, 0, 1, 1, 1]], dtype=torch.long),
+ }
+ ]
+
+ GOLDTrainer._generate_on_policy_for_slices(trainer, slices, [0])
+
+ buffered_inputs = trainer._buffered_inputs[0]
+ assert trainer.vllm_generation.prompts == [[5, 13, 6]]
+ assert trainer.vllm_generation.sync_calls == 1
+ assert torch.equal(buffered_inputs["input_ids"], torch.tensor([[5, 13, 6, 42]], dtype=torch.long))
+ assert torch.equal(buffered_inputs["attention_mask"], torch.tensor([[1, 1, 1, 1]], dtype=torch.long))
+ assert torch.equal(buffered_inputs["labels"], torch.tensor([[-100, -100, -100, 42]], dtype=torch.long))
+ assert buffered_inputs["original_prompt_text"] == ["A B"]
+ assert buffered_inputs["original_completion_text"] == ["C"]
+ assert trainer._buffered_text_logs[0] == (["A B"], ["C"])
+
+
+def test_on_policy_prompt_text_reflects_truncated_prompt():
+ """When the prompt overflows max_length - max_completion_length it is truncated before the student sees it.
+ `original_prompt_text` — which the teacher re-encodes — must reflect that truncated prompt, not the full one, so
+ teacher and student score the completion under the same context."""
+
+ class RecordingVLLMGeneration:
+ def __init__(self):
+ self.prompts = None
+
+ def sync_weights(self):
+ pass
+
+ def generate(self, prompts, images, num_generations):
+ self.prompts = prompts
+ return None, [[42]], None, None
+
+ class RecordingTokenizer:
+ pad_token_id = 0
+ pad_token = ""
+
+ def __init__(self):
+ self.truncation_side = "right"
+
+ def batch_decode(self, sequences, skip_special_tokens=False, clean_up_tokenization_spaces=False):
+ del clean_up_tokenization_spaces
+ token_map = {0: "", 5: "A", 6: "B", 13: "", 42: "C"}
+ decoded = []
+ for sequence in sequences:
+ tokens = [token_map[int(t)] for t in sequence if int(t) != 0]
+ decoded.append(" ".join(tokens))
+ return decoded
+
+ def decode(self, ids, skip_special_tokens=False, clean_up_tokenization_spaces=False):
+ return self.batch_decode([ids], skip_special_tokens, clean_up_tokenization_spaces)[0]
+
+ trainer = GOLDTrainer.__new__(GOLDTrainer)
+ trainer.accelerator = SimpleNamespace(device=torch.device("cpu"), is_main_process=True)
+ trainer.processing_class = RecordingTokenizer()
+ trainer.args = SimpleNamespace(max_length=3, report_to=[])
+ trainer.use_vllm = True
+ trainer.use_uld_loss = False
+ trainer.teacher_tokenizer = None
+ trainer.uld_loss_fn = None
+ trainer.vllm_generation = RecordingVLLMGeneration()
+ trainer.vllm_sync_frequency = 1
+ trainer._last_vllm_sync_step = -1
+ trainer.state = SimpleNamespace(global_step=0)
+ trainer.num_generations = 1
+ trainer.generation_config = SimpleNamespace(max_new_tokens=1)
+ trainer._buffered_inputs = [None]
+ trainer._buffered_text_logs = [None]
+
+ slices = [
+ {
+ "prompts": torch.tensor([[0, 0, 5, 13, 6]], dtype=torch.long),
+ "prompt_attention_mask": torch.tensor([[0, 0, 1, 1, 1]], dtype=torch.long),
+ }
+ ]
+
+ GOLDTrainer._generate_on_policy_for_slices(trainer, slices, [0])
+
+ buffered_inputs = trainer._buffered_inputs[0]
+ # prompt_max_length = max_length - max_completion_length = 3 - 1 = 2; right-truncation keeps [5, 13].
+ assert torch.equal(buffered_inputs["input_ids"], torch.tensor([[5, 13, 42]], dtype=torch.long))
+ assert buffered_inputs["original_prompt_text"] == ["A "]
+
+
+def test_gold_trainer_init_defaults_vllm_max_model_length_to_max_length(monkeypatch):
+ captured = {}
+
+ class DummyStudentModel:
+ def __init__(self):
+ config = SimpleNamespace(_name_or_path="student", vocab_size=17)
+ config.get_text_config = lambda: config
+ self.config = config
+ self.generation_config = SimpleNamespace(eos_token_id=2)
+ self.name_or_path = "student"
+
+ class DummyTeacherModel:
+ def __init__(self):
+ self.resized_to = None
+
+ def resize_token_embeddings(self, vocab_size):
+ self.resized_to = vocab_size
+
+ class DummyProcessingClass:
+ pad_token_id = 0
+
+ def fake_sft_init(
+ self,
+ model,
+ args=None,
+ data_collator=None,
+ train_dataset=None,
+ eval_dataset=None,
+ processing_class=None,
+ compute_metrics=None,
+ callbacks=None,
+ optimizers=None,
+ preprocess_logits_for_metrics=None,
+ peft_config=None,
+ ):
+ del data_collator, train_dataset, eval_dataset, compute_metrics, callbacks, optimizers
+ del preprocess_logits_for_metrics, peft_config
+ self.model = model
+ self.args = args
+ self.processing_class = processing_class
+ self.accelerator = SimpleNamespace(
+ device=torch.device("cpu"),
+ num_processes=1,
+ prepare_model=lambda module, evaluation_mode=True: module,
+ )
+ self.is_deepspeed_enabled = False
+ self.is_fsdp_enabled = False
+
+ class CapturingVLLMGeneration:
+ def __init__(self, **kwargs):
+ captured.update(kwargs)
+
+ monkeypatch.setattr(gold_trainer_module.SFTTrainer, "__init__", fake_sft_init)
+ monkeypatch.setattr(gold_trainer_module, "is_vllm_available", lambda: True)
+ monkeypatch.setattr(gold_trainer_module, "VLLMGeneration", CapturingVLLMGeneration)
+
+ args = SimpleNamespace(
+ model_init_kwargs=None,
+ max_length=128,
+ use_liger_kernel=False,
+ teacher_model_init_kwargs=None,
+ use_uld_loss=False,
+ teacher_tokenizer_name_or_path=None,
+ teacher_model_revision=None,
+ disable_dropout=False,
+ lmbda=1.0,
+ beta=0.5,
+ temperature=1.0,
+ top_p=1.0,
+ seq_kd=False,
+ num_generations=1,
+ max_completion_length=16,
+ top_k=0,
+ log_completions=False,
+ log_completions_steps=100,
+ wandb_log_unique_prompts=True,
+ num_completions_to_print=None,
+ per_device_train_batch_size=1,
+ gradient_accumulation_steps=1,
+ use_vllm=True,
+ vllm_mode="colocate",
+ vllm_structured_outputs_regex=None,
+ vllm_server_base_url=None,
+ vllm_server_host="0.0.0.0",
+ vllm_server_port=8001,
+ vllm_group_port=51216,
+ vllm_server_timeout=240.0,
+ vllm_tensor_parallel_size=1,
+ vllm_gpu_memory_utilization=0.2,
+ vllm_max_model_length=None,
+ vllm_enable_sleep_mode=False,
+ vllm_model_impl="vllm",
+ vllm_sync_frequency=1,
+ )
+
+ teacher_model = DummyTeacherModel()
+ GOLDTrainer(
+ model=DummyStudentModel(),
+ teacher_model=teacher_model,
+ args=args,
+ data_collator=object(),
+ processing_class=DummyProcessingClass(),
+ )
+
+ assert teacher_model.resized_to == 17
+ assert captured["max_model_length"] == 128
+
+
+def test_chatml_collator_truncates_keeping_completion_end(llama_tokenizer):
+ """When the rendered chat-template message exceeds max_length, the collator must
+ keep the LAST max_length tokens (the model's recent context), not the first. Also verifies byte_offsets are sliced
+ consistently with input_ids."""
+ long_user = "Please summarize:\n" + ("very long context. " * 200) # well over 512 tokens
+ long_assistant = "summary content goes here. " * 60
+ examples = [
+ {
+ "messages": [
+ {"role": "user", "content": long_user},
+ {"role": "assistant", "content": long_assistant},
+ ]
+ }
+ ]
+
+ max_length = 256
+ collator = DataCollatorForChatML(tokenizer=llama_tokenizer, max_length=max_length)
+ batch = collator(examples)
+
+ # Truncation must produce exactly max_length tokens (no left padding when full)
+ assert batch["input_ids"].shape[1] == max_length
+
+ # The last token of the kept sequence must match the EOS / final assistant token
+ # of the full untruncated tokenization — proving we kept the END of the completion.
+ backend = llama_tokenizer.backend_tokenizer
+ formatted_message = llama_tokenizer.apply_chat_template(
+ examples[0]["messages"], add_generation_prompt=False, tokenize=False
+ )
+ [(full_ids, _)] = encode_with_byte_offsets(backend, [formatted_message], add_special_tokens=False)
+ assert batch["input_ids"][0, -1].item() == full_ids[-1]
+ assert tuple(batch["byte_offsets"][0, -1].tolist())[1] > 0 # last completion-relative offset is non-zero
+
+
+def test_prepared_tokenized_rows_keep_completion_after_truncation(llama_tokenizer):
+ """When a GOLD row's prompt overflows max_length, dataset prep must keep the LAST max_length tokens (the
+ completion end), tracking the prompt/completion boundary via completion_mask so the collator labels the completion
+ instead of masking the whole sequence."""
+ long_user = "Please summarize:\n" + ("very long context. " * 200) # prompt alone overflows max_length
+ assistant = "the short answer"
+ dataset = Dataset.from_dict(
+ {"messages": [[{"role": "user", "content": long_user}, {"role": "assistant", "content": assistant}]]}
+ )
+
+ max_length = 64
+ args = SimpleNamespace(
+ dataset_num_proc=None,
+ dataset_text_field="text",
+ max_length=max_length,
+ packing_strategy="bfd",
+ use_liger_kernel=False,
+ )
+ trainer = GOLDTrainer.__new__(GOLDTrainer)
+ prepared = trainer._prepare_dataset_with_original_text(
+ dataset, llama_tokenizer, args, packing=False, formatting_func=None, dataset_name="train"
+ )
+ row = prepared[0]
+
+ assert len(row["input_ids"]) == max_length # truncated, not dropped
+ assert 1 in row["completion_mask"] # completion survived front-truncation
+
+ # original_prompt_text / original_completion_text must reflect the truncated ids the student kept,
+ # not the pre-truncation strings (otherwise the teacher would re-encode a longer prompt context).
+ completion_start = row["completion_mask"].index(1)
+ decode = partial(llama_tokenizer.decode, skip_special_tokens=False, clean_up_tokenization_spaces=False)
+ assert row["original_prompt_text"] == decode(row["input_ids"][:completion_start])
+ assert row["original_completion_text"] == decode(row["input_ids"][completion_start:])
+
+ collator = DataCollatorForChatML(tokenizer=llama_tokenizer, max_length=max_length)
+ batch = collator([row])
+
+ # The collator labels exactly the tracked completion tokens — never all -100 — and the assistant text survives.
+ completion_ids = [tid for tid, m in zip(row["input_ids"], row["completion_mask"], strict=False) if m == 1]
+ supervised = [label for label in batch["labels"][0].tolist() if label != -100]
+ assert supervised == completion_ids
+ assert assistant in llama_tokenizer.decode(completion_ids)
+
+
+def test_prepared_tokenized_rows_rebase_byte_offsets_when_truncation_eats_into_completion(llama_tokenizer):
+ """When truncation drops the front of the completion (``drop > completion_start``), the kept byte_offsets
+ reference bytes in the original completion text — but ``original_completion_text`` is decoded fresh from the kept
+ ids and starts at byte 0. The kept offsets must be rebased so they match the teacher's re-encoding."""
+ short_prompt = "Q:"
+ long_completion = "word " * 300 # completion alone overflows max_length
+ dataset = Dataset.from_dict({"prompt": [short_prompt], "completion": [long_completion]})
+
+ max_length = 32
+ args = SimpleNamespace(
+ dataset_num_proc=None,
+ dataset_text_field="text",
+ max_length=max_length,
+ packing_strategy="bfd",
+ use_liger_kernel=False,
+ )
+ trainer = GOLDTrainer.__new__(GOLDTrainer)
+ prepared = trainer._prepare_dataset_with_original_text(
+ dataset, llama_tokenizer, args, packing=False, formatting_func=None, dataset_name="train"
+ )
+ row = prepared[0]
+
+ assert len(row["input_ids"]) == max_length
+ # Prompt is so short that truncation ate into the completion: no prompt tokens survive.
+ assert row["completion_mask"] == [1] * max_length
+
+ # First kept completion token must start at byte 0 of the new (truncated) original_completion_text.
+ assert tuple(row["byte_offsets"][0]) == (0, len(b"word "))
+
+
+def test_prepare_dataset_messages_uses_last_assistant_turn(qwen_tokenizer):
+ messages = [
+ {"role": "system", "content": "Be terse."},
+ {"role": "user", "content": "First?"},
+ {"role": "assistant", "content": "One."},
+ {"role": "user", "content": "Second?"},
+ {"role": "assistant", "content": "Two."},
+ ]
+ dataset = Dataset.from_dict({"messages": [messages]})
+ args = SimpleNamespace(
+ dataset_num_proc=None,
+ dataset_text_field="text",
+ max_length=512,
+ packing_strategy="bfd",
+ use_liger_kernel=False,
+ )
+ trainer = GOLDTrainer.__new__(GOLDTrainer)
+
+ prepared = trainer._prepare_dataset_with_original_text(
+ dataset, qwen_tokenizer, args, packing=False, formatting_func=None, dataset_name="train"
+ )
+ row = prepared[0]
+ expected_prompt = qwen_tokenizer.apply_chat_template(messages[:-1], add_generation_prompt=True, tokenize=False)
+ expected_full = qwen_tokenizer.apply_chat_template(messages, add_generation_prompt=False, tokenize=False)
+
+ assert row["original_prompt_text"] == expected_prompt
+ assert row["original_completion_text"] == expected_full[len(expected_prompt) :]
+ assert "One." not in row["original_completion_text"]
+ assert "Two." in row["original_completion_text"]
+
+ completion_ids = [tid for tid, mask in zip(row["input_ids"], row["completion_mask"], strict=True) if mask == 1]
+ decoded_completion = qwen_tokenizer.decode(
+ completion_ids, skip_special_tokens=False, clean_up_tokenization_spaces=False
+ )
+ assert decoded_completion == row["original_completion_text"]
+
+
+def test_alignment_groups_cover_all_tokens(llama_tokenizer, qwen_tokenizer):
+ config = build_config()
+ loss = ULDLoss(config, student_tokenizer=llama_tokenizer, teacher_tokenizer=qwen_tokenizer)
+
+ text = "SmolLM3-3B says hi 😊 to 你好."
+ [(student_ids, student_offs)] = encode_with_byte_offsets(
+ llama_tokenizer.backend_tokenizer, [text], add_special_tokens=False
+ )
+ [(teacher_ids, teacher_offs)] = encode_with_byte_offsets(
+ qwen_tokenizer.backend_tokenizer, [text], add_special_tokens=False
+ )
+
+ student_groups, teacher_groups = loss._align_by_byte_offsets(student_offs, teacher_offs)
+
+ assert len(student_groups) == len(teacher_groups)
+ assert sorted(idx for group in student_groups for idx in group) == list(range(len(student_ids)))
+ assert sorted(idx for group in teacher_groups for idx in group) == list(range(len(teacher_ids)))
+ for student_group, teacher_group in zip(student_groups, teacher_groups, strict=True):
+ student_span = (student_offs[student_group[0]][0], student_offs[student_group[-1]][1])
+ teacher_span = (teacher_offs[teacher_group[0]][0], teacher_offs[teacher_group[-1]][1])
+ assert student_span == teacher_span
+
+
+def test_on_policy_completion_byte_offsets_match_encode_offsets(smollm_tokenizer, qwen_tokenizer):
+ """On-policy offsets are derived from the generated token ids directly (per-token piece byte length, no
+ decode-then-re-encode round-trip). For ByteLevel BPE — the family of every cross-tokenizer pair GOLD targets
+ (SmolLM, Qwen, Llama 3+, …) — those per-token spans match what `encode_with_byte_offsets` produces on the same
+ text, so student and teacher offsets share one byte coordinate system."""
+ trainer = GOLDTrainer.__new__(GOLDTrainer)
+ trainer.use_uld_loss = True
+ trainer.teacher_tokenizer = qwen_tokenizer
+ trainer.uld_loss_fn = SimpleNamespace(use_extended_uld=True)
+ trainer.processing_class = smollm_tokenizer
+
+ completion_text = "hello 你好 😊"
+ [(completion_ids, expected_offsets)] = encode_with_byte_offsets(
+ smollm_tokenizer.backend_tokenizer, [completion_text], add_special_tokens=False
+ )
+ input_ids = [smollm_tokenizer.pad_token_id] + completion_ids
+ labels = [-100] + completion_ids
+ updated_slice = {
+ "input_ids": torch.tensor([input_ids]),
+ "labels": torch.tensor([labels]),
+ }
+
+ trainer._maybe_add_completion_byte_offsets(updated_slice)
+
+ assert [tuple(offset) for offset in updated_slice["byte_offsets"][0, 1:].tolist()] == expected_offsets
+
+
+def test_merge_probabilities_multiplies_split_tokens():
+ config = build_config()
+ # Use simple 3-token vocabulary to validate merging behaviour
+ # probs[0] = P(token | context) at position 0 for all vocab tokens
+ # probs[1] = P(token | context) at position 1 for all vocab tokens
+ probs = torch.tensor([[0.6, 0.3, 0.1], [0.2, 0.5, 0.3]])
+ loss = ULDLoss(config, student_tokenizer=None, teacher_tokenizer=None)
+
+ # token_ids[1] = 1 means the actual token at position 1 is token ID 1
+ # So we should extract P(token_id=1 | ...) = probs[1, 1] = 0.5
+ token_ids = [0, 1] # Actual generated tokens
+
+ merged = loss._merge_probabilities_with_alignment_groups(probs, [[0, 1]], token_ids=token_ids)
+
+ # Expected: P_merged(y) = P(y | context_0) × P(token_1=1 | context_1)
+ # For each vocab token y, multiply marginal prob at pos 0 by scalar conditional prob of actual token at pos 1
+ expected = probs[0] * probs[1, 1] # probs[1, 1] = 0.5
+ # Expected unnormalized: [0.6 * 0.5, 0.3 * 0.5, 0.1 * 0.5] = [0.3, 0.15, 0.05]
+
+ torch.testing.assert_close(merged[0], expected)
+
+
+def test_uldloss_positional_mode_does_not_require_byte_offsets():
+ config = build_config(use_extended_uld=False)
+ loss_fn = ULDLoss(config, student_tokenizer=None, teacher_tokenizer=None)
+
+ student_logits = torch.randn(1, 4, 5)
+ teacher_logits = torch.randn(1, 4, 6)
+ student_labels = torch.tensor([[-100, 1, 2, -100]])
+ teacher_labels = torch.tensor([[-100, 3, 4, -100]])
+ student_input_ids = torch.tensor([[0, 1, 2, 0]])
+ teacher_input_ids = torch.tensor([[0, 3, 4, 0]])
+
+ loss = loss_fn(
+ student_logits=student_logits,
+ teacher_logits=teacher_logits,
+ student_labels=student_labels,
+ teacher_labels=teacher_labels,
+ student_input_ids=student_input_ids,
+ teacher_input_ids=teacher_input_ids,
+ )
+
+ assert torch.isfinite(loss)
+
+
+def test_initialize_vocabulary_mapping_contains_common_tokens(llama_tokenizer, qwen_tokenizer):
+ config = build_config(
+ uld_use_hybrid_loss=True,
+ uld_hybrid_matched_weight=1.0,
+ uld_hybrid_unmatched_weight=0.0,
+ )
+ loss = ULDLoss(config, student_tokenizer=llama_tokenizer, teacher_tokenizer=qwen_tokenizer)
+
+ common_tokens = ["Hello", "world", "-", "ol", "LM", "3", "B"]
+ for token in common_tokens:
+ student_id = llama_tokenizer.convert_tokens_to_ids(token)
+ teacher_id = qwen_tokenizer.convert_tokens_to_ids(token)
+ assert student_id is not None
+ assert teacher_id is not None
+ assert teacher_id in loss._vocab_mapping
+ assert loss._vocab_mapping[teacher_id] == student_id
+ assert teacher_id in loss._teacher_matched_ids
+ assert student_id in loss._student_matched_ids
+
+
+def test_get_start_and_size_answers_skips_prompt_tokens():
+ trainer = ULDLoss.__new__(ULDLoss)
+ trainer.ignore_index = -100
+
+ answers = torch.tensor(
+ [
+ [-100, -100, -100, 10, 20, 30, -100, -100],
+ [-100, 5, 6, 7, -100, -100, -100, -100],
+ [-100, -100, -100, -100, -100, -100, -100, -100],
+ ]
+ )
+
+ starts, sizes = trainer._get_start_and_size_answers(answers)
+
+ assert starts == [3, 1, 0]
+ assert sizes == [3, 3, 0]
+
+
+@pytest.mark.slow
+def test_generate_on_policy_outputs_masks_prompt(llama_tokenizer):
+ trainer = GOLDTrainer.__new__(GOLDTrainer)
+ trainer.processing_class = llama_tokenizer
+
+ prompt_text = "<|begin_of_text|><|start_header_id|>user<|end_header_id|>\nHello?<|eot_id|>"
+ completion_text = "<|start_header_id|>assistant<|end_header_id|>\nHi there!"
+
+ prompt_ids = llama_tokenizer(prompt_text, add_special_tokens=False)["input_ids"]
+ completion_ids = llama_tokenizer(completion_text, add_special_tokens=False)["input_ids"]
+
+ pad_id = llama_tokenizer.pad_token_id
+ pad_width = 3
+ prompt_tensor = torch.full((1, len(prompt_ids) + pad_width), pad_id, dtype=torch.long)
+ prompt_tensor[0, pad_width:] = torch.tensor(prompt_ids, dtype=torch.long)
+ prompt_mask = (prompt_tensor != pad_id).long()
+
+ # model.generate() returns full sequences including left-padding from the input
+ completion_tensor = torch.tensor(completion_ids, dtype=torch.long).unsqueeze(0)
+ generated_sequence = torch.cat([prompt_tensor, completion_tensor], dim=1)
+
+ class DummyModel:
+ def generate(self, input_ids, attention_mask, generation_config, return_dict_in_generate):
+ assert torch.equal(input_ids, prompt_tensor)
+ assert torch.equal(attention_mask, prompt_mask)
+ return SimpleNamespace(sequences=generated_sequence)
+
+ generation_config = SimpleNamespace(max_completion_length=None, temperature=None, top_k=None, top_p=None)
+ new_ids, new_mask, new_labels, prompt_texts, completion_texts = GOLDTrainer.generate_on_policy_outputs(
+ trainer,
+ DummyModel(),
+ {"prompts": prompt_tensor, "prompt_attention_mask": prompt_mask},
+ generation_config,
+ pad_id,
+ )
+
+ assert torch.equal(new_ids, generated_sequence)
+ if pad_id is not None:
+ expected_mask = (generated_sequence != pad_id).long()
+ assert torch.equal(new_mask, expected_mask)
+ else:
+ assert torch.all(new_mask == 1)
+
+ padded_prompt_len = prompt_tensor.shape[1]
+ assert torch.all(new_labels[0, :padded_prompt_len] == -100)
+ assert torch.equal(new_labels[0, padded_prompt_len:], torch.tensor(completion_ids, dtype=torch.long))
+
+ unpadded_prompt_ids = prompt_tensor[0][prompt_mask[0].bool()].tolist()
+ assert prompt_texts[0] == llama_tokenizer.decode(
+ unpadded_prompt_ids, skip_special_tokens=False, clean_up_tokenization_spaces=False
+ )
+ assert completion_texts[0] == llama_tokenizer.decode(
+ completion_ids, skip_special_tokens=False, clean_up_tokenization_spaces=False
+ )
+
+
+@pytest.mark.slow
+def test_generate_on_policy_outputs_masks_prompt_smollm(smollm_tokenizer, openr1_examples):
+ trainer = GOLDTrainer.__new__(GOLDTrainer)
+ trainer.processing_class = smollm_tokenizer
+
+ collator = DataCollatorForChatML(tokenizer=smollm_tokenizer)
+ batch = collator([openr1_examples[0]])
+ batch = {k: v.cpu() if isinstance(v, torch.Tensor) else v for k, v in batch.items()}
+
+ class DummyModel:
+ def generate(self, input_ids, attention_mask, generation_config, return_dict_in_generate):
+ assert torch.equal(input_ids, batch["prompts"])
+ assert torch.equal(attention_mask, batch["prompt_attention_mask"])
+ return SimpleNamespace(sequences=batch["input_ids"])
+
+ generation_config = SimpleNamespace(max_completion_length=None, temperature=None, top_k=None, top_p=None)
+ pad_id = smollm_tokenizer.pad_token_id
+ new_ids, new_mask, new_labels, prompt_texts, completion_texts = GOLDTrainer.generate_on_policy_outputs(
+ trainer,
+ DummyModel(),
+ {"prompts": batch["prompts"], "prompt_attention_mask": batch["prompt_attention_mask"]},
+ generation_config,
+ pad_id,
+ )
+
+ assert torch.equal(new_ids, batch["input_ids"])
+ if pad_id is not None:
+ expected_mask = (batch["input_ids"] != pad_id).long()
+ assert torch.equal(new_mask, expected_mask)
+ else:
+ assert torch.all(new_mask == 1)
+
+ prompt_len = int(batch["prompt_attention_mask"].sum().item())
+ tail_labels = new_labels[0, prompt_len:]
+ expected_tail = batch["input_ids"][0, prompt_len:]
+ active_mask = tail_labels != -100
+ assert torch.all(new_labels[0, :prompt_len] == -100)
+ assert torch.equal(tail_labels[active_mask], expected_tail[active_mask])
+ assert torch.all(tail_labels[~active_mask] == -100)
+
+ prompt_tokens = batch["prompts"][0, batch["prompt_attention_mask"][0].bool()]
+ decoded_prompt = smollm_tokenizer.decode(prompt_tokens.tolist(), skip_special_tokens=False)
+ assert prompt_texts[0] == decoded_prompt
+
+ assistant_completion = openr1_examples[0]["messages"][-1]["content"].strip()
+ assert assistant_completion in completion_texts[0]
+
+
+def test_generalized_jsd_loss_accepts_probability_inputs():
+ student_probs = torch.tensor([[[0.6, 0.3, 0.1]]])
+ teacher_probs = torch.tensor([[[0.5, 0.4, 0.1]]])
+ mixture = 0.5 * (student_probs + teacher_probs)
+ expected = 0.5 * (
+ torch.sum(student_probs * (torch.log(student_probs) - torch.log(mixture)))
+ + torch.sum(teacher_probs * (torch.log(teacher_probs) - torch.log(mixture)))
+ )
+
+ loss = GOLDTrainer.generalized_jsd_loss(
+ student_probs,
+ teacher_probs,
+ beta=0.5,
+ reduction="batchmean",
+ logits_are_probs=True,
+ )
+
+ torch.testing.assert_close(loss, expected)
+
+
+def test_uldloss_handles_llama_student_qwen_teacher_sequence(llama_tokenizer, qwen_tokenizer):
+ config = build_config(
+ uld_use_hybrid_loss=True,
+ uld_hybrid_matched_weight=0.6,
+ uld_hybrid_unmatched_weight=0.4,
+ )
+ loss_fn = ULDLoss(config, student_tokenizer=llama_tokenizer, teacher_tokenizer=qwen_tokenizer)
+
+ prompt = "User: Summarize the difference between llamas and alpacas."
+ completion = "Assistant: Llamas are taller while alpacas have softer wool."
+
+ student_ids, student_labels, student_offsets = encode_prompt_completion(llama_tokenizer, prompt, completion)
+ teacher_ids, teacher_labels, teacher_offsets = encode_prompt_completion(qwen_tokenizer, prompt, completion)
+
+ pad_id_student = llama_tokenizer.pad_token_id
+ pad_id_teacher = qwen_tokenizer.pad_token_id
+ max_length = max(len(student_ids), len(teacher_ids))
+
+ student_ids = pad_tokens(student_ids, pad_id_student, max_length)
+ teacher_ids = pad_tokens(teacher_ids, pad_id_teacher, max_length)
+ student_labels = pad_labels(student_labels, max_length)
+ teacher_labels = pad_labels(teacher_labels, max_length)
+ student_byte_offsets = pad_byte_offsets(student_offsets, max_length, padding_side="right").unsqueeze(0)
+ teacher_byte_offsets = pad_byte_offsets(teacher_offsets, max_length, padding_side="right").unsqueeze(0)
+
+ student_input_ids = torch.tensor([student_ids])
+ teacher_input_ids = torch.tensor([teacher_ids])
+ student_labels = torch.tensor([student_labels])
+ teacher_labels = torch.tensor([teacher_labels])
+
+ student_vocab = len(llama_tokenizer)
+ teacher_vocab = len(qwen_tokenizer)
+
+ student_logits = torch.randn(1, max_length, student_vocab)
+ teacher_logits = torch.randn(1, max_length, teacher_vocab)
+
+ loss = loss_fn(
+ student_logits=student_logits,
+ teacher_logits=teacher_logits,
+ student_labels=student_labels,
+ teacher_labels=teacher_labels,
+ student_input_ids=student_input_ids,
+ teacher_input_ids=teacher_input_ids,
+ student_byte_offsets=student_byte_offsets,
+ teacher_byte_offsets=teacher_byte_offsets,
+ )
+
+ assert torch.isfinite(loss)
+ assert loss.dim() == 0
+ assert loss_fn.last_matched_loss is not None
+ assert loss_fn.last_unmatched_loss is not None
+
+
+def test_uldloss_handles_smollm_student_qwen_teacher_sequence(smollm_tokenizer, qwen_tokenizer):
+ config = build_config(
+ uld_use_hybrid_loss=True,
+ uld_hybrid_matched_weight=0.5,
+ uld_hybrid_unmatched_weight=0.5,
+ )
+ loss_fn = ULDLoss(config, student_tokenizer=smollm_tokenizer, teacher_tokenizer=qwen_tokenizer)
+
+ prompt = "User: Describe SmolLM3 in a sentence."
+ completion = "Assistant: SmolLM3 is a compact yet capable language model."
+
+ student_ids, student_labels, student_offsets = encode_prompt_completion(smollm_tokenizer, prompt, completion)
+ teacher_ids, teacher_labels, teacher_offsets = encode_prompt_completion(qwen_tokenizer, prompt, completion)
+
+ pad_id_student = smollm_tokenizer.pad_token_id
+ pad_id_teacher = qwen_tokenizer.pad_token_id
+ max_length = max(len(student_ids), len(teacher_ids))
+
+ student_ids = pad_tokens(student_ids, pad_id_student, max_length)
+ teacher_ids = pad_tokens(teacher_ids, pad_id_teacher, max_length)
+ student_labels = pad_labels(student_labels, max_length)
+ teacher_labels = pad_labels(teacher_labels, max_length)
+ student_byte_offsets = pad_byte_offsets(student_offsets, max_length, padding_side="right").unsqueeze(0)
+ teacher_byte_offsets = pad_byte_offsets(teacher_offsets, max_length, padding_side="right").unsqueeze(0)
+
+ student_input_ids = torch.tensor([student_ids])
+ teacher_input_ids = torch.tensor([teacher_ids])
+ student_labels = torch.tensor([student_labels])
+ teacher_labels = torch.tensor([teacher_labels])
+
+ student_vocab = len(smollm_tokenizer)
+ teacher_vocab = len(qwen_tokenizer)
+
+ student_logits = torch.randn(1, max_length, student_vocab)
+ teacher_logits = torch.randn(1, max_length, teacher_vocab)
+
+ loss = loss_fn(
+ student_logits=student_logits,
+ teacher_logits=teacher_logits,
+ student_labels=student_labels,
+ teacher_labels=teacher_labels,
+ student_input_ids=student_input_ids,
+ teacher_input_ids=teacher_input_ids,
+ student_byte_offsets=student_byte_offsets,
+ teacher_byte_offsets=teacher_byte_offsets,
+ )
+
+ assert torch.isfinite(loss)
+ assert loss.dim() == 0
+ assert loss_fn.last_matched_loss is not None
+ assert loss_fn.last_unmatched_loss is not None
+
+
+def test_uldloss_hybrid_config_beta_zero(llama_tokenizer, qwen_tokenizer):
+ config = build_config(
+ uld_use_hybrid_loss=True,
+ uld_hybrid_matched_weight=0.0,
+ uld_hybrid_unmatched_weight=1.0,
+ uld_crossentropy_weight=0.0,
+ uld_distillation_weight=1.0,
+ uld_student_temperature=1.0,
+ uld_teacher_temperature=1.0,
+ temperature=1.0,
+ top_p=0.95,
+ top_k=0,
+ lmbda=1.0,
+ beta=0.0,
+ )
+ loss_fn = ULDLoss(config, student_tokenizer=llama_tokenizer, teacher_tokenizer=qwen_tokenizer)
+
+ prompt = "User: Explain how GOLD handles tokenizer mismatches."
+ completion = "Assistant: GOLD merges aligned subwords and applies hybrid ULD loss."
+
+ student_ids, student_labels, student_offsets = encode_prompt_completion(llama_tokenizer, prompt, completion)
+ teacher_ids, teacher_labels, teacher_offsets = encode_prompt_completion(qwen_tokenizer, prompt, completion)
+
+ pad_id_student = llama_tokenizer.pad_token_id
+ pad_id_teacher = qwen_tokenizer.pad_token_id
+ max_length = max(len(student_ids), len(teacher_ids))
+
+ student_ids = pad_tokens(student_ids, pad_id_student, max_length)
+ teacher_ids = pad_tokens(teacher_ids, pad_id_teacher, max_length)
+ student_labels = pad_labels(student_labels, max_length)
+ teacher_labels = pad_labels(teacher_labels, max_length)
+ student_byte_offsets = pad_byte_offsets(student_offsets, max_length, padding_side="right").unsqueeze(0)
+ teacher_byte_offsets = pad_byte_offsets(teacher_offsets, max_length, padding_side="right").unsqueeze(0)
+
+ student_input_ids = torch.tensor([student_ids])
+ teacher_input_ids = torch.tensor([teacher_ids])
+ student_labels = torch.tensor([student_labels])
+ teacher_labels = torch.tensor([teacher_labels])
+
+ student_vocab = len(llama_tokenizer)
+ teacher_vocab = len(qwen_tokenizer)
+ torch.manual_seed(0)
+ student_logits = torch.randn(1, max_length, student_vocab)
+ teacher_logits = torch.randn(1, max_length, teacher_vocab)
+
+ loss = loss_fn(
+ student_logits=student_logits,
+ teacher_logits=teacher_logits,
+ student_labels=student_labels,
+ teacher_labels=teacher_labels,
+ student_input_ids=student_input_ids,
+ teacher_input_ids=teacher_input_ids,
+ student_byte_offsets=student_byte_offsets,
+ teacher_byte_offsets=teacher_byte_offsets,
+ )
+
+ assert torch.isfinite(loss)
+ assert loss.dim() == 0
+ assert loss_fn.last_matched_loss is not None
+ assert loss_fn.last_unmatched_loss is not None
+
+ expected = config.uld_hybrid_unmatched_weight * loss_fn.last_unmatched_loss
+ torch.testing.assert_close(loss, expected, atol=1e-6, rtol=1e-5)
+
+
+class TestGOLDTrainerLoss(TrlTestCase):
+ def setup_method(self):
+ self.model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+ self.tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+ self.tokenizer.pad_token = self.tokenizer.eos_token
+
+ def test_loss_normalizes_by_num_items_in_batch(self):
+ # When `num_items_in_batch` is passed (as under gradient accumulation), the JSD loss must be reduced as
+ # sum / num_items_in_batch rather than the local per-microbatch mean. The batch uses variable-length prompts
+ # to ensure the loss covers every valid completion token instead of slicing by the batch-max prompt width.
+ # See issue #4719. The ULD path has its own normalization and is not covered here.
+ dataset = Dataset.from_dict(
+ {
+ "messages": [
+ [{"role": "user", "content": "Hi"}, {"role": "assistant", "content": "Hello there, how are you?"}],
+ [
+ {"role": "user", "content": "Please explain in detail the theory of general relativity"},
+ {"role": "assistant", "content": "OK"},
+ ],
+ ]
+ }
+ )
+ trainer = GOLDTrainer(
+ model=self.model_id,
+ teacher_model=self.model_id,
+ args=GOLDConfig(
+ output_dir=self.tmp_dir,
+ report_to="none",
+ per_device_train_batch_size=2,
+ max_length=64,
+ max_completion_length=20,
+ use_cpu=True,
+ bf16=False,
+ ),
+ train_dataset=dataset,
+ processing_class=self.tokenizer,
+ )
+
+ # Diverge the teacher from the student so JSD is well above fp noise (else the loss is identically 0).
+ torch.manual_seed(0)
+ with torch.no_grad():
+ for p in trainer.teacher_model.parameters():
+ p.add_(0.5 * torch.randn_like(p))
+
+ device = next(trainer.model.parameters()).device
+ batch = trainer.data_collator([trainer.train_dataset[i] for i in range(2)])
+ batch = {k: v.to(device) for k, v in batch.items() if isinstance(v, torch.Tensor)}
+
+ prompt_width = batch["prompts"].shape[1]
+ old_prompt_width_count = (batch["labels"][:, prompt_width:] != -100).sum()
+ num_valid = (batch["labels"] != -100).sum()
+
+ # Prove this batch exposes the regression: the old prompt-width slice would miss valid completion labels.
+ assert prompt_width > (batch["labels"][0] != -100).nonzero()[0].item()
+ assert num_valid > old_prompt_width_count
+
+ trainer.model.eval()
+ with torch.no_grad():
+ loss_mean = trainer.compute_loss(trainer.model, batch) # num_items_in_batch=None -> local mean
+ loss_global = trainer.compute_loss(trainer.model, batch, num_items_in_batch=num_valid)
+
+ # With num_items_in_batch equal to the local valid-token count, sum/N equals the local mean.
+ torch.testing.assert_close(loss_global, loss_mean, rtol=1e-4, atol=1e-6)
+
+ # Doubling the global count exactly halves the loss (sum / num_items is linear in 1/num_items).
+ loss_double = trainer.compute_loss(trainer.model, batch, num_items_in_batch=num_valid * 2)
+ torch.testing.assert_close(loss_double, loss_mean / 2, rtol=1e-4, atol=1e-6)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_grpo_with_replay_buffer_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_grpo_with_replay_buffer_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..f6edc1c9c6650d5fe37495b5007599d7595b2da7
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_grpo_with_replay_buffer_trainer.py
@@ -0,0 +1,292 @@
+# 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.grpo_with_replay_buffer import (
+ GRPOWithReplayBufferConfig,
+ GRPOWithReplayBufferTrainer,
+ ReplayBuffer,
+)
+
+from ..testing_utils import TrlTestCase
+
+
+@pytest.mark.low_priority
+class TestReplayBuffer:
+ def setup_method(self):
+ self.replay_buffer = ReplayBuffer(max_size=5)
+
+ def test_add(self):
+ # Add elements to the replay buffer
+ scores = [0.5, 0.8, 0.3, 0.9, 0.7]
+ data = [
+ {"id": 1},
+ {"id": 2},
+ {"id": 3},
+ {"id": 4},
+ {"id": 5},
+ ]
+ self.replay_buffer.add(scores, data)
+
+ # Check if the buffer contains the correct number of elements
+ assert len(self.replay_buffer.heap) == 5
+
+ # Check if the buffer maintains the min-heap property
+ heap_scores = [item[0] for item in self.replay_buffer.heap]
+ assert heap_scores[0] == min(heap_scores)
+ assert heap_scores[0] == 0.3
+
+ def test_add_more_than_maxlen(self):
+ # Add elements to the replay buffer
+ scores = [0.5, 0.8, 0.3, 0.9, 0.7, 0.6, 0.4]
+ data = [
+ {"id": 1},
+ {"id": 2},
+ {"id": 3},
+ {"id": 4},
+ {"id": 5},
+ {"id": 6},
+ {"id": 7},
+ ]
+ self.replay_buffer.add(scores, data)
+
+ # Check if the buffer contains the correct number of elements
+ assert len(self.replay_buffer.heap) == 5
+
+ # Check if the buffer maintains the min-heap property
+ heap_scores = [item[0] for item in self.replay_buffer.heap]
+ assert heap_scores[0] == min(heap_scores)
+ assert heap_scores[0] == 0.5 # 0.3 and 0.4 should be removed
+
+ def test_sample(self):
+ # Add elements to the replay buffer
+ scores = [0.5, 0.8, 0.3, 0.9, 0.7]
+ data = [
+ {"id": 1},
+ {"id": 2},
+ {"id": 3},
+ {"id": 4},
+ {"id": 5},
+ ]
+ self.replay_buffer.add(scores, data)
+
+ # Sample elements from the buffer
+ sampled = self.replay_buffer.sample(num_samples=3)
+
+ # Check if the sampled elements are from the buffer
+ assert len(sampled) == 3
+ for item in sampled:
+ assert item in [entry[1] for entry in self.replay_buffer.heap]
+
+
+@pytest.mark.low_priority
+class TestUpdateWithReplayBuffer:
+ def setup_method(self):
+ dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+ config = GRPOWithReplayBufferConfig(
+ replay_buffer_size=5,
+ )
+ self.trainer = GRPOWithReplayBufferTrainer(
+ model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+ reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5",
+ args=config,
+ train_dataset=dataset,
+ )
+ self.trainer.replay_buffer = ReplayBuffer(max_size=5)
+ self.trainer.num_generations = 2
+
+ def _prepopulate_buffer(self, with_pixels=False, with_logprobs=False):
+ scores = [0.1, 0.9]
+ data = [
+ {
+ "prompt_ids": torch.tensor([[100, 101], [102, 103]]),
+ "prompt_mask": torch.ones(2, 2, dtype=torch.long),
+ "completion_ids": torch.tensor([[5, 6], [7, 8]]),
+ "completion_mask": torch.ones(2, 2, dtype=torch.long),
+ "advantages": torch.tensor([[0.5, 0.6]]),
+ **({"pixel_values": torch.randn(2, 3, 224, 224)} if with_pixels else {}),
+ **({"old_per_token_logps": torch.randn(2, 2)} if with_logprobs else {}),
+ },
+ {
+ "prompt_ids": torch.tensor([[104, 105], [106, 107]]),
+ "prompt_mask": torch.ones(2, 2, dtype=torch.long),
+ "completion_ids": torch.tensor([[13, 14], [15, 16]]),
+ "completion_mask": torch.ones(2, 2, dtype=torch.long),
+ "advantages": torch.tensor([[0.8, 0.85]]),
+ **({"pixel_values": torch.randn(2, 3, 224, 224)} if with_pixels else {}),
+ **({"old_per_token_logps": torch.randn(2, 2)} if with_logprobs else {}),
+ },
+ ]
+ self.trainer.replay_buffer.add(scores, data)
+
+ def _make_inputs(self, group_advantages, with_pixels=False, with_logprobs=False):
+ inputs = {
+ "group_advantages": group_advantages,
+ "prompt_ids": torch.tensor([[1, 2], [3, 4], [5, 6], [7, 8]]),
+ "prompt_mask": torch.ones(4, 2, dtype=torch.long),
+ "completion_ids": torch.tensor([[9, 10], [11, 12], [13, 14], [15, 16]]),
+ "completion_mask": torch.ones(4, 2, dtype=torch.long),
+ "forward_kwargs": {"pixel_values": torch.randn(4, 3, 224, 224)} if with_pixels else {},
+ "old_per_token_logps": torch.randn(4, 2) if with_logprobs else None,
+ }
+ inputs["group_std_rewards"] = group_advantages.std(dim=1).expand_as(group_advantages)
+ return inputs
+
+ def test_update_with_replay_buffer_no_variance(self):
+ self._prepopulate_buffer(with_pixels=True, with_logprobs=True)
+ group_advantages = torch.tensor([[0.5, 0.5], [0.8, 0.8]]) # no variance
+ inputs = self._make_inputs(group_advantages, with_pixels=True, with_logprobs=True)
+ original_prompt_ids = inputs["prompt_ids"].clone()
+
+ outputs = self.trainer.update_with_replay_buffer(**inputs, num_items_in_batch=4)
+
+ assert outputs is not None
+ assert "pixel_values" in outputs
+ assert "old_per_token_logps" in outputs
+ assert len(self.trainer.replay_buffer.heap) == 2
+ for pid in outputs["prompt_ids"]:
+ assert pid.tolist() not in original_prompt_ids.tolist()
+
+ def test_update_with_replay_buffer_with_variance(self):
+ self._prepopulate_buffer()
+ group_advantages = torch.tensor([[0.6, 0.4], [0.7, 1.2]]) # has variance
+ inputs = self._make_inputs(group_advantages)
+
+ sampled = self.trainer.update_with_replay_buffer(**inputs, num_items_in_batch=4)
+
+ assert len(self.trainer.replay_buffer.heap) == 4 # grew
+ assert sampled is None
+
+ def test_update_with_mixed_variance(self):
+ self._prepopulate_buffer()
+ group_advantages = torch.tensor([[0.6, 0.6], [0.3, 0.45]]) # one no-variance, one variance
+ inputs = self._make_inputs(group_advantages)
+ original_prompt_ids = inputs["prompt_ids"].clone().view(-1, self.trainer.num_generations, 2).tolist()
+
+ outputs = self.trainer.update_with_replay_buffer(**inputs, num_items_in_batch=4)
+
+ assert len(self.trainer.replay_buffer.heap) == 3 # grew by 1
+ output_prompt_ids = outputs["prompt_ids"].view(-1, self.trainer.num_generations, 2).tolist()
+
+ buffer_ids = [item[1]["prompt_ids"].tolist() for item in self.trainer.replay_buffer.heap]
+ found_from_buffer = any(pid in buffer_ids for pid in output_prompt_ids)
+ found_from_original = any(pid in original_prompt_ids for pid in output_prompt_ids)
+
+ assert found_from_buffer
+ assert found_from_original
+ assert [[1, 2], [3, 4]] not in output_prompt_ids # excluded no-variance group
+
+ def test_update_with_inputs_different_seq_len(self):
+ """
+ Test with inputs where the sequence lengths are different from the prepopulated buffer.
+ """
+ self._prepopulate_buffer()
+ pad_token_id = self.trainer.processing_class.pad_token_id
+ group_advantages = torch.tensor([[0.6, 0.6], [0.3, 0.45]]) # one no-variance, one variance
+ inputs = {
+ "group_advantages": group_advantages,
+ "prompt_ids": torch.tensor(
+ [
+ [1, 2, pad_token_id],
+ [1, 2, pad_token_id],
+ [3, 4, 5],
+ [3, 4, 5],
+ ]
+ ),
+ "prompt_mask": torch.tensor([[1, 1, 0], [1, 1, 0], [1, 1, 1], [1, 1, 1]], dtype=torch.long),
+ "completion_ids": torch.tensor(
+ [
+ [1009, 1010, pad_token_id],
+ [1011, 1012, 1013],
+ [1013, 1014, pad_token_id],
+ [1015, 1016, 1017],
+ ]
+ ),
+ "completion_mask": torch.tensor([[1, 1, 0], [1, 1, 1], [1, 1, 0], [1, 1, 1]], dtype=torch.long),
+ "forward_kwargs": {},
+ }
+ inputs["group_std_rewards"] = group_advantages.std(dim=1).expand_as(group_advantages)
+
+ outputs_after_sampling = self.trainer.update_with_replay_buffer(**inputs, num_items_in_batch=4)
+ # Seq length of current batch should be preserved
+ assert outputs_after_sampling["prompt_ids"].shape[-1] == 3
+ assert len(self.trainer.replay_buffer.heap) == 3
+ output_prompt_ids = outputs_after_sampling["prompt_ids"].view(-1, self.trainer.num_generations, 3).tolist()
+
+ buffered_prompt_completion_ids = [
+ (item[1]["prompt_ids"].tolist(), item[1]["completion_ids"].tolist())
+ for item in self.trainer.replay_buffer.heap
+ ]
+ buffered_prompt_ids, buffered_completion_ids = zip(*buffered_prompt_completion_ids, strict=True)
+
+ # Check for new entry with seq len 3 in buffer
+ assert [[3, 4, 5], [3, 4, 5]] in buffered_prompt_ids # excluded no-variance group
+ assert [
+ [1013, 1014, pad_token_id],
+ [1015, 1016, 1017],
+ ] in buffered_completion_ids # excluded no-variance group
+
+ # Check that sampled outputs contain one group with prompt_ids starting with a pad token
+ assert [
+ [pad_token_id, 101, 102],
+ [pad_token_id, 102, 103],
+ ] in output_prompt_ids or [
+ [pad_token_id, 104, 105],
+ [pad_token_id, 106, 107],
+ ] in output_prompt_ids
+
+
+@pytest.mark.low_priority
+@pytest.mark.parametrize("scale_rewards", ["batch", "group"])
+class TestGRPOWithReplayBufferTrainer(TrlTestCase):
+ def test_train_with_replay_buffer(self, scale_rewards):
+ dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train")
+
+ # Guarantee that some rewards have 0 std
+ def custom_reward_func(completions, **kwargs):
+ if torch.rand(1).item() < 0.25:
+ return [0] * len(completions) # simulate some None rewards
+ else:
+ return torch.rand(len(completions)).tolist()
+
+ training_args = GRPOWithReplayBufferConfig(
+ 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=4, # reduce the batch size to reduce memory usage
+ num_generations=4, # reduce the number of generations to reduce memory usage
+ max_completion_length=8, # reduce the completion length to reduce memory usage
+ replay_buffer_size=8,
+ report_to="none",
+ scale_rewards=scale_rewards,
+ )
+ trainer = GRPOWithReplayBufferTrainer(
+ model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
+ reward_funcs=[custom_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."
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_gspo_token_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_gspo_token_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..25e3179209165d00b27dcb8dd45e483cdf3f4551
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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."
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_harbor.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_harbor.py
new file mode 100644
index 0000000000000000000000000000000000000000..f59497c8062c2755dbe1064408a70d28be37f08c
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_kto_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_kto_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..9ae94950b1ce22fb4a5de5093adc91f9d6490dad
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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"
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_merge_model_callback.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_merge_model_callback.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb63ac40c448dc560f132933984d38ed77eb9fc3
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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}."
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_minillm_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_minillm_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..27b32af550453c05924d0e4e69cb59de715f029f
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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."
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_modeling_value_head.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_modeling_value_head.py
new file mode 100644
index 0000000000000000000000000000000000000000..f69570f093b133f4877feeead5de172f6b5158ac
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_nash_md_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_nash_md_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c5496b3243d65c7ce0eff0474cb13b038175994
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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]
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_online_dpo_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_online_dpo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..355d20f272218df5626468afc89907bfad515e57
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_openreward.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_openreward.py
new file mode 100644
index 0000000000000000000000000000000000000000..0db62ae2ec8b18784551e7e15a4d1e8d5e3048c9
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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. /
+ # sessions.; 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()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_orpo_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_orpo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf07073b06d2329dbc7ac0fdcf656061f7087a08
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_ppo_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_ppo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..45a0e0b60bf5e1ebe7068b7305161aceb6b88755
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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"
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_prm_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_prm_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa139e28da9d5dfc83d09d3dd88fb269530fcbe7
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_sdft_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_sdft_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..32a25c9b70a093458be7a54460f81d539cf922cd
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_sdpo_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_sdpo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..cd8e25373d54f8ae8d3457f109e72b7ba824a58f
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_self_distillation_trainer_behavior.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_self_distillation_trainer_behavior.py
new file mode 100644
index 0000000000000000000000000000000000000000..d581ca26f2e028c838d349cdb56d872b20d78cc9
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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),
+ )
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_ssd_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_ssd_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..077357cca85f2c982202ee3350ca67578374df54
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_tpo_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_tpo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..be9327e0eb13b73401bc7852e3f94e5872d34874
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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."
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_utils.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..b498d19eb05ab00ce809d0c3cb04384a2ab697f9
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_xpo_trainer.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/experimental/test_xpo_trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..2c81e1f7c474c731899321b09405c0ee9c0e6954
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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]
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/invariant/README.md b/tasks/tasksmith-466b1e8e082b/tests/source/tests/invariant/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..6bb9d5e7809b51db3d6d411515dcec6a193810bc
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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 ` 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 .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.
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/invariant/__init__.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/invariant/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d26f4482fe3969b6de2b51bd1f85fc16dad6a65
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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.
+
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/invariant/references/dpo.json b/tasks/tasksmith-466b1e8e082b/tests/source/tests/invariant/references/dpo.json
new file mode 100644
index 0000000000000000000000000000000000000000..b13ed4133bc29f799b936d06624e52c73ddad6cb
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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
+ }
+ ]
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/invariant/references/sft.json b/tasks/tasksmith-466b1e8e082b/tests/source/tests/invariant/references/sft.json
new file mode 100644
index 0000000000000000000000000000000000000000..f0d292b6d878793470222cebc553eb1a39cb7672
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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
+ }
+ ]
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/invariant/references/sft_fa2.json b/tasks/tasksmith-466b1e8e082b/tests/source/tests/invariant/references/sft_fa2.json
new file mode 100644
index 0000000000000000000000000000000000000000..3f01f3223d3c6a7dc342518eb9542098b97f5996
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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
+ }
+ ]
+}
\ No newline at end of file
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/invariant/test_invariant.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/invariant/test_invariant.py
new file mode 100644
index 0000000000000000000000000000000000000000..210923e8ce35170eb0e791419677f2cadfa3d85a
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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 --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
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/tasksmith_behavior.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/tasksmith_behavior.py
new file mode 100644
index 0000000000000000000000000000000000000000..416ec8757bf89f452956b3b3d932c5960d994008
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/tests/source/tests/tasksmith_behavior.py
@@ -0,0 +1,243 @@
+import pytest
+from collections import defaultdict
+
+
+def _build_trainer(tmp_path):
+ from transformers import GPT2Config, GPT2LMHeadModel, PreTrainedTokenizerFast
+ from tokenizers import Tokenizer
+ from tokenizers.models import WordLevel
+ from tokenizers.pre_tokenizers import Whitespace
+ from datasets import Dataset
+ from trl.experimental.kto import KTOConfig, KTOTrainer
+
+ vocab = {"<|endoftext|>": 0, "hello": 1, "world": 2, "foo": 3, "bar": 4}
+ tok = Tokenizer(WordLevel(vocab, unk_token="<|endoftext|>"))
+ tok.pre_tokenizer = Whitespace()
+ tokenizer = PreTrainedTokenizerFast(tokenizer_object=tok)
+ tokenizer.pad_token = "<|endoftext|>"
+ tokenizer.eos_token = "<|endoftext|>"
+
+ cfg = GPT2Config(n_embd=32, n_head=4, n_layer=2, vocab_size=len(vocab))
+ model = GPT2LMHeadModel(cfg)
+ ref_model = GPT2LMHeadModel(cfg)
+
+ dataset = Dataset.from_dict({
+ "prompt": ["hello", "hello", "hello", "hello"],
+ "completion": ["world", "world", "world", "world"],
+ "label": [True, False, True, False],
+ })
+
+ args = KTOConfig(
+ output_dir=str(tmp_path),
+ per_device_train_batch_size=4,
+ max_steps=1,
+ report_to="none",
+ max_length=16,
+ use_cpu=True,
+ )
+
+ trainer = KTOTrainer(
+ model=model,
+ ref_model=ref_model,
+ args=args,
+ processing_class=tokenizer,
+ train_dataset=dataset,
+ )
+ return trainer
+
+
+def test_log_uses_precomputed_margins_not_derived(tmp_path):
+ """log() averages rewards/margins from _metrics; it does NOT overwrite with chosen_avg - rejected_avg."""
+ trainer = _build_trainer(tmp_path)
+
+ # chosen_avg=1.0, rejected_avg=0.4 -> old code would set margins=0.6
+ # pre-computed margin=0.3 (different from 0.6) -> new code must keep 0.3
+ trainer._metrics["train"]["rewards/chosen"] = [1.0]
+ trainer._metrics["train"]["rewards/rejected"] = [0.4]
+ trainer._metrics["train"]["rewards/margins"] = [0.3]
+ trainer.model.train()
+
+ trainer.log({})
+
+ logged = trainer.state.log_history[-1]
+ assert "rewards/margins" in logged, "rewards/margins must be logged"
+ assert abs(logged["rewards/margins"] - 0.3) < 1e-6, (
+ f"Expected 0.3 (averaged from _metrics), got {logged['rewards/margins']}. "
+ "log() must not re-derive margins from chosen/rejected averages."
+ )
+
+
+def test_log_emits_no_margins_when_not_in_metrics(tmp_path):
+ """When _metrics has no rewards/margins, log() must not fabricate one from chosen/rejected."""
+ trainer = _build_trainer(tmp_path)
+
+ trainer._metrics["train"]["rewards/chosen"] = [1.0]
+ trainer._metrics["train"]["rewards/rejected"] = [0.4]
+ # rewards/margins intentionally absent
+ trainer.model.train()
+
+ trainer.log({})
+
+ logged = trainer.state.log_history[-1]
+ assert "rewards/margins" not in logged, (
+ f"rewards/margins must not appear when absent from _metrics; got keys: {list(logged.keys())}"
+ )
+
+
+def test_log_averages_multiple_margin_entries(tmp_path):
+ """When _metrics['rewards/margins'] has multiple per-batch entries, log() averages them."""
+ trainer = _build_trainer(tmp_path)
+
+ trainer._metrics["train"]["rewards/margins"] = [0.2, 0.6]
+ trainer.model.train()
+
+ trainer.log({})
+
+ logged = trainer.state.log_history[-1]
+ assert "rewards/margins" in logged
+ assert abs(logged["rewards/margins"] - 0.4) < 1e-6, (
+ f"Expected average 0.4, got {logged['rewards/margins']}"
+ )
+
+
+def test_full_train_logs_rewards_margins(tmp_path):
+ """End-to-end: after train(), log_history contains rewards/margins."""
+ trainer = _build_trainer(tmp_path)
+ trainer.train()
+ history = trainer.state.log_history
+ all_keys = {k for e in history for k in e}
+ assert "rewards/margins" in all_keys, (
+ f"Expected rewards/margins in log history after training. Keys seen: {all_keys}"
+ )
+ _assert_real_batch_margin_updates(tmp_path / "numeric-batches")
+
+
+# Adjacent behavior: collator pads correctly (passes on both old and new code)
+def test_collator_padding_unchanged():
+ import torch
+ from trl.experimental.kto.kto_trainer import DataCollatorForUnpairedPreference
+
+ 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},
+ ]
+ batch = collator(examples)
+ assert "completion_input_ids" in batch
+ assert batch["completion_input_ids"].shape[0] == 2
+ assert batch["label"] == [True, False]
+
+
+def _assert_real_batch_margin_updates(tmp_path):
+ """Exercise production loss/metric paths; independently calculate batch rewards."""
+ import torch
+ import torch.nn.functional as F
+
+ torch.manual_seed(731)
+ trainer = _build_trainer(tmp_path)
+ # Actual tiny policy/reference forwards remain in both production paths.
+ # A uniform reference makes nonzero rewards deterministic and easy to audit.
+ with torch.no_grad():
+ for parameter in trainer.ref_model.parameters():
+ parameter.zero_()
+ for model in (trainer.model, trainer.ref_model):
+ for module in model.modules():
+ if isinstance(module, torch.nn.Dropout):
+ module.p = 0.0
+ trainer.ref_model.eval()
+
+ cases = [
+ ([[1, 2, 3], [1, 4, 2]], [True, True]),
+ ([[4, 3, 2], [2, 1, 4]], [False, False]),
+ ([[1, 2, 3], [4, 3, 2], [2, 4, 1]], [True, False, True]),
+ ([[3, 1, 4], [2, 4, 3]], [True, True]),
+ ([[1, 3, 4], [4, 2, 1]], [False, False]),
+ ([[3, 2, 4], [4, 1, 3], [2, 3, 1], [1, 4, 2]], [False, True, False, False]),
+ ]
+ kernel_calls = []
+
+ def cpu_kernel_protocol(**kwargs):
+ # Only the optional fused kernel is represented by a CPU protocol double.
+ # Real _compute_loss_liger performs its backbone forwards, count gathers,
+ # per-class reward averaging and margin append around these returned sums.
+ kernel_calls.append(tuple(kwargs['preference_labels'].tolist()))
+ policy = F.linear(kwargs['_input'], kwargs['lin_weight'], kwargs['bias'])
+ reference = F.linear(kwargs['ref_input'], kwargs['ref_weight'], kwargs['ref_bias'])
+ target = kwargs['target']
+ active = target.ne(-100)
+ indices = target.masked_fill(~active, 0).unsqueeze(-1)
+ policy_logps = (policy.log_softmax(-1).gather(-1, indices).squeeze(-1) * active).sum(-1)
+ reference_logps = (reference.log_softmax(-1).gather(-1, indices).squeeze(-1) * active).sum(-1)
+ rewards = trainer.beta * (policy_logps - reference_logps).detach()
+ chosen = kwargs['preference_labels']
+ # Preserve the actual six-value fused-kernel return protocol.
+ return policy_logps.sum() * 0 + 0.125, (
+ policy_logps[chosen].sum(), policy_logps[~chosen].sum(),
+ policy[chosen].sum(), policy[~chosen].sum(),
+ rewards[chosen].sum(), rewards[~chosen].sum(),
+ )
+
+ trainer.liger_loss_fn = cpu_kernel_protocol
+ for use_liger in (False, True):
+ trainer.use_liger_kernel = use_liger
+ for mode in ('train', 'eval'):
+ trainer.model.train(mode == 'train')
+ other_mode = 'eval' if mode == 'train' else 'train'
+ trainer._metrics[mode] = defaultdict(list)
+ trainer._metrics[other_mode] = defaultdict(list, {'sentinel': [123.0]})
+ # Stale entries deliberately disagree with current batch rewards.
+ trainer._metrics[mode]['rewards/chosen'] = [13.0]
+ trainer._metrics[mode]['rewards/rejected'] = [17.0]
+ trainer._metrics[mode]['rewards/margins'] = [42.0]
+ expected_chosen, expected_rejected, expected_margins = [13.0], [17.0], [42.0]
+
+ for rows, labels in cases:
+ ids = torch.tensor(rows, dtype=torch.long, device=trainer.accelerator.device)
+ attention = torch.ones_like(ids)
+ completion = torch.ones_like(ids)
+ completion[:, 0] = 0
+ inputs = {
+ 'completion_input_ids': ids,
+ 'completion_attention_mask': attention,
+ 'completion_mask': completion,
+ 'KL_completion_input_ids': ids,
+ 'KL_completion_attention_mask': attention,
+ 'KL_completion_mask': completion,
+ 'label': labels,
+ }
+ # Independent full-vocabulary reference calculation: no call to
+ # the trainer's reward/log-probability helpers or metric storage.
+ with torch.no_grad():
+ policy_logits = trainer.model(input_ids=ids, attention_mask=attention).logits[:, :-1]
+ reference_logits = trainer.ref_model(input_ids=ids, attention_mask=attention).logits[:, :-1]
+ targets = ids[:, 1:].unsqueeze(-1)
+ policy_values = F.log_softmax(policy_logits, dim=-1).gather(-1, targets).squeeze(-1).sum(-1)
+ reference_values = F.log_softmax(reference_logits, dim=-1).gather(-1, targets).squeeze(-1).sum(-1)
+ rewards = trainer.beta * (policy_values - reference_values)
+ chosen = torch.tensor(labels, dtype=torch.bool, device=ids.device)
+ if chosen.any():
+ expected_chosen.append(rewards[chosen].mean().item())
+ if (~chosen).any():
+ expected_rejected.append(rewards[~chosen].mean().item())
+ if chosen.any() and (~chosen).any():
+ margin = rewards[chosen].mean().item() - rewards[~chosen].mean().item()
+ assert abs(margin) > 1e-7, 'Fixture must discriminate constant-zero margins'
+ expected_margins.append(margin)
+
+ loss = trainer.compute_loss(trainer.model, inputs)
+ assert torch.isfinite(loss).all()
+ metrics = trainer._metrics[mode]
+ assert metrics['rewards/chosen'] == pytest.approx(expected_chosen, abs=1e-6)
+ assert metrics['rewards/rejected'] == pytest.approx(expected_rejected, abs=1e-6)
+ assert metrics.get('rewards/margins', []) == pytest.approx(expected_margins, abs=1e-6)
+ assert dict(trainer._metrics[other_mode]) == {'sentinel': [123.0]}
+
+ # The two real mixed batches must carry different current values;
+ # repeated/stale or accumulated-sum margins cannot pass.
+ assert abs(expected_margins[-1] - expected_margins[-2]) > 1e-7
+ trainer.log({})
+ key = 'eval_rewards/margins' if mode == 'eval' else 'rewards/margins'
+ assert trainer.state.log_history[-1][key] == pytest.approx(
+ sum(expected_margins) / len(expected_margins), abs=1e-6
+ )
+ assert len(kernel_calls) == 2 * len(cases)
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/test_activation_offloading.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/test_activation_offloading.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f2f6a03b4bb78911a64e08db2775094fd896edb
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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"
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/test_callbacks.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/test_callbacks.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef2aa71d81644f11b5963974d3f5f849334a93fd
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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()
diff --git a/tasks/tasksmith-466b1e8e082b/tests/source/tests/test_chat_template_utils.py b/tasks/tasksmith-466b1e8e082b/tests/source/tests/test_chat_template_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7ead60fc3875b460c8c56134dea928f61df067d
--- /dev/null
+++ b/tasks/tasksmith-466b1e8e082b/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 , , ... 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\n\n\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.name + '' }}
+ {%- 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 '