trl v1 (missing hf merges)

trl/SKILL.md

@@ -0,0 +1,443 @@
+---
+name: trl
+description: This skill should be used when users want to train or fine-tune language models using TRL (Transformer Reinforcement Learning) on Hugging Face Jobs infrastructure. Covers SFT, DPO, GRPO, KTO, reward modeling, and PPO training methods, plus GGUF conversion for local deployment. Includes guidance on the TRL Jobs package, UV scripts with PEP 723 format, dataset preparation and validation, hardware selection, cost estimation, Trackio monitoring, Hub authentication, and model persistence. Should be invoked for tasks involving cloud GPU training, GGUF conversion, or when users mention training on Hugging Face Jobs without local GPU setup.
+license: Complete terms in LICENSE.txt
+---
+
+# TRL Training on Hugging Face Jobs
+
+## Overview
+
+Train language models using TRL (Transformer Reinforcement Learning) on fully managed Hugging Face infrastructure. No local GPU setup required—models train on cloud GPUs and results are automatically saved to the Hugging Face Hub.
+
+**TRL provides multiple training methods:**
+- **SFT** (Supervised Fine-Tuning) - Standard instruction tuning
+- **DPO** (Direct Preference Optimization) - Alignment from preference data
+- **GRPO** (Group Relative Policy Optimization) - Online RL training
+- **KTO** (Kahneman-Tversky Optimization) - Preference tuning without paired data
+- **Reward Modeling** - Train reward models for RLHF
+- **PPO** (Proximal Policy Optimization) - Classic RLHF method
+
+**For detailed TRL method documentation:**
+```python
+hf_doc_search("your query", product="trl")
+hf_doc_fetch("https://huggingface.co/docs/trl/sft_trainer")  # SFT
+hf_doc_fetch("https://huggingface.co/docs/trl/dpo_trainer")  # DPO
+# etc.
+```
+
+**See also:** `references/training_methods.md` for method overviews and selection guidance
+
+## When to Use This Skill
+
+Use this skill when users want to:
+- Fine-tune language models on cloud GPUs without local infrastructure
+- Train with TRL methods (SFT, DPO, GRPO, KTO, etc.)
+- Run training jobs on Hugging Face Jobs infrastructure
+- Convert trained models to GGUF for local deployment (Ollama, LM Studio, llama.cpp)
+- Ensure trained models are permanently saved to the Hub
+- Use modern workflows with optimized defaults
+
+## Key Directives
+
+When assisting with training jobs:
+
+1. **Submit jobs directly with inline scripts** - The `script` parameter accepts Python code directly. Do NOT save to local files unless the user explicitly requests it. Pass the script content as a string to `hf_jobs()`.
+
+2. **Always include Trackio** - Every training script should include Trackio for real-time monitoring. Use example scripts in `scripts/` as templates.
+
+3. **Provide job details after submission** - After submitting, provide job ID, monitoring URL, estimated time, and note that the user can request status checks later.
+
+4. **Use example scripts as templates** - Reference `scripts/train_sft_example.py`, `scripts/train_dpo_example.py`, etc. as starting points.
+
+## Prerequisites Checklist
+
+Before starting any training job, verify:
+
+### ✅ **Account & Authentication**
+- Hugging Face Account with [Pro](https://hf.co/pro), [Team](https://hf.co/enterprise), or [Enterprise](https://hf.co/enterprise) plan (Jobs require paid plan)
+- Authenticated login: Check with `mcp__huggingface__hf_whoami()`
+- **HF_TOKEN for Hub Push** ⚠️ CRITICAL - Training environment is ephemeral, must push to Hub or ALL training results are lost
+- Token must have write permissions and is automatically available as `$HF_TOKEN` in job secrets
+
+### ✅ **Dataset Requirements**
+- Dataset must exist on Hub or be loadable via `datasets.load_dataset()`
+- Format must match training method (SFT: "messages"/text/prompt-completion; DPO: chosen/rejected; GRPO: prompt-only)
+- Use `scripts/validate_dataset.py` to verify format or `hf_doc_fetch("https://huggingface.co/docs/trl/dataset_formats")` for complete reference
+- Size appropriate for hardware (Demo: 50-100 examples on t4-small; Production: 1K-10K+ on a10g-large/a100-large)
+
+### ⚠️ **Critical Settings**
+- **Timeout must exceed expected training time** - Default 30min is TOO SHORT for most training. Minimum recommended: 1-2 hours. Job fails and loses all progress if timeout is exceeded.
+- **Hub push must be enabled** - Config: `push_to_hub=True`, `hub_model_id="username/model-name"`; Job: `secrets={"HF_TOKEN": "$HF_TOKEN"}`
+
+## Asynchronous Job Guidelines
+
+**⚠️ IMPORTANT: Training jobs run asynchronously and can take hours**
+
+### Action Required
+
+**When user requests training:**
+1. **Create the training script** with Trackio included (use `scripts/train_sft_example.py` as template)
+2. **Submit immediately** using `hf_jobs()` MCP tool with script content inline - don't save to file unless user requests
+3. **Report submission** with job ID, monitoring URL, and estimated time
+4. **Wait for user** to request status checks - don't poll automatically
+
+### Ground Rules
+- **Jobs run in background** - Submission returns immediately; training continues independently
+- **Initial logs delayed** - Can take 30-60 seconds for logs to appear
+- **User checks status** - Wait for user to request status updates
+- **Avoid polling** - Check logs only on user request; provide monitoring links instead
+
+### After Submission
+
+**Provide to user:**
+- ✅ Job ID and monitoring URL
+- ✅ Expected completion time
+- ✅ Trackio dashboard URL
+- ✅ Note that user can request status checks later
+
+**Example Response:**
+```
+✅ Job submitted successfully!
+
+Job ID: abc123xyz
+Monitor: https://huggingface.co/jobs/username/abc123xyz
+
+Expected time: ~2 hours
+Estimated cost: ~$10
+
+The job is running in the background. Ask me to check status/logs when ready!
+```
+
+## Quick Start: Three Approaches
+
+### Approach 1: TRL Jobs Package (Easiest—Recommended for Beginners)
+
+The `trl-jobs` package provides optimized defaults and one-liner training:
+
+```bash
+# Install (users only, not needed for this environment)
+pip install trl-jobs
+
+# Train with SFT (simplest possible)
+trl-jobs sft \
+  --model_name Qwen/Qwen2.5-0.5B \
+  --dataset_name trl-lib/Capybara
+```
+
+**Benefits:** Pre-configured settings, automatic Trackio integration, automatic Hub push, one-line commands
+**When to use:** User is new to training, standard scenarios, quick experimentation
+**Repository:** https://github.com/huggingface/trl-jobs
+
+### Approach 2: UV Scripts (Recommended for Custom Training)
+
+UV scripts use PEP 723 inline dependencies for clean, self-contained training. **Submit script content directly inline:**
+
+```python
+hf_jobs("uv", {
+    "script": """
+# /// script
+# dependencies = ["trl>=0.12.0", "peft>=0.7.0", "trackio"]
+# ///
+
+from datasets import load_dataset
+from peft import LoraConfig
+from trl import SFTTrainer, SFTConfig
+import trackio
+
+trackio.init(project="my-training", space_id="username/my-dashboard")
+
+dataset = load_dataset("trl-lib/Capybara", split="train")
+
+trainer = SFTTrainer(
+    model="Qwen/Qwen2.5-0.5B",
+    train_dataset=dataset,
+    peft_config=LoraConfig(r=16, lora_alpha=32),
+    args=SFTConfig(
+        output_dir="my-model",
+        push_to_hub=True,
+        hub_model_id="username/my-model",
+        num_train_epochs=3,
+        report_to="trackio",
+    )
+)
+
+trainer.train()
+trainer.push_to_hub()
+trackio.finish()
+""",
+    "flavor": "a10g-large",
+    "timeout": "2h",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+
+**Benefits:** Clean code, dependencies declared inline (PEP 723), no file saving required
+**When to use:** Custom training logic, full control over training
+**See:** `references/uv_scripts_guide.md` for complete UV scripts guide
+
+### Approach 3: TRL Maintained Scripts (Run Official Examples)
+
+TRL provides battle-tested scripts for all methods. Can be run from URLs:
+
+```python
+hf_jobs("uv", {
+    "script": "https://raw.githubusercontent.com/huggingface/trl/main/examples/scripts/sft.py",
+    "script_args": [
+        "--model_name_or_path", "Qwen/Qwen2.5-0.5B",
+        "--dataset_name", "trl-lib/Capybara",
+        "--output_dir", "my-model",
+        "--push_to_hub",
+        "--hub_model_id", "username/my-model"
+    ],
+    "flavor": "a10g-large",
+    "timeout": "2h",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+
+**Benefits:** No code to write, maintained by TRL team, production-tested
+**When to use:** Standard TRL training, quick experiments, don't need custom code
+**Available:** sft.py, dpo.py, grpo.py, kto.py, reward.py, ppo.py - https://github.com/huggingface/trl/tree/main/examples/scripts
+
+### Finding More UV Scripts on Hub
+
+The `uv-scripts` organization provides ready-to-use UV scripts stored as datasets on Hugging Face Hub:
+
+```python
+# Discover available UV script collections
+dataset_search({"author": "uv-scripts", "sort": "downloads", "limit": 20})
+
+# Explore a specific collection
+hub_repo_details(["uv-scripts/classification"], repo_type="dataset", include_readme=True)
+```
+
+**Popular collections:** ocr, classification, synthetic-data, vllm, dataset-creation
+
+## Hardware Selection
+
+| Model Size | Recommended Hardware | Cost (approx/hr) | Use Case |
+|------------|---------------------|------------------|----------|
+| <1B params | `t4-small` | ~$0.75 | Demos, quick tests |
+| 1-3B params | `t4-medium`, `l4x1` | ~$1.50-2.50 | Development |
+| 3-7B params | `a10g-small`, `a10g-large` | ~$3.50-5.00 | Production training |
+| 7-13B params | `a10g-large`, `a100-large` | ~$5-10 | Large models (use LoRA) |
+| 13B+ params | `a100-large`, `a10g-largex2` | ~$10-20 | Very large (use LoRA) |
+
+**GPU Flavors:** cpu-basic/upgrade/performance/xl, t4-small/medium, l4x1/x4, a10g-small/large/largex2/largex4, a100-large, h100/h100x8
+
+**Guidelines:**
+- Use **LoRA/PEFT** for models >7B to reduce memory
+- Multi-GPU automatically handled by TRL/Accelerate
+- Start with smaller hardware for testing
+
+**See:** `references/hardware_guide.md` for detailed specifications
+
+## Critical: Saving Results to Hub
+
+**⚠️ EPHEMERAL ENVIRONMENT—MUST PUSH TO HUB**
+
+The Jobs environment is temporary. All files are deleted when the job ends. If the model isn't pushed to Hub, **ALL TRAINING IS LOST**.
+
+### Required Configuration
+
+**In training script/config:**
+```python
+SFTConfig(
+    push_to_hub=True,
+    hub_model_id="username/model-name",  # MUST specify
+    hub_strategy="every_save",  # Optional: push checkpoints
+)
+```
+
+**In job submission:**
+```python
+{
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}  # Enables authentication
+}
+```
+
+### Verification Checklist
+
+Before submitting:
+- [ ] `push_to_hub=True` set in config
+- [ ] `hub_model_id` includes username/repo-name
+- [ ] `secrets` parameter includes HF_TOKEN
+- [ ] User has write access to target repo
+
+**See:** `references/hub_saving.md` for detailed troubleshooting
+
+## Timeout Management
+
+**⚠️ DEFAULT: 30 MINUTES—TOO SHORT FOR TRAINING**
+
+### Setting Timeouts
+
+```python
+{
+    "timeout": "2h"   # 2 hours (formats: "90m", "2h", "1.5h", or seconds as integer)
+}
+```
+
+### Timeout Guidelines
+
+| Scenario | Recommended | Notes |
+|----------|-------------|-------|
+| Quick demo (50-100 examples) | 10-30 min | Verify setup |
+| Development training | 1-2 hours | Small datasets |
+| Production (3-7B model) | 4-6 hours | Full datasets |
+| Large model with LoRA | 3-6 hours | Depends on dataset |
+
+**Always add 20-30% buffer** for model/dataset loading, checkpoint saving, Hub push operations, and network delays.
+
+**On timeout:** Job killed immediately, all unsaved progress lost, must restart from beginning
+
+## Cost Estimation
+
+**Offer to estimate cost when planning jobs with known parameters.** Use `scripts/estimate_cost.py`:
+
+```bash
+python scripts/estimate_cost.py \
+  --model meta-llama/Llama-2-7b-hf \
+  --dataset trl-lib/Capybara \
+  --hardware a10g-large \
+  --dataset-size 16000 \
+  --epochs 3
+```
+
+Output includes estimated time, cost, recommended timeout (with buffer), and optimization suggestions.
+
+**When to offer:** User planning a job, asks about cost/time, choosing hardware, job will run >1 hour or cost >$5
+
+## Example Training Scripts
+
+**Production-ready templates with all best practices:**
+
+- **`scripts/train_sft_example.py`** - Complete SFT training with Trackio, LoRA, checkpoints
+- **`scripts/train_dpo_example.py`** - DPO training for preference learning
+- **`scripts/train_grpo_example.py`** - GRPO training for online RL
+
+These scripts demonstrate proper Hub saving, Trackio integration, checkpoint management, and optimized parameters. Pass their content inline to `hf_jobs()` or use as templates for custom scripts.
+
+## Monitoring and Tracking
+
+**Trackio** provides real-time metrics visualization. See `references/trackio_guide.md` for complete setup guide.
+
+**Key points:**
+- Add `"trackio"` to dependencies
+- Initialize with `trackio.init(project="name", space_id="username/dashboard")`
+- Configure trainer with `report_to="trackio"`
+- Call `trackio.finish()` after training
+
+**Alternative:** Use `report_to="tensorboard"` for simpler setup (logs saved with model to Hub)
+
+### Check Job Status
+
+```python
+# List all jobs
+hf_jobs("ps")
+
+# Inspect specific job
+hf_jobs("inspect", {"job_id": "your-job-id"})
+
+# View logs
+hf_jobs("logs", {"job_id": "your-job-id"})
+```
+
+**Remember:** Wait for user to request status checks. Avoid polling repeatedly.
+
+## Converting Models to GGUF
+
+After training, convert models to **GGUF format** for use with llama.cpp, Ollama, LM Studio, and other local inference tools.
+
+**What is GGUF:**
+- Optimized for CPU/GPU inference with llama.cpp
+- Supports quantization (4-bit, 5-bit, 8-bit) to reduce model size
+- Compatible with Ollama, LM Studio, Jan, GPT4All, llama.cpp
+- Typically 2-8GB for 7B models (vs 14GB unquantized)
+
+**When to convert:**
+- Running models locally with Ollama or LM Studio
+- Reducing model size with quantization
+- Deploying to edge devices
+- Sharing models for local-first use
+
+**See:** `references/gguf_conversion.md` for complete conversion guide, including production-ready conversion script, quantization options, hardware requirements, usage examples, and troubleshooting.
+
+**Quick conversion:**
+```python
+hf_jobs("uv", {
+    "script": "<see references/gguf_conversion.md for complete script>",
+    "flavor": "a10g-large",
+    "timeout": "45m",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"},
+    "env": {
+        "ADAPTER_MODEL": "username/my-finetuned-model",
+        "BASE_MODEL": "Qwen/Qwen2.5-0.5B",
+        "OUTPUT_REPO": "username/my-model-gguf"
+    }
+})
+```
+
+## Common Training Patterns
+
+See `references/training_patterns.md` for detailed examples including:
+- Quick demo (5-10 minutes)
+- Production with checkpoints
+- Multi-GPU training
+- DPO training (preference learning)
+- GRPO training (online RL)
+
+## Troubleshooting
+
+**Common issues:**
+- Job times out → Increase timeout, reduce epochs/dataset, use smaller model/LoRA
+- Model not saved to Hub → Check push_to_hub=True, hub_model_id, secrets=HF_TOKEN
+- Out of Memory (OOM) → Reduce batch size, increase gradient accumulation, enable LoRA, use larger GPU
+- Dataset format error → Check format docs, validate dataset with `scripts/validate_dataset.py`
+- Import/module errors → Add PEP 723 header with dependencies, verify format
+- Authentication errors → Check `mcp__huggingface__hf_whoami()`, token permissions, secrets parameter
+
+**See:** `references/troubleshooting.md` for complete troubleshooting guide
+
+## Resources
+
+### References (In This Skill)
+- `references/training_methods.md` - Overview of SFT, DPO, GRPO, KTO, PPO, Reward Modeling
+- `references/training_patterns.md` - Common training patterns and examples
+- `references/gguf_conversion.md` - Complete GGUF conversion guide
+- `references/trackio_guide.md` - Trackio monitoring setup
+- `references/uv_scripts_guide.md` - Complete UV scripts guide
+- `references/hardware_guide.md` - Hardware specs and selection
+- `references/hub_saving.md` - Hub authentication troubleshooting
+- `references/troubleshooting.md` - Common issues and solutions
+
+### Scripts (In This Skill)
+- `scripts/train_sft_example.py` - Production SFT template
+- `scripts/train_dpo_example.py` - Production DPO template
+- `scripts/train_grpo_example.py` - Production GRPO template
+- `scripts/validate_dataset.py` - Validate dataset format before training
+- `scripts/estimate_cost.py` - Estimate time and cost (offer when appropriate)
+- `scripts/convert_to_gguf.py` - Complete GGUF conversion script
+
+### External Links
+- [TRL Documentation](https://huggingface.co/docs/trl)
+- [TRL Jobs Training Guide](https://huggingface.co/docs/trl/en/jobs_training)
+- [TRL Jobs Package](https://github.com/huggingface/trl-jobs)
+- [HF Jobs Documentation](https://huggingface.co/docs/huggingface_hub/guides/jobs)
+- [TRL Example Scripts](https://github.com/huggingface/trl/tree/main/examples/scripts)
+- [UV Scripts Guide](https://docs.astral.sh/uv/guides/scripts/)
+- [UV Scripts Organization](https://huggingface.co/uv-scripts)
+
+## Key Takeaways
+
+1. **Submit scripts inline** - The `script` parameter accepts Python code directly; no file saving required unless user requests
+2. **Jobs are asynchronous** - Don't wait/poll; let user check when ready
+3. **Always set timeout** - Default 30 min is insufficient; minimum 1-2 hours recommended
+4. **Always enable Hub push** - Environment is ephemeral; without push, all results lost
+5. **Include Trackio** - Use example scripts as templates for real-time monitoring
+6. **Offer cost estimation** - When parameters are known, use `scripts/estimate_cost.py`
+7. **Three approaches available:** TRL Jobs package (easiest), UV scripts (custom, modern), TRL maintained scripts (official examples)
+8. **Use doc-fetch/doc-search** for latest TRL documentation
+9. **Validate dataset format** before training with `scripts/validate_dataset.py`
+10. **Choose appropriate hardware** for model size; use LoRA for models >7B

trl/references/gguf_conversion.md

@@ -0,0 +1,257 @@
+# GGUF Conversion Guide
+
+After training models with TRL on Hugging Face Jobs, convert them to **GGUF format** for use with llama.cpp, Ollama, LM Studio, and other local inference tools.
+
+**This guide provides production-ready, tested code.** All required dependencies are included in the examples below. No additional troubleshooting should be needed when following the templates exactly.
+
+## What is GGUF?
+
+**GGUF** (GPT-Generated Unified Format):
+- Optimized format for CPU/GPU inference with llama.cpp
+- Supports quantization (4-bit, 5-bit, 8-bit) to reduce model size
+- Compatible with: Ollama, LM Studio, Jan, GPT4All, llama.cpp
+- Typically 2-8GB for 7B models (vs 14GB unquantized)
+
+## When to Convert to GGUF
+
+**Convert when:**
+- Running models locally with Ollama or LM Studio
+- Using CPU-optimized inference
+- Reducing model size with quantization
+- Deploying to edge devices
+- Sharing models for local-first use
+
+## Conversion Process
+
+**The conversion requires:**
+1. **Merge LoRA adapter** with base model (if using PEFT)
+2. **Convert to GGUF** format using llama.cpp
+3. **Quantize** to different bit depths (optional but recommended)
+4. **Upload** GGUF files to Hub
+
+## GGUF Conversion Script Template
+
+See `scripts/convert_to_gguf.py` for a complete, production-ready conversion script.
+
+**Quick conversion job:**
+
+```python
+hf_jobs("uv", {
+    "script": """
+# /// script
+# dependencies = [
+#     "transformers>=4.36.0",
+#     "peft>=0.7.0",
+#     "torch>=2.0.0",
+#     "huggingface_hub>=0.20.0",
+#     "sentencepiece>=0.1.99",
+#     "protobuf>=3.20.0",
+#     "numpy",
+#     "gguf",
+# ]
+# ///
+
+import os
+import torch
+import subprocess
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import PeftModel
+from huggingface_hub import HfApi
+
+# Configuration from environment
+ADAPTER_MODEL = os.environ.get("ADAPTER_MODEL", "username/my-model")
+BASE_MODEL = os.environ.get("BASE_MODEL", "Qwen/Qwen2.5-0.5B")
+OUTPUT_REPO = os.environ.get("OUTPUT_REPO", "username/my-model-gguf")
+
+print("🔄 Converting to GGUF...")
+
+# Step 1: Load and merge
+print("Loading base model...")
+base = AutoModelForCausalLM.from_pretrained(
+    BASE_MODEL,
+    dtype=torch.float16,
+    device_map="auto",
+    trust_remote_code=True
+)
+
+print("Loading adapter...")
+model = PeftModel.from_pretrained(base, ADAPTER_MODEL)
+
+print("Merging...")
+merged = model.merge_and_unload()
+
+# Save merged model
+merged_dir = "/tmp/merged"
+merged.save_pretrained(merged_dir, safe_serialization=True)
+tokenizer = AutoTokenizer.from_pretrained(ADAPTER_MODEL)
+tokenizer.save_pretrained(merged_dir)
+
+# Step 2: Install build tools and clone llama.cpp
+print("Setting up llama.cpp...")
+subprocess.run(["apt-get", "update", "-qq"], check=True, capture_output=True)
+subprocess.run(["apt-get", "install", "-y", "-qq", "build-essential", "cmake"], check=True, capture_output=True)
+
+subprocess.run([
+    "git", "clone",
+    "https://github.com/ggerganov/llama.cpp.git",
+    "/tmp/llama.cpp"
+], check=True)
+
+subprocess.run([
+    "pip", "install", "-r",
+    "/tmp/llama.cpp/requirements.txt"
+], check=True)
+
+# Convert to GGUF
+print("Converting to GGUF...")
+subprocess.run([
+    "python", "/tmp/llama.cpp/convert_hf_to_gguf.py",
+    merged_dir,
+    "--outfile", "/tmp/model-f16.gguf",
+    "--outtype", "f16"
+], check=True)
+
+# Step 3: Build quantization tool with CMake
+print("Building quantization tool...")
+os.makedirs("/tmp/llama.cpp/build", exist_ok=True)
+
+subprocess.run([
+    "cmake", "-B", "/tmp/llama.cpp/build", "-S", "/tmp/llama.cpp",
+    "-DGGML_CUDA=OFF"
+], check=True)
+
+subprocess.run([
+    "cmake", "--build", "/tmp/llama.cpp/build",
+    "--target", "llama-quantize", "-j", "4"
+], check=True)
+
+quantize = "/tmp/llama.cpp/build/bin/llama-quantize"
+quants = ["Q4_K_M", "Q5_K_M", "Q8_0"]
+
+for q in quants:
+    print(f"Creating {q} quantization...")
+    subprocess.run([
+        quantize,
+        "/tmp/model-f16.gguf",
+        f"/tmp/model-{q.lower()}.gguf",
+        q
+    ], check=True)
+
+# Step 4: Upload
+print("Uploading to Hub...")
+api = HfApi()
+api.create_repo(OUTPUT_REPO, repo_type="model", exist_ok=True)
+
+for q in ["f16"] + [q.lower() for q in quants]:
+    api.upload_file(
+        path_or_fileobj=f"/tmp/model-{q}.gguf",
+        path_in_repo=f"model-{q}.gguf",
+        repo_id=OUTPUT_REPO
+    )
+
+print(f"✅ Done! Models at: https://huggingface.co/{OUTPUT_REPO}")
+""",
+    "flavor": "a10g-large",
+    "timeout": "45m",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"},
+    "env": {
+        "ADAPTER_MODEL": "username/my-finetuned-model",
+        "BASE_MODEL": "Qwen/Qwen2.5-0.5B",
+        "OUTPUT_REPO": "username/my-model-gguf"
+    }
+})
+```
+
+## Quantization Options
+
+Common quantization formats (from smallest to largest):
+
+| Format | Size | Quality | Use Case |
+|--------|------|---------|----------|
+| **Q4_K_M** | ~300MB | Good | **Recommended** - best balance of size/quality |
+| **Q5_K_M** | ~350MB | Better | Higher quality, slightly larger |
+| **Q8_0** | ~500MB | Very High | Near-original quality |
+| **F16** | ~1GB | Original | Full precision, largest file |
+
+**Recommendation:** Create Q4_K_M, Q5_K_M, and Q8_0 versions to give users options.
+
+## Hardware Requirements
+
+**For conversion:**
+- Small models (<1B): CPU-basic works, but slow
+- Medium models (1-7B): a10g-large recommended
+- Large models (7B+): a10g-large or a100-large
+
+**Time estimates:**
+- 0.5B model: ~15-25 minutes on A10G
+- 3B model: ~30-45 minutes on A10G
+- 7B model: ~45-60 minutes on A10G
+
+## Using GGUF Models
+
+**GGUF models work on both CPU and GPU.** They're optimized for CPU inference but can also leverage GPU acceleration when available.
+
+**With Ollama (auto-detects GPU):**
+```bash
+# Download GGUF
+huggingface-cli download username/my-model-gguf model-q4_k_m.gguf
+
+# Create Modelfile
+echo "FROM ./model-q4_k_m.gguf" > Modelfile
+
+# Create and run (uses GPU automatically if available)
+ollama create my-model -f Modelfile
+ollama run my-model
+```
+
+**With llama.cpp:**
+```bash
+# CPU only
+./llama-cli -m model-q4_k_m.gguf -p "Your prompt"
+
+# With GPU acceleration (offload 32 layers to GPU)
+./llama-cli -m model-q4_k_m.gguf -ngl 32 -p "Your prompt"
+```
+
+**With LM Studio:**
+1. Download the `.gguf` file
+2. Import into LM Studio
+3. Start chatting
+
+## Best Practices
+
+1. **Always create multiple quantizations** - Give users choice of size/quality
+2. **Include README** - Document which quantization to use for what purpose
+3. **Test the GGUF** - Run a quick inference test before uploading
+4. **Use A10G GPU** - Much faster than CPU for loading/merging large models
+5. **Clean up temp files** - Conversion creates large intermediate files
+
+## Common Issues
+
+**Out of memory during merge:**
+- Use larger GPU (a10g-large or a100-large)
+- Load with `device_map="auto"` for automatic device placement
+- Use `dtype=torch.float16` or `torch.bfloat16` instead of float32
+
+**Conversion fails with architecture error:**
+- Ensure llama.cpp supports the model architecture
+- Check that model uses standard architecture (Qwen, Llama, Mistral, etc.)
+- Some newer models require latest llama.cpp from main branch
+- Check llama.cpp issues/docs for model support
+
+**GGUF file doesn't work with llama.cpp:**
+- Verify llama.cpp version compatibility
+- Download latest llama.cpp: `git clone https://github.com/ggerganov/llama.cpp.git`
+- Rebuild llama.cpp after updating: `make clean && make`
+
+**Quantization fails:**
+- Ensure the `llama-quantize` tool was built: `make llama-quantize`
+- Check that FP16 GGUF was created successfully before quantizing
+- Some quantization types require specific llama.cpp versions
+
+**Upload fails or times out:**
+- Large models (>2GB) may need longer timeout
+- Use `api.upload_file()` with `commit_message` for better tracking
+- Consider uploading quantized versions separately
+
+**See:** `scripts/convert_to_gguf.py` for complete, production-ready conversion script with all dependencies included.

trl/references/hardware_guide.md

@@ -0,0 +1,283 @@
+# Hardware Selection Guide
+
+Choosing the right hardware (flavor) is critical for cost-effective training.
+
+## Available Hardware
+
+### CPU
+- `cpu-basic` - Basic CPU, testing only
+- `cpu-upgrade` - Enhanced CPU
+
+**Use cases:** Dataset validation, preprocessing, testing scripts
+**Not recommended for training:** Too slow for any meaningful training
+
+### GPU Options
+
+| Flavor | GPU | Memory | Use Case | Cost/hour |
+|--------|-----|--------|----------|-----------|
+| `t4-small` | NVIDIA T4 | 16GB | <1B models, demos | ~$0.50-1 |
+| `t4-medium` | NVIDIA T4 | 16GB | 1-3B models, development | ~$1-2 |
+| `l4x1` | NVIDIA L4 | 24GB | 3-7B models, efficient training | ~$2-3 |
+| `l4x4` | 4x NVIDIA L4 | 96GB | Multi-GPU training | ~$8-12 |
+| `a10g-small` | NVIDIA A10G | 24GB | 3-7B models, production | ~$3-4 |
+| `a10g-large` | NVIDIA A10G | 24GB | 7-13B models | ~$4-6 |
+| `a10g-largex2` | 2x NVIDIA A10G | 48GB | Multi-GPU, large models | ~$8-12 |
+| `a10g-largex4` | 4x NVIDIA A10G | 96GB | Multi-GPU, very large models | ~$16-24 |
+| `a100-large` | NVIDIA A100 | 40GB | 13B+ models, fast training | ~$8-12 |
+
+### TPU Options
+
+| Flavor | Type | Use Case |
+|--------|------|----------|
+| `v5e-1x1` | TPU v5e | Small TPU workloads |
+| `v5e-2x2` | 4x TPU v5e | Medium TPU workloads |
+| `v5e-2x4` | 8x TPU v5e | Large TPU workloads |
+
+**Note:** TPUs require TPU-optimized code. Most TRL training uses GPUs.
+
+## Selection Guidelines
+
+### By Model Size
+
+**Tiny Models (<1B parameters)**
+- **Recommended:** `t4-small`
+- **Example:** Qwen2.5-0.5B, TinyLlama
+- **Batch size:** 4-8
+- **Training time:** 1-2 hours for 1K examples
+
+**Small Models (1-3B parameters)**
+- **Recommended:** `t4-medium` or `a10g-small`
+- **Example:** Qwen2.5-1.5B, Phi-2
+- **Batch size:** 2-4
+- **Training time:** 2-4 hours for 10K examples
+
+**Medium Models (3-7B parameters)**
+- **Recommended:** `a10g-small` or `a10g-large`
+- **Example:** Qwen2.5-7B, Mistral-7B
+- **Batch size:** 1-2 (or LoRA with 4-8)
+- **Training time:** 4-8 hours for 10K examples
+
+**Large Models (7-13B parameters)**
+- **Recommended:** `a10g-large` or `a100-large`
+- **Example:** Llama-3-8B, Mixtral-8x7B (with LoRA)
+- **Batch size:** 1 (full fine-tuning) or 2-4 (LoRA)
+- **Training time:** 6-12 hours for 10K examples
+- **Note:** Always use LoRA/PEFT
+
+**Very Large Models (13B+ parameters)**
+- **Recommended:** `a100-large` with LoRA
+- **Example:** Llama-3-13B, Llama-3-70B (LoRA only)
+- **Batch size:** 1-2 with LoRA
+- **Training time:** 8-24 hours for 10K examples
+- **Note:** Full fine-tuning not feasible, use LoRA/PEFT
+
+### By Budget
+
+**Minimal Budget (<$5 total)**
+- Use `t4-small`
+- Train on subset of data (100-500 examples)
+- Limit to 1-2 epochs
+- Use small model (<1B)
+
+**Small Budget ($5-20)**
+- Use `t4-medium` or `a10g-small`
+- Train on 1K-5K examples
+- 2-3 epochs
+- Model up to 3B parameters
+
+**Medium Budget ($20-50)**
+- Use `a10g-small` or `a10g-large`
+- Train on 5K-20K examples
+- 3-5 epochs
+- Model up to 7B parameters
+
+**Large Budget ($50-200)**
+- Use `a10g-large` or `a100-large`
+- Full dataset training
+- Multiple epochs
+- Model up to 13B parameters with LoRA
+
+### By Training Type
+
+**Quick Demo/Experiment**
+- `t4-small`
+- 50-100 examples
+- 5-10 steps
+- ~10-15 minutes
+
+**Development/Iteration**
+- `t4-medium` or `a10g-small`
+- 1K examples
+- 1 epoch
+- ~30-60 minutes
+
+**Production Training**
+- `a10g-large` or `a100-large`
+- Full dataset
+- 3-5 epochs
+- 4-12 hours
+
+**Research/Experimentation**
+- `a100-large`
+- Multiple runs
+- Various hyperparameters
+- Budget for 20-50 hours
+
+## Memory Considerations
+
+### Estimating Memory Requirements
+
+**Full fine-tuning:**
+```
+Memory (GB) ≈ (Model params in billions) × 20
+```
+
+**LoRA fine-tuning:**
+```
+Memory (GB) ≈ (Model params in billions) × 4
+```
+
+**Examples:**
+- Qwen2.5-0.5B full: ~10GB ✅ fits t4-small
+- Qwen2.5-1.5B full: ~30GB ❌ exceeds most GPUs
+- Qwen2.5-1.5B LoRA: ~6GB ✅ fits t4-small
+- Qwen2.5-7B full: ~140GB ❌ not feasible
+- Qwen2.5-7B LoRA: ~28GB ✅ fits a10g-large
+
+### Memory Optimization
+
+If hitting memory limits:
+
+1. **Use LoRA/PEFT**
+   ```python
+   peft_config=LoraConfig(r=16, lora_alpha=32)
+   ```
+
+2. **Reduce batch size**
+   ```python
+   per_device_train_batch_size=1
+   ```
+
+3. **Increase gradient accumulation**
+   ```python
+   gradient_accumulation_steps=8  # Effective batch size = 1×8
+   ```
+
+4. **Enable gradient checkpointing**
+   ```python
+   gradient_checkpointing=True
+   ```
+
+5. **Use mixed precision**
+   ```python
+   bf16=True  # or fp16=True
+   ```
+
+6. **Upgrade to larger GPU**
+   - t4 → a10g → a100
+
+## Cost Estimation
+
+### Formula
+
+```
+Total Cost = (Hours of training) × (Cost per hour)
+```
+
+### Example Calculations
+
+**Quick demo:**
+- Hardware: t4-small ($0.75/hour)
+- Time: 15 minutes (0.25 hours)
+- Cost: $0.19
+
+**Development training:**
+- Hardware: a10g-small ($3.50/hour)
+- Time: 2 hours
+- Cost: $7.00
+
+**Production training:**
+- Hardware: a10g-large ($5/hour)
+- Time: 6 hours
+- Cost: $30.00
+
+**Large model with LoRA:**
+- Hardware: a100-large ($10/hour)
+- Time: 8 hours
+- Cost: $80.00
+
+### Cost Optimization Tips
+
+1. **Start small:** Test on t4-small with subset
+2. **Use LoRA:** 4-5x cheaper than full fine-tuning
+3. **Optimize hyperparameters:** Fewer epochs if possible
+4. **Set appropriate timeout:** Don't waste compute on stalled jobs
+5. **Use checkpointing:** Resume if job fails
+6. **Monitor costs:** Check running jobs regularly
+
+## Multi-GPU Training
+
+TRL automatically handles multi-GPU training with Accelerate when using multi-GPU flavors.
+
+**Multi-GPU flavors:**
+- `l4x4` - 4x L4 GPUs
+- `a10g-largex2` - 2x A10G GPUs
+- `a10g-largex4` - 4x A10G GPUs
+
+**When to use:**
+- Models >13B parameters
+- Need faster training (linear speedup)
+- Large datasets (>50K examples)
+
+**Example:**
+```python
+hf_jobs("uv", {
+    "script": "train.py",
+    "flavor": "a10g-largex2",  # 2 GPUs
+    "timeout": "4h",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+
+No code changes needed—TRL/Accelerate handles distribution automatically.
+
+## Choosing Between Options
+
+### a10g vs a100
+
+**Choose a10g when:**
+- Model <13B parameters
+- Budget conscious
+- Training time not critical
+
+**Choose a100 when:**
+- Model 13B+ parameters
+- Need fastest training
+- Memory requirements high
+- Budget allows
+
+### Single vs Multi-GPU
+
+**Choose single GPU when:**
+- Model <7B parameters
+- Budget constrained
+- Simpler debugging
+
+**Choose multi-GPU when:**
+- Model >13B parameters
+- Need faster training
+- Large batch sizes required
+- Cost-effective for large jobs
+
+## Quick Reference
+
+```python
+# Model size → Hardware selection
+HARDWARE_MAP = {
+    "<1B":     "t4-small",
+    "1-3B":    "a10g-small",
+    "3-7B":    "a10g-large",
+    "7-13B":   "a10g-large (LoRA) or a100-large",
+    ">13B":    "a100-large (LoRA required)"
+}
+```

trl/references/hub_saving.md

@@ -0,0 +1,364 @@
+# Saving Training Results to Hugging Face Hub
+
+**⚠️ CRITICAL:** Training environments are ephemeral. ALL results are lost when a job completes unless pushed to the Hub.
+
+## Why Hub Push is Required
+
+When running on Hugging Face Jobs:
+- Environment is temporary
+- All files deleted on job completion
+- No local disk persistence
+- Cannot access results after job ends
+
+**Without Hub push, training is completely wasted.**
+
+## Required Configuration
+
+### 1. Training Configuration
+
+In your SFTConfig or trainer config:
+
+```python
+SFTConfig(
+    push_to_hub=True,                    # Enable Hub push
+    hub_model_id="username/model-name",   # Target repository
+)
+```
+
+### 2. Job Configuration
+
+When submitting the job:
+
+```python
+hf_jobs("uv", {
+    "script": "train.py",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}  # Provide authentication
+})
+```
+
+**The `$HF_TOKEN` placeholder is automatically replaced with your Hugging Face token.**
+
+## Complete Example
+
+```python
+# train.py
+# /// script
+# dependencies = ["trl"]
+# ///
+
+from trl import SFTTrainer, SFTConfig
+from datasets import load_dataset
+
+dataset = load_dataset("trl-lib/Capybara", split="train")
+
+# Configure with Hub push
+config = SFTConfig(
+    output_dir="my-model",
+    num_train_epochs=3,
+    
+    # ✅ CRITICAL: Hub push configuration
+    push_to_hub=True,
+    hub_model_id="myusername/my-trained-model",
+    
+    # Optional: Push strategy
+    push_to_hub_model_id="myusername/my-trained-model",
+    push_to_hub_organization=None,
+    push_to_hub_token=None,  # Uses environment token
+)
+
+trainer = SFTTrainer(
+    model="Qwen/Qwen2.5-0.5B",
+    train_dataset=dataset,
+    args=config,
+)
+
+trainer.train()
+
+# ✅ Push final model
+trainer.push_to_hub()
+
+print("✅ Model saved to: https://huggingface.co/myusername/my-trained-model")
+```
+
+**Submit with authentication:**
+
+```python
+hf_jobs("uv", {
+    "script": "train.py",
+    "flavor": "a10g-large",
+    "timeout": "2h",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}  # ✅ Required!
+})
+```
+
+## What Gets Saved
+
+When `push_to_hub=True`:
+
+1. **Model weights** - Final trained parameters
+2. **Tokenizer** - Associated tokenizer
+3. **Configuration** - Model config (config.json)
+4. **Training arguments** - Hyperparameters used
+5. **Model card** - Auto-generated documentation
+6. **Checkpoints** - If `save_strategy="steps"` enabled
+
+## Checkpoint Saving
+
+Save intermediate checkpoints during training:
+
+```python
+SFTConfig(
+    output_dir="my-model",
+    push_to_hub=True,
+    hub_model_id="username/my-model",
+    
+    # Checkpoint configuration
+    save_strategy="steps",
+    save_steps=100,              # Save every 100 steps
+    save_total_limit=3,          # Keep only last 3 checkpoints
+)
+```
+
+**Benefits:**
+- Resume training if job fails
+- Compare checkpoint performance
+- Use intermediate models
+
+**Checkpoints are pushed to:** `username/my-model` (same repo)
+
+## Authentication Methods
+
+### Method 1: Automatic Token (Recommended)
+
+```python
+"secrets": {"HF_TOKEN": "$HF_TOKEN"}
+```
+
+Uses your logged-in Hugging Face token automatically.
+
+### Method 2: Explicit Token
+
+```python
+"secrets": {"HF_TOKEN": "hf_abc123..."}
+```
+
+Provide token explicitly (not recommended for security).
+
+### Method 3: Environment Variable
+
+```python
+"env": {"HF_TOKEN": "hf_abc123..."}
+```
+
+Pass as regular environment variable (less secure than secrets).
+
+**Always prefer Method 1** for security and convenience.
+
+## Verification Checklist
+
+Before submitting any training job, verify:
+
+- [ ] `push_to_hub=True` in training config
+- [ ] `hub_model_id` is specified (format: `username/model-name`)
+- [ ] `secrets={"HF_TOKEN": "$HF_TOKEN"}` in job config
+- [ ] Repository name doesn't conflict with existing repos
+- [ ] You have write access to the target namespace
+
+## Repository Setup
+
+### Automatic Creation
+
+If repository doesn't exist, it's created automatically when first pushing.
+
+### Manual Creation
+
+Create repository before training:
+
+```python
+from huggingface_hub import HfApi
+
+api = HfApi()
+api.create_repo(
+    repo_id="username/model-name",
+    repo_type="model",
+    private=False,  # or True for private repo
+)
+```
+
+### Repository Naming
+
+**Valid names:**
+- `username/my-model`
+- `username/model-name`
+- `organization/model-name`
+
+**Invalid names:**
+- `model-name` (missing username)
+- `username/model name` (spaces not allowed)
+- `username/MODEL` (uppercase discouraged)
+
+## Troubleshooting
+
+### Error: 401 Unauthorized
+
+**Cause:** HF_TOKEN not provided or invalid
+
+**Solutions:**
+1. Verify `secrets={"HF_TOKEN": "$HF_TOKEN"}` in job config
+2. Check you're logged in: `huggingface-cli whoami`
+3. Re-login: `huggingface-cli login`
+
+### Error: 403 Forbidden
+
+**Cause:** No write access to repository
+
+**Solutions:**
+1. Check repository namespace matches your username
+2. Verify you're a member of organization (if using org namespace)
+3. Check repository isn't private (if accessing org repo)
+
+### Error: Repository not found
+
+**Cause:** Repository doesn't exist and auto-creation failed
+
+**Solutions:**
+1. Manually create repository first
+2. Check repository name format
+3. Verify namespace exists
+
+### Error: Push failed during training
+
+**Cause:** Network issues or Hub unavailable
+
+**Solutions:**
+1. Training continues but final push fails
+2. Checkpoints may be saved
+3. Re-run push manually after job completes
+
+### Issue: Model saved but not visible
+
+**Possible causes:**
+1. Repository is private—check https://huggingface.co/username
+2. Wrong namespace—verify `hub_model_id` matches login
+3. Push still in progress—wait a few minutes
+
+## Manual Push After Training
+
+If training completes but push fails, push manually:
+
+```python
+from transformers import AutoModel, AutoTokenizer
+
+# Load from local checkpoint
+model = AutoModel.from_pretrained("./output_dir")
+tokenizer = AutoTokenizer.from_pretrained("./output_dir")
+
+# Push to Hub
+model.push_to_hub("username/model-name", token="hf_abc123...")
+tokenizer.push_to_hub("username/model-name", token="hf_abc123...")
+```
+
+**Note:** Only possible if job hasn't completed (files still exist).
+
+## Best Practices
+
+1. **Always enable `push_to_hub=True`**
+2. **Use checkpoint saving** for long training runs
+3. **Verify Hub push** in logs before job completes
+4. **Set appropriate `save_total_limit`** to avoid excessive checkpoints
+5. **Use descriptive repo names** (e.g., `qwen-capybara-sft` not `model1`)
+6. **Add model card** with training details
+7. **Tag models** with relevant tags (e.g., `text-generation`, `fine-tuned`)
+
+## Monitoring Push Progress
+
+Check logs for push progress:
+
+```python
+hf_jobs("logs", {"job_id": "your-job-id"})
+```
+
+**Look for:**
+```
+Pushing model to username/model-name...
+Upload file pytorch_model.bin: 100%
+✅ Model pushed successfully
+```
+
+## Example: Full Production Setup
+
+```python
+# production_train.py
+# /// script
+# dependencies = ["trl>=0.12.0", "peft>=0.7.0"]
+# ///
+
+from datasets import load_dataset
+from peft import LoraConfig
+from trl import SFTTrainer, SFTConfig
+import os
+
+# Verify token is available
+assert "HF_TOKEN" in os.environ, "HF_TOKEN not found in environment!"
+
+# Load dataset
+dataset = load_dataset("trl-lib/Capybara", split="train")
+print(f"✅ Dataset loaded: {len(dataset)} examples")
+
+# Configure with comprehensive Hub settings
+config = SFTConfig(
+    output_dir="qwen-capybara-sft",
+    
+    # Hub configuration
+    push_to_hub=True,
+    hub_model_id="myusername/qwen-capybara-sft",
+    hub_strategy="checkpoint",  # Push checkpoints
+    
+    # Checkpoint configuration
+    save_strategy="steps",
+    save_steps=100,
+    save_total_limit=3,
+    
+    # Training settings
+    num_train_epochs=3,
+    per_device_train_batch_size=4,
+    
+    # Logging
+    logging_steps=10,
+    logging_first_step=True,
+)
+
+# Train with LoRA
+trainer = SFTTrainer(
+    model="Qwen/Qwen2.5-0.5B",
+    train_dataset=dataset,
+    args=config,
+    peft_config=LoraConfig(r=16, lora_alpha=32),
+)
+
+print("🚀 Starting training...")
+trainer.train()
+
+print("💾 Pushing final model to Hub...")
+trainer.push_to_hub()
+
+print("✅ Training complete!")
+print(f"Model available at: https://huggingface.co/myusername/qwen-capybara-sft")
+```
+
+**Submit:**
+
+```python
+hf_jobs("uv", {
+    "script": "production_train.py",
+    "flavor": "a10g-large",
+    "timeout": "6h",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+
+## Key Takeaway
+
+**Without `push_to_hub=True` and `secrets={"HF_TOKEN": "$HF_TOKEN"}`, all training results are permanently lost.**
+
+Always verify both are configured before submitting any training job.

trl/references/trackio_guide.md

@@ -0,0 +1,100 @@
+# Trackio Integration for TRL Training
+
+**Trackio** is a local-first experiment tracking library that provides real-time metrics visualization via a Gradio dashboard.
+
+⚠️ **IMPORTANT**: Trackio is local-first, which means:
+- It runs a dashboard on the machine where training happens
+- For Jobs training, sync to a Hugging Face Space to view metrics
+- Without a Space, metrics are only accessible during the job (then lost)
+
+## Setting Up Trackio for Jobs
+
+**Step 1: Add trackio dependency**
+```python
+# /// script
+# dependencies = [
+#     "trl>=0.12.0",
+#     "trackio",  # Required!
+# ]
+# ///
+```
+
+**Step 2: Create a Trackio Space (one-time setup)**
+
+**Option A: Let Trackio auto-create (Recommended)**
+Pass a `space_id` to `trackio.init()` and Trackio will automatically create the Space if it doesn't exist.
+
+**Option B: Create manually**
+- Create Space via Hub UI at https://huggingface.co/new-space
+- Select Gradio SDK
+- OR use command: `huggingface-cli repo create my-trackio-dashboard --type space --space_sdk gradio`
+
+**Step 3: Initialize Trackio with space_id**
+```python
+import trackio
+
+trackio.init(
+    project="my-training",
+    space_id="username/my-trackio-dashboard",  # CRITICAL for Jobs!
+    config={
+        "model": "Qwen/Qwen2.5-0.5B",
+        "dataset": "trl-lib/Capybara",
+        "learning_rate": 2e-5,
+    }
+)
+```
+
+**Step 4: Configure TRL to use Trackio**
+```python
+SFTConfig(
+    report_to="trackio",
+    # ... other config
+)
+```
+
+**Step 5: Finish tracking**
+```python
+trainer.train()
+trackio.finish()  # Ensures final metrics are synced
+```
+
+## What Trackio Tracks
+
+Trackio automatically logs:
+- ✅ Training loss
+- ✅ Learning rate
+- ✅ GPU utilization
+- ✅ Memory usage
+- ✅ Training throughput
+- ✅ Custom metrics
+
+## How It Works with Jobs
+
+1. **Training runs** → Metrics logged to local SQLite DB
+2. **Every 5 minutes** → Trackio syncs DB to HF Dataset (Parquet)
+3. **Space dashboard** → Reads from Dataset, displays metrics in real-time
+4. **Job completes** → Final sync ensures all metrics persisted
+
+## Viewing the Dashboard
+
+After starting training:
+1. Navigate to the Space: `https://huggingface.co/spaces/username/my-trackio-dashboard`
+2. The Gradio dashboard shows all tracked experiments
+3. Filter by project, compare runs, view charts with smoothing
+
+## Alternative: TensorBoard (Simpler for Jobs)
+
+For simpler setup without needing a Space:
+```python
+SFTConfig(
+    report_to="tensorboard",  # Logs saved with model to Hub
+)
+```
+
+TensorBoard logs are automatically saved with the model and viewable via TensorBoard locally after downloading.
+
+## Recommendation
+
+- **Trackio**: Best for real-time monitoring during long training runs
+- **TensorBoard**: Best for post-training analysis, simpler setup
+- **Weights & Biases**: Best for team collaboration, requires account

trl/references/training_methods.md

@@ -0,0 +1,172 @@
+# TRL Training Methods Overview
+
+TRL (Transformer Reinforcement Learning) provides multiple training methods for fine-tuning and aligning language models. This reference provides a brief overview of each method.
+
+## Supervised Fine-Tuning (SFT)
+
+**What it is:** Standard instruction tuning with supervised learning on demonstration data.
+
+**When to use:**
+- Initial fine-tuning of base models on task-specific data
+- Teaching new capabilities or domains
+- Most common starting point for fine-tuning
+
+**Dataset format:** Conversational format with "messages" field, OR text field, OR prompt/completion pairs
+
+**Example:**
+```python
+from trl import SFTTrainer, SFTConfig
+
+trainer = SFTTrainer(
+    model="Qwen/Qwen2.5-0.5B",
+    train_dataset=dataset,
+    args=SFTConfig(
+        output_dir="my-model",
+        push_to_hub=True,
+        hub_model_id="username/my-model",
+    )
+)
+trainer.train()
+```
+
+**Documentation:** `hf_doc_fetch("https://huggingface.co/docs/trl/sft_trainer")`
+
+## Direct Preference Optimization (DPO)
+
+**What it is:** Alignment method that trains directly on preference pairs (chosen vs rejected responses) without requiring a reward model.
+
+**When to use:**
+- Aligning models to human preferences
+- Improving response quality after SFT
+- Have paired preference data (chosen/rejected responses)
+
+**Dataset format:** Preference pairs with "chosen" and "rejected" fields
+
+**Example:**
+```python
+from trl import DPOTrainer, DPOConfig
+
+trainer = DPOTrainer(
+    model="Qwen/Qwen2.5-0.5B-Instruct",  # Use instruct model
+    train_dataset=dataset,
+    args=DPOConfig(
+        output_dir="dpo-model",
+        beta=0.1,  # KL penalty coefficient
+    )
+)
+trainer.train()
+```
+
+**Documentation:** `hf_doc_fetch("https://huggingface.co/docs/trl/dpo_trainer")`
+
+## Group Relative Policy Optimization (GRPO)
+
+**What it is:** Online RL method that optimizes relative to group performance, useful for tasks with verifiable rewards.
+
+**When to use:**
+- Tasks with automatic reward signals (code execution, math verification)
+- Online learning scenarios
+- When DPO offline data is insufficient
+
+**Dataset format:** Prompt-only format (model generates responses, reward computed online)
+
+**Example:**
+```python
+# Use TRL maintained script
+hf_jobs("uv", {
+    "script": "https://raw.githubusercontent.com/huggingface/trl/main/examples/scripts/grpo.py",
+    "script_args": [
+        "--model_name_or_path", "Qwen/Qwen2.5-0.5B-Instruct",
+        "--dataset_name", "trl-lib/math_shepherd",
+        "--output_dir", "grpo-model"
+    ],
+    "flavor": "a10g-large",
+    "timeout": "4h",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+
+**Documentation:** `hf_doc_fetch("https://huggingface.co/docs/trl/grpo_trainer")`
+
+## Kahneman-Tversky Optimization (KTO)
+
+**What it is:** Preference tuning without paired data - uses independent positive/negative examples.
+
+**When to use:**
+- Have preference data but not paired comparisons
+- Simpler data collection than DPO
+- Want to incorporate human feedback without explicit pairs
+
+**Dataset format:** Examples with binary labels (desirable/undesirable) but not paired
+
+**Documentation:** `hf_doc_fetch("https://huggingface.co/docs/trl/kto_trainer")`
+
+## Reward Modeling
+
+**What it is:** Train a reward model to score responses, used as a component in RLHF pipelines.
+
+**When to use:**
+- Building RLHF pipeline
+- Need automatic quality scoring
+- Creating reward signals for PPO training
+
+**Dataset format:** Preference pairs with "chosen" and "rejected" responses
+
+**Documentation:** `hf_doc_fetch("https://huggingface.co/docs/trl/reward_trainer")`
+
+## Proximal Policy Optimization (PPO)
+
+**What it is:** Classic RLHF method using a reward model to guide policy optimization.
+
+**When to use:**
+- Full RLHF pipeline
+- Have trained reward model
+- Need fine-grained control over optimization
+
+**Requirements:** Pre-trained reward model
+
+**Note:** PPO is more complex than DPO. For most use cases, start with DPO.
+
+**Documentation:** `hf_doc_fetch("https://huggingface.co/docs/trl/ppo_trainer")`
+
+## Method Selection Guide
+
+| Method | Complexity | Data Required | Use Case |
+|--------|-----------|---------------|----------|
+| **SFT** | Low | Demonstrations | Initial fine-tuning |
+| **DPO** | Medium | Paired preferences | Post-SFT alignment |
+| **GRPO** | Medium | Prompts + reward fn | Online RL with automatic rewards |
+| **KTO** | Medium | Unpaired preferences | Alignment with simpler data |
+| **Reward** | Medium | Paired preferences | Building RLHF pipeline |
+| **PPO** | High | Demonstrations + reward model | Full RLHF |
+
+## Recommended Pipeline
+
+**For most use cases:**
+1. **Start with SFT** - Fine-tune base model on task data
+2. **Follow with DPO** - Align to preferences using paired data
+3. **Optional: GGUF conversion** - Deploy for local inference
+
+**For advanced RL scenarios:**
+1. **Start with SFT** - Fine-tune base model
+2. **Train reward model** - On preference data
+3. **Apply GRPO or PPO** - Online RL with reward model
+
+## Dataset Format Reference
+
+For complete dataset format specifications, use:
+```python
+hf_doc_fetch("https://huggingface.co/docs/trl/dataset_formats")
+```
+
+Or validate your dataset:
+```python
+# See scripts/validate_dataset.py
+```
+
+## See Also
+
+- `references/training_patterns.md` - Common training patterns and examples
+- `scripts/train_sft_example.py` - Complete SFT template
+- `scripts/train_dpo_example.py` - Complete DPO template
+- `scripts/validate_dataset.py` - Dataset format validation tool

trl/references/training_patterns.md

@@ -0,0 +1,194 @@
+# Common Training Patterns
+
+This guide provides common training patterns and use cases for TRL on Hugging Face Jobs.
+
+## Quick Demo (5-10 minutes)
+
+Test setup with minimal training:
+
+```python
+hf_jobs("uv", {
+    "script": "https://raw.githubusercontent.com/huggingface/trl/main/examples/scripts/sft.py",
+    "script_args": [
+        "--model_name_or_path", "Qwen/Qwen2.5-0.5B",
+        "--dataset_name", "trl-lib/Capybara",
+        "--dataset_train_split", "train[:50]",  # Only 50 examples
+        "--max_steps", "10",
+        "--output_dir", "demo",
+        "--push_to_hub",
+        "--hub_model_id", "username/demo"
+    ],
+    "flavor": "t4-small",
+    "timeout": "15m",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+
+**Note:** The TRL maintained script above doesn't include Trackio. For production training with monitoring, see `scripts/train_sft_example.py` for a complete template with Trackio integration.
+
+## Production with Checkpoints
+
+Full training with intermediate saves. Use this pattern for long training runs where you want to save progress:
+
+```python
+hf_jobs("uv", {
+    "script": """
+# /// script
+# dependencies = ["trl>=0.12.0", "peft>=0.7.0", "trackio"]
+# ///
+
+from datasets import load_dataset
+from peft import LoraConfig
+from trl import SFTTrainer, SFTConfig
+import trackio
+
+trackio.init(project="production-training", space_id="username/my-dashboard")
+
+dataset = load_dataset("trl-lib/Capybara", split="train")
+
+config = SFTConfig(
+    output_dir="my-model",
+    push_to_hub=True,
+    hub_model_id="username/my-model",
+    hub_strategy="every_save",  # Push each checkpoint
+    save_strategy="steps",
+    save_steps=100,
+    save_total_limit=3,
+    num_train_epochs=3,
+    report_to="trackio",
+)
+
+trainer = SFTTrainer(
+    model="Qwen/Qwen2.5-0.5B",
+    train_dataset=dataset,
+    args=config,
+    peft_config=LoraConfig(r=16, lora_alpha=32),
+)
+
+trainer.train()
+trainer.push_to_hub()
+trackio.finish()
+""",
+    "flavor": "a10g-large",
+    "timeout": "6h",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+
+## Multi-GPU Training
+
+Automatic distributed training across multiple GPUs. TRL/Accelerate handles distribution automatically:
+
+```python
+hf_jobs("uv", {
+    "script": """
+# Your training script here (same as single GPU)
+# No changes needed - Accelerate detects multiple GPUs
+""",
+    "flavor": "a10g-largex2",  # 2x A10G GPUs
+    "timeout": "4h",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+
+**Tips for multi-GPU:**
+- No code changes needed
+- Use `per_device_train_batch_size` (per GPU, not total)
+- Effective batch size = `per_device_train_batch_size` × `num_gpus` × `gradient_accumulation_steps`
+- Monitor GPU utilization to ensure both GPUs are being used
+
+## DPO Training (Preference Learning)
+
+Train with preference data for alignment:
+
+```python
+hf_jobs("uv", {
+    "script": """
+# /// script
+# dependencies = ["trl>=0.12.0", "trackio"]
+# ///
+
+from datasets import load_dataset
+from trl import DPOTrainer, DPOConfig
+import trackio
+
+trackio.init(project="dpo-training", space_id="username/my-dashboard")
+
+dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
+
+config = DPOConfig(
+    output_dir="dpo-model",
+    push_to_hub=True,
+    hub_model_id="username/dpo-model",
+    num_train_epochs=1,
+    beta=0.1,  # KL penalty coefficient
+    report_to="trackio",
+)
+
+trainer = DPOTrainer(
+    model="Qwen/Qwen2.5-0.5B-Instruct",  # Use instruct model as base
+    train_dataset=dataset,
+    args=config,
+)
+
+trainer.train()
+trainer.push_to_hub()
+trackio.finish()
+""",
+    "flavor": "a10g-large",
+    "timeout": "3h",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+
+**For DPO documentation:** Use `hf_doc_fetch("https://huggingface.co/docs/trl/dpo_trainer")`
+
+## GRPO Training (Online RL)
+
+Group Relative Policy Optimization for online reinforcement learning:
+
+```python
+hf_jobs("uv", {
+    "script": "https://raw.githubusercontent.com/huggingface/trl/main/examples/scripts/grpo.py",
+    "script_args": [
+        "--model_name_or_path", "Qwen/Qwen2.5-0.5B-Instruct",
+        "--dataset_name", "trl-lib/math_shepherd",
+        "--output_dir", "grpo-model",
+        "--push_to_hub",
+        "--hub_model_id", "username/grpo-model"
+    ],
+    "flavor": "a10g-large",
+    "timeout": "4h",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+
+**For GRPO documentation:** Use `hf_doc_fetch("https://huggingface.co/docs/trl/grpo_trainer")`
+
+## Pattern Selection Guide
+
+| Use Case | Pattern | Hardware | Time |
+|----------|---------|----------|------|
+| Test setup | Quick Demo | t4-small | 5-10 min |
+| Small dataset (<1K) | Production w/ Checkpoints | t4-medium | 30-60 min |
+| Medium dataset (1-10K) | Production w/ Checkpoints | a10g-large | 2-6 hours |
+| Large dataset (>10K) | Multi-GPU | a10g-largex2 | 4-12 hours |
+| Preference learning | DPO Training | a10g-large | 2-4 hours |
+| Online RL | GRPO Training | a10g-large | 3-6 hours |
+
+## Best Practices
+
+1. **Always start with Quick Demo** - Verify setup before long runs
+2. **Use checkpoints for runs >1 hour** - Protect against failures
+3. **Enable Trackio** - Monitor progress in real-time
+4. **Add 20-30% buffer to timeout** - Account for loading/saving overhead
+5. **Test with small dataset slice first** - Use `"train[:100]"` to verify code
+6. **Use multi-GPU for large models** - 7B+ models benefit significantly
+
+## See Also
+
+- `scripts/train_sft_example.py` - Complete SFT template with Trackio
+- `scripts/train_dpo_example.py` - Complete DPO template
+- `scripts/train_grpo_example.py` - Complete GRPO template
+- `references/hardware_guide.md` - Detailed hardware specifications
+- `references/training_methods.md` - Overview of all TRL training methods

trl/references/troubleshooting.md

@@ -0,0 +1,212 @@
+# Troubleshooting TRL Training Jobs
+
+Common issues and solutions when training with TRL on Hugging Face Jobs.
+
+## Job Times Out
+
+**Problem:** Job terminates before training completes, all progress lost.
+
+**Solutions:**
+- Increase timeout parameter (e.g., `"timeout": "4h"`)
+- Reduce `num_train_epochs` or use smaller dataset slice
+- Use smaller model or enable LoRA/PEFT to speed up training
+- Add 20-30% buffer to estimated time for loading/saving overhead
+
+**Prevention:**
+- Always start with a quick demo run to estimate timing
+- Use `scripts/estimate_cost.py` to get time estimates
+- Monitor first runs closely via Trackio or logs
+
+## Model Not Saved to Hub
+
+**Problem:** Training completes but model doesn't appear on Hub - all work lost.
+
+**Check:**
+- [ ] `push_to_hub=True` in training config
+- [ ] `hub_model_id` specified with username (e.g., `"username/model-name"`)
+- [ ] `secrets={"HF_TOKEN": "$HF_TOKEN"}` in job submission
+- [ ] User has write access to target repo
+- [ ] Token has write permissions (check at https://huggingface.co/settings/tokens)
+- [ ] Training script calls `trainer.push_to_hub()` at the end
+
+**See:** `references/hub_saving.md` for detailed Hub authentication troubleshooting
+
+## Out of Memory (OOM)
+
+**Problem:** Job fails with CUDA out of memory error.
+
+**Solutions (in order of preference):**
+1. **Reduce batch size:** Lower `per_device_train_batch_size` (try 4 → 2 → 1)
+2. **Increase gradient accumulation:** Raise `gradient_accumulation_steps` to maintain effective batch size
+3. **Enable LoRA/PEFT:** Use `peft_config=LoraConfig(r=16, lora_alpha=32)` to train adapters only
+4. **Use larger GPU:** Switch from `t4-medium` → `a10g-large` → `a100-large`
+5. **Enable gradient checkpointing:** Set `gradient_checkpointing=True` in config (slower but saves memory)
+6. **Use smaller model:** Try a smaller variant (e.g., 0.5B instead of 3B)
+
+**Memory guidelines:**
+- T4 (16GB): <1B models with LoRA
+- A10G (24GB): 1-3B models with LoRA, <1B full fine-tune
+- A100 (40GB/80GB): 7B+ models with LoRA, 3B full fine-tune
+
+## Dataset Format Error
+
+**Problem:** Training fails with dataset format errors or missing fields.
+
+**Solutions:**
+1. **Check format documentation:**
+   ```python
+   hf_doc_fetch("https://huggingface.co/docs/trl/dataset_formats")
+   ```
+
+2. **Validate dataset before training:**
+   ```bash
+   python scripts/validate_dataset.py <dataset-name> <method>
+   # e.g., python scripts/validate_dataset.py trl-lib/Capybara sft
+   ```
+
+3. **Verify field names:**
+   - **SFT:** Needs "messages" field (conversational), OR "text" field, OR "prompt"/"completion"
+   - **DPO:** Needs "chosen" and "rejected" fields
+   - **GRPO:** Needs prompt-only format
+
+4. **Check dataset split:**
+   - Ensure split exists (e.g., `split="train"`)
+   - Preview dataset: `load_dataset("name", split="train[:5]")`
+
+## Import/Module Errors
+
+**Problem:** Job fails with "ModuleNotFoundError" or import errors.
+
+**Solutions:**
+1. **Add PEP 723 header with dependencies:**
+   ```python
+   # /// script
+   # dependencies = [
+   #     "trl>=0.12.0",
+   #     "peft>=0.7.0",
+   #     "transformers>=4.36.0",
+   # ]
+   # ///
+   ```
+
+2. **Verify exact format:**
+   - Must have `# ///` delimiters (with space after `#`)
+   - Dependencies must be valid PyPI package names
+   - Check spelling and version constraints
+
+3. **Test locally first:**
+   ```bash
+   uv run train.py  # Tests if dependencies are correct
+   ```
+
+## Authentication Errors
+
+**Problem:** Job fails with authentication or permission errors when pushing to Hub.
+
+**Solutions:**
+1. **Verify authentication:**
+   ```python
+   mcp__huggingface__hf_whoami()  # Check who's authenticated
+   ```
+
+2. **Check token permissions:**
+   - Go to https://huggingface.co/settings/tokens
+   - Ensure token has "write" permission
+   - Token must not be "read-only"
+
+3. **Verify token in job:**
+   ```python
+   "secrets": {"HF_TOKEN": "$HF_TOKEN"}  # Must be in job config
+   ```
+
+4. **Check repo permissions:**
+   - User must have write access to target repo
+   - If org repo, user must be member with write access
+   - Repo must exist or user must have permission to create
+
+## Job Stuck or Not Starting
+
+**Problem:** Job shows "pending" or "starting" for extended period.
+
+**Solutions:**
+- Check Jobs dashboard for status: https://huggingface.co/jobs
+- Verify hardware availability (some GPU types may have queues)
+- Try different hardware flavor if one is heavily utilized
+- Check for account billing issues (Jobs requires paid plan)
+
+**Typical startup times:**
+- CPU jobs: 10-30 seconds
+- GPU jobs: 30-90 seconds
+- If >3 minutes: likely queued or stuck
+
+## Training Loss Not Decreasing
+
+**Problem:** Training runs but loss stays flat or doesn't improve.
+
+**Solutions:**
+1. **Check learning rate:** May be too low (try 2e-5 to 5e-5) or too high (try 1e-6)
+2. **Verify dataset quality:** Inspect examples to ensure they're reasonable
+3. **Check model size:** Very small models may not have capacity for task
+4. **Increase training steps:** May need more epochs or larger dataset
+5. **Verify dataset format:** Wrong format may cause degraded training
+
+## Logs Not Appearing
+
+**Problem:** Cannot see training logs or progress.
+
+**Solutions:**
+1. **Wait 30-60 seconds:** Initial logs can be delayed
+2. **Check logs via MCP tool:**
+   ```python
+   hf_jobs("logs", {"job_id": "your-job-id"})
+   ```
+3. **Use Trackio for real-time monitoring:** See `references/trackio_guide.md`
+4. **Verify job is actually running:**
+   ```python
+   hf_jobs("inspect", {"job_id": "your-job-id"})
+   ```
+
+## Checkpoint/Resume Issues
+
+**Problem:** Cannot resume from checkpoint or checkpoint not saved.
+
+**Solutions:**
+1. **Enable checkpoint saving:**
+   ```python
+   SFTConfig(
+       save_strategy="steps",
+       save_steps=100,
+       hub_strategy="every_save",  # Push each checkpoint
+   )
+   ```
+
+2. **Verify checkpoints pushed to Hub:** Check model repo for checkpoint folders
+
+3. **Resume from checkpoint:**
+   ```python
+   trainer = SFTTrainer(
+       model="username/model-name",  # Can be checkpoint path
+       resume_from_checkpoint="username/model-name/checkpoint-1000",
+   )
+   ```
+
+## Getting Help
+
+If issues persist:
+
+1. **Check TRL documentation:**
+   ```python
+   hf_doc_search("your issue", product="trl")
+   ```
+
+2. **Check Jobs documentation:**
+   ```python
+   hf_doc_fetch("https://huggingface.co/docs/huggingface_hub/guides/jobs")
+   ```
+
+3. **Review related guides:**
+   - `references/hub_saving.md` - Hub authentication issues
+   - `references/hardware_guide.md` - Hardware selection and specs
+   - `references/uv_scripts_guide.md` - UV script format issues
+
+4. **Ask in HF forums:** https://discuss.huggingface.co/

trl/references/uv_scripts_guide.md

@@ -0,0 +1,414 @@
+# UV Scripts Guide for TRL Training
+
+UV scripts are self-contained Python scripts with inline dependency declarations (PEP 723). They're the modern, recommended approach for custom TRL training.
+
+## What are UV Scripts?
+
+UV scripts declare dependencies at the top of the file using special comment syntax:
+
+```python
+# /// script
+# dependencies = [
+#     "trl>=0.12.0",
+#     "transformers>=4.36.0",
+# ]
+# ///
+
+# Your training code here
+from trl import SFTTrainer
+```
+
+## Benefits
+
+1. **Self-contained**: Dependencies are part of the script
+2. **Version control**: Pin exact versions for reproducibility
+3. **No setup files**: No requirements.txt or setup.py needed
+4. **Portable**: Run anywhere UV is installed
+5. **Clean**: Much cleaner than bash + pip + python strings
+
+## Creating a UV Script
+
+### Step 1: Define Dependencies
+
+Start with dependency declaration:
+
+```python
+# /// script
+# dependencies = [
+#     "trl>=0.12.0",              # TRL for training
+#     "transformers>=4.36.0",     # Transformers library
+#     "datasets>=2.14.0",         # Dataset loading
+#     "accelerate>=0.24.0",       # Distributed training
+#     "peft>=0.7.0",              # LoRA/PEFT (optional)
+# ]
+# ///
+```
+
+### Step 2: Add Training Code
+
+```python
+# /// script
+# dependencies = ["trl", "peft"]
+# ///
+
+from datasets import load_dataset
+from peft import LoraConfig
+from trl import SFTTrainer, SFTConfig
+
+# Load dataset
+dataset = load_dataset("trl-lib/Capybara", split="train")
+
+# Configure training
+config = SFTConfig(
+    output_dir="my-model",
+    num_train_epochs=3,
+    push_to_hub=True,
+    hub_model_id="username/my-model",
+)
+
+# Train
+trainer = SFTTrainer(
+    model="Qwen/Qwen2.5-0.5B",
+    train_dataset=dataset,
+    args=config,
+    peft_config=LoraConfig(r=16, lora_alpha=32),
+)
+
+trainer.train()
+trainer.push_to_hub()
+```
+
+### Step 3: Run on Jobs
+
+```python
+hf_jobs("uv", {
+    "script": "train.py",  # or URL
+    "flavor": "a10g-large",
+    "timeout": "2h",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+
+## Running Scripts from URLs
+
+UV scripts can be run directly from URLs:
+
+```python
+hf_jobs("uv", {
+    "script": "https://gist.github.com/username/abc123/raw/train.py",
+    "flavor": "a10g-large",
+    "timeout": "2h",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+
+**Benefits:**
+- Share scripts via GitHub Gists
+- Version control in Git repos
+- Scripts accessible from anywhere
+
+## Working with Local Scripts
+
+⚠️ **Important:** The `hf_jobs("uv", ...)` command does NOT support local file paths directly. You must make scripts accessible via URL.
+
+### Why Local Paths Don't Work
+
+The Jobs API runs in isolated Docker containers without access to your local filesystem. Scripts must be:
+- Publicly accessible URLs, OR
+- Accessible via authentication (HF_TOKEN for private repos)
+
+**Don't:**
+```python
+# ❌ These will all fail
+hf_jobs("uv", {"script": "train.py"})
+hf_jobs("uv", {"script": "./scripts/train.py"})
+hf_jobs("uv", {"script": "/path/to/train.py"})
+```
+
+**Do:**
+```python
+# ✅ These work
+hf_jobs("uv", {"script": "https://huggingface.co/user/repo/resolve/main/train.py"})
+hf_jobs("uv", {"script": "https://raw.githubusercontent.com/user/repo/main/train.py"})
+hf_jobs("uv", {"script": "https://gist.githubusercontent.com/user/id/raw/train.py"})
+```
+
+### Recommended: Upload to Hugging Face Hub
+
+The easiest way to use local scripts is to upload them to a Hugging Face repository:
+
+```bash
+# Create a dedicated scripts repo
+huggingface-cli repo create my-training-scripts --type model
+
+# Upload your script
+huggingface-cli upload my-training-scripts ./train.py train.py
+
+# If you update the script later
+huggingface-cli upload my-training-scripts ./train.py train.py --commit-message "Updated training params"
+
+# Use in jobs
+script_url = "https://huggingface.co/USERNAME/my-training-scripts/resolve/main/train.py"
+
+hf_jobs("uv", {
+    "script": script_url,
+    "flavor": "a10g-large",
+    "timeout": "2h",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+
+**Benefits:**
+- ✅ Version control via Git
+- ✅ Private repos supported (with HF_TOKEN)
+- ✅ Easy to share and update
+- ✅ No external dependencies
+- ✅ Integrates with HF ecosystem
+
+**For Private Scripts:**
+```python
+# Your script is in a private repo
+hf_jobs("uv", {
+    "script": "https://huggingface.co/USERNAME/private-scripts/resolve/main/train.py",
+    "flavor": "a10g-large",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}  # Allows access to private repo
+})
+```
+
+### Alternative: GitHub Gist
+
+For quick scripts or one-off experiments:
+
+```bash
+# 1. Create a gist at https://gist.github.com
+# 2. Paste your script
+# 3. Click "Create public gist" (or secret gist)
+# 4. Click the "Raw" button to get the raw URL
+
+# Use in jobs
+hf_jobs("uv", {
+    "script": "https://gist.githubusercontent.com/username/gist-id/raw/train.py",
+    "flavor": "a10g-large"
+})
+```
+
+**Benefits:**
+- ✅ Quick and easy
+- ✅ No HF CLI setup needed
+- ✅ Good for sharing examples
+
+**Limitations:**
+- ❌ Less version control than Git repos
+- ❌ Secret gists are still publicly accessible via URL
+
+
+## Using TRL Example Scripts
+
+TRL provides maintained scripts that are UV-compatible:
+
+```python
+hf_jobs("uv", {
+    "script": "https://raw.githubusercontent.com/huggingface/trl/main/examples/scripts/sft.py",
+    "script_args": [
+        "--model_name_or_path", "Qwen/Qwen2.5-0.5B",
+        "--dataset_name", "trl-lib/Capybara",
+        "--output_dir", "my-model",
+        "--push_to_hub",
+        "--hub_model_id", "username/my-model"
+    ],
+    "flavor": "a10g-large",
+    "timeout": "2h",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+
+**Available TRL scripts:**
+- `sft.py` - Supervised fine-tuning
+- `dpo.py` - Direct Preference Optimization
+- `kto.py` - KTO training
+- `grpo.py` - GRPO training
+- `reward.py` - Reward model training
+- `prm.py` - Process reward model
+
+All at: https://github.com/huggingface/trl/tree/main/examples/scripts
+
+## Best Practices
+
+### 1. Pin Versions
+
+Always pin dependency versions for reproducibility:
+
+```python
+# /// script
+# dependencies = [
+#     "trl==0.12.0",           # Exact version
+#     "transformers>=4.36.0",  # Minimum version
+# ]
+# ///
+```
+
+### 2. Add Logging
+
+Include progress logging for monitoring:
+
+```python
+print("✅ Dataset loaded")
+print("🚀 Starting training...")
+print(f"📊 Training on {len(dataset)} examples")
+```
+
+### 3. Validate Inputs
+
+Check dataset and configuration before training:
+
+```python
+dataset = load_dataset("trl-lib/Capybara", split="train")
+assert len(dataset) > 0, "Dataset is empty!"
+print(f"✅ Dataset loaded: {len(dataset)} examples")
+```
+
+### 4. Add Comments
+
+Document the script for future reference:
+
+```python
+# Train Qwen-0.5B on Capybara dataset using LoRA
+# Expected runtime: ~2 hours on a10g-large
+# Cost estimate: ~$6-8
+```
+
+### 5. Test Locally First
+
+Test scripts locally before running on Jobs:
+
+```bash
+uv run train.py  # Runs locally with uv
+```
+
+## Docker Images
+
+### Default Image
+
+UV scripts run on default Python image with UV installed.
+
+### TRL Image
+
+Use official TRL image for faster startup:
+
+```python
+hf_jobs("uv", {
+    "script": "train.py",
+    "image": "huggingface/trl",  # Pre-installed TRL dependencies
+    "flavor": "a10g-large",
+    "timeout": "2h",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+
+**Benefits:**
+- Faster job startup (no pip install)
+- All TRL dependencies pre-installed
+- Tested and maintained by HF
+
+## Template Scripts
+
+### Basic SFT Template
+
+```python
+# /// script
+# dependencies = ["trl>=0.12.0"]
+# ///
+
+from datasets import load_dataset
+from trl import SFTTrainer, SFTConfig
+
+dataset = load_dataset("DATASET_NAME", split="train")
+
+trainer = SFTTrainer(
+    model="MODEL_NAME",
+    train_dataset=dataset,
+    args=SFTConfig(
+        output_dir="OUTPUT_DIR",
+        num_train_epochs=3,
+        push_to_hub=True,
+        hub_model_id="USERNAME/MODEL_NAME",
+    )
+)
+
+trainer.train()
+trainer.push_to_hub()
+```
+
+### SFT with LoRA Template
+
+```python
+# /// script
+# dependencies = ["trl>=0.12.0", "peft>=0.7.0"]
+# ///
+
+from datasets import load_dataset
+from peft import LoraConfig
+from trl import SFTTrainer, SFTConfig
+
+dataset = load_dataset("DATASET_NAME", split="train")
+
+trainer = SFTTrainer(
+    model="MODEL_NAME",
+    train_dataset=dataset,
+    peft_config=LoraConfig(r=16, lora_alpha=32),
+    args=SFTConfig(
+        output_dir="OUTPUT_DIR",
+        num_train_epochs=3,
+        push_to_hub=True,
+        hub_model_id="USERNAME/MODEL_NAME",
+    )
+)
+
+trainer.train()
+trainer.push_to_hub()
+```
+
+### DPO Template
+
+```python
+# /// script
+# dependencies = ["trl>=0.12.0"]
+# ///
+
+from datasets import load_dataset
+from transformers import AutoTokenizer
+from trl import DPOTrainer, DPOConfig
+
+model_name = "MODEL_NAME"
+dataset = load_dataset("DATASET_NAME", split="train")
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+
+trainer = DPOTrainer(
+    model=model_name,
+    train_dataset=dataset,
+    tokenizer=tokenizer,
+    args=DPOConfig(
+        output_dir="OUTPUT_DIR",
+        num_train_epochs=3,
+        push_to_hub=True,
+        hub_model_id="USERNAME/MODEL_NAME",
+    )
+)
+
+trainer.train()
+trainer.push_to_hub()
+```
+
+## Troubleshooting
+
+### Issue: Dependencies not installing
+**Check:** Verify dependency names and versions are correct
+
+### Issue: Script not found
+**Check:** Verify URL is accessible and points to raw file
+
+### Issue: Import errors
+**Solution:** Add missing dependencies to `dependencies` list
+
+### Issue: Slow startup
+**Solution:** Use `image="huggingface/trl"` for pre-installed dependencies

trl/scripts/convert_to_gguf.py

@@ -0,0 +1,301 @@
+#!/usr/bin/env python3
+# /// script
+# dependencies = [
+#     "transformers>=4.36.0",
+#     "peft>=0.7.0",
+#     "torch>=2.0.0",
+#     "accelerate>=0.24.0",
+#     "huggingface_hub>=0.20.0",
+#     "sentencepiece>=0.1.99",
+#     "protobuf>=3.20.0",
+#     "numpy",
+#     "gguf",
+# ]
+# ///
+
+import os
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import PeftModel
+from huggingface_hub import HfApi, snapshot_download
+import subprocess
+
+print("🔄 GGUF Conversion Script")
+print("=" * 60)
+
+# Configuration
+ADAPTER_MODEL = "evalstate/qwen-capybara-medium"
+BASE_MODEL = "Qwen/Qwen2.5-0.5B"
+OUTPUT_MODEL_NAME = "evalstate/qwen-capybara-medium-gguf"
+username = os.environ.get("HF_USERNAME", "evalstate")
+
+print(f"\n📦 Configuration:")
+print(f"   Base model: {BASE_MODEL}")
+print(f"   Adapter model: {ADAPTER_MODEL}")
+print(f"   Output repo: {OUTPUT_MODEL_NAME}")
+
+# Step 1: Load base model and adapter
+print("\n🔧 Step 1: Loading base model and LoRA adapter...")
+print("   (This may take a few minutes)")
+
+base_model = AutoModelForCausalLM.from_pretrained(
+    BASE_MODEL,
+    dtype=torch.float16,
+    device_map="auto",
+    trust_remote_code=True,
+)
+print("   ✅ Base model loaded")
+
+# Load and merge adapter
+print("   Loading LoRA adapter...")
+model = PeftModel.from_pretrained(base_model, ADAPTER_MODEL)
+print("   ✅ Adapter loaded")
+
+print("   Merging adapter with base model...")
+merged_model = model.merge_and_unload()
+print("   ✅ Models merged!")
+
+# Load tokenizer
+tokenizer = AutoTokenizer.from_pretrained(ADAPTER_MODEL, trust_remote_code=True)
+print("   ✅ Tokenizer loaded")
+
+# Step 2: Save merged model temporarily
+print("\n💾 Step 2: Saving merged model...")
+merged_dir = "/tmp/merged_model"
+merged_model.save_pretrained(merged_dir, safe_serialization=True)
+tokenizer.save_pretrained(merged_dir)
+print(f"   ✅ Merged model saved to {merged_dir}")
+
+# Step 3: Install llama.cpp for conversion
+print("\n📥 Step 3: Setting up llama.cpp for GGUF conversion...")
+print("   Cloning llama.cpp repository...")
+subprocess.run(
+    ["git", "clone", "https://github.com/ggerganov/llama.cpp.git", "/tmp/llama.cpp"],
+    check=True,
+    capture_output=True
+)
+print("   ✅ llama.cpp cloned")
+
+print("   Installing Python dependencies...")
+subprocess.run(
+    ["pip", "install", "-r", "/tmp/llama.cpp/requirements.txt"],
+    check=True,
+    capture_output=True
+)
+# Also need sentencepiece for tokenizer conversion
+subprocess.run(
+    ["pip", "install", "sentencepiece", "protobuf"],
+    check=True,
+    capture_output=True
+)
+print("   ✅ Dependencies installed")
+
+# Step 4: Convert to GGUF (FP16)
+print("\n🔄 Step 4: Converting to GGUF format (FP16)...")
+gguf_output_dir = "/tmp/gguf_output"
+os.makedirs(gguf_output_dir, exist_ok=True)
+
+convert_script = "/tmp/llama.cpp/convert_hf_to_gguf.py"
+gguf_file = f"{gguf_output_dir}/qwen-capybara-medium-f16.gguf"
+
+print(f"   Running: python {convert_script} {merged_dir}")
+try:
+    result = subprocess.run(
+        [
+            "python", convert_script,
+            merged_dir,
+            "--outfile", gguf_file,
+            "--outtype", "f16"
+        ],
+        check=True,
+        capture_output=True,
+        text=True
+    )
+    print(result.stdout)
+    if result.stderr:
+        print("Warnings:", result.stderr)
+except subprocess.CalledProcessError as e:
+    print(f"❌ Conversion failed!")
+    print("STDOUT:", e.stdout)
+    print("STDERR:", e.stderr)
+    raise
+print(f"   ✅ FP16 GGUF created: {gguf_file}")
+
+# Step 5: Quantize to different formats
+print("\n⚙️  Step 5: Creating quantized versions...")
+quantize_bin = "/tmp/llama.cpp/llama-quantize"
+
+# Build quantize tool first
+print("   Building quantize tool...")
+subprocess.run(
+    ["make", "-C", "/tmp/llama.cpp", "llama-quantize"],
+    check=True,
+    capture_output=True
+)
+print("   ✅ Quantize tool built")
+
+# Common quantization formats
+quant_formats = [
+    ("Q4_K_M", "4-bit, medium quality (recommended)"),
+    ("Q5_K_M", "5-bit, higher quality"),
+    ("Q8_0", "8-bit, very high quality"),
+]
+
+quantized_files = []
+for quant_type, description in quant_formats:
+    print(f"   Creating {quant_type} quantization ({description})...")
+    quant_file = f"{gguf_output_dir}/qwen-capybara-medium-{quant_type.lower()}.gguf"
+
+    subprocess.run(
+        [quantize_bin, gguf_file, quant_file, quant_type],
+        check=True,
+        capture_output=True
+    )
+    quantized_files.append((quant_file, quant_type))
+
+    # Get file size
+    size_mb = os.path.getsize(quant_file) / (1024 * 1024)
+    print(f"   ✅ {quant_type}: {size_mb:.1f} MB")
+
+# Step 6: Upload to Hub
+print("\n☁️  Step 6: Uploading to Hugging Face Hub...")
+api = HfApi()
+
+# Create repo
+print(f"   Creating repository: {OUTPUT_MODEL_NAME}")
+try:
+    api.create_repo(repo_id=OUTPUT_MODEL_NAME, repo_type="model", exist_ok=True)
+    print("   ✅ Repository created")
+except Exception as e:
+    print(f"   ��️  Repository may already exist: {e}")
+
+# Upload FP16 version
+print("   Uploading FP16 GGUF...")
+api.upload_file(
+    path_or_fileobj=gguf_file,
+    path_in_repo="qwen-capybara-medium-f16.gguf",
+    repo_id=OUTPUT_MODEL_NAME,
+)
+print("   ✅ FP16 uploaded")
+
+# Upload quantized versions
+for quant_file, quant_type in quantized_files:
+    print(f"   Uploading {quant_type}...")
+    api.upload_file(
+        path_or_fileobj=quant_file,
+        path_in_repo=f"qwen-capybara-medium-{quant_type.lower()}.gguf",
+        repo_id=OUTPUT_MODEL_NAME,
+    )
+    print(f"   ✅ {quant_type} uploaded")
+
+# Create README
+print("\n📝 Creating README...")
+readme_content = f"""---
+base_model: {BASE_MODEL}
+tags:
+- gguf
+- llama.cpp
+- quantized
+- trl
+- sft
+---
+
+# {OUTPUT_MODEL_NAME.split('/')[-1]}
+
+This is a GGUF conversion of [{ADAPTER_MODEL}](https://huggingface.co/{ADAPTER_MODEL}), which is a LoRA fine-tuned version of [{BASE_MODEL}](https://huggingface.co/{BASE_MODEL}).
+
+## Model Details
+
+- **Base Model:** {BASE_MODEL}
+- **Fine-tuned Model:** {ADAPTER_MODEL}
+- **Training:** Supervised Fine-Tuning (SFT) with TRL
+- **Format:** GGUF (for llama.cpp, Ollama, LM Studio, etc.)
+
+## Available Quantizations
+
+| File | Quant | Size | Description | Use Case |
+|------|-------|------|-------------|----------|
+| qwen-capybara-medium-f16.gguf | F16 | ~1GB | Full precision | Best quality, slower |
+| qwen-capybara-medium-q8_0.gguf | Q8_0 | ~500MB | 8-bit | High quality |
+| qwen-capybara-medium-q5_k_m.gguf | Q5_K_M | ~350MB | 5-bit medium | Good quality, smaller |
+| qwen-capybara-medium-q4_k_m.gguf | Q4_K_M | ~300MB | 4-bit medium | Recommended - good balance |
+
+## Usage
+
+### With llama.cpp
+
+```bash
+# Download model
+huggingface-cli download {OUTPUT_MODEL_NAME} qwen-capybara-medium-q4_k_m.gguf
+
+# Run with llama.cpp
+./llama-cli -m qwen-capybara-medium-q4_k_m.gguf -p "Your prompt here"
+```
+
+### With Ollama
+
+1. Create a `Modelfile`:
+```
+FROM ./qwen-capybara-medium-q4_k_m.gguf
+```
+
+2. Create the model:
+```bash
+ollama create qwen-capybara -f Modelfile
+ollama run qwen-capybara
+```
+
+### With LM Studio
+
+1. Download the `.gguf` file
+2. Import into LM Studio
+3. Start chatting!
+
+## Training Details
+
+This model was fine-tuned using:
+- **Dataset:** trl-lib/Capybara (1,000 examples)
+- **Method:** Supervised Fine-Tuning with LoRA
+- **Epochs:** 3
+- **LoRA rank:** 16
+- **Hardware:** A10G Large GPU
+
+## License
+
+Inherits the license from the base model: {BASE_MODEL}
+
+## Citation
+
+```bibtex
+@misc{{qwen-capybara-medium-gguf,
+  author = {{{username}}},
+  title = {{Qwen Capybara Medium GGUF}},
+  year = {{2025}},
+  publisher = {{Hugging Face}},
+  url = {{https://huggingface.co/{OUTPUT_MODEL_NAME}}}
+}}
+```
+
+---
+
+*Converted to GGUF format using llama.cpp*
+"""
+
+api.upload_file(
+    path_or_fileobj=readme_content.encode(),
+    path_in_repo="README.md",
+    repo_id=OUTPUT_MODEL_NAME,
+)
+print("   ✅ README uploaded")
+
+print("\n" + "=" * 60)
+print("✅ GGUF Conversion Complete!")
+print(f"📦 Repository: https://huggingface.co/{OUTPUT_MODEL_NAME}")
+print("\n📥 Download with:")
+print(f"   huggingface-cli download {OUTPUT_MODEL_NAME} qwen-capybara-medium-q4_k_m.gguf")
+print("\n🚀 Use with Ollama:")
+print("   1. Download the GGUF file")
+print("   2. Create Modelfile: FROM ./qwen-capybara-medium-q4_k_m.gguf")
+print("   3. ollama create qwen-capybara -f Modelfile")
+print("   4. ollama run qwen-capybara")
+print("=" * 60)

trl/scripts/estimate_cost.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+# /// script
+# dependencies = []
+# ///
+"""
+Estimate training time and cost for TRL jobs.
+
+Usage:
+    python estimate_cost.py --model <model> --dataset <dataset> --hardware <flavor>
+    
+Example:
+    python estimate_cost.py --model Qwen/Qwen2.5-0.5B --dataset trl-lib/Capybara --hardware a10g-large
+"""
+
+import argparse
+
+# Hardware costs per hour (approximate)
+HARDWARE_COSTS = {
+    "t4-small": 0.75,
+    "t4-medium": 1.50,
+    "l4x1": 2.50,
+    "a10g-small": 3.50,
+    "a10g-large": 5.00,
+    "a10g-largex2": 10.00,
+    "a10g-largex4": 20.00,
+    "a100-large": 10.00,
+}
+
+# Model sizes in billions of parameters
+MODEL_SIZES = {
+    "0.5B": 0.5,
+    "1.5B": 1.5,
+    "3B": 3,
+    "7B": 7,
+    "13B": 13,
+}
+
+def estimate_training_time(model_params, dataset_size, epochs, hardware):
+    """Estimate training time in hours."""
+    # Rough estimates based on empirical observations
+    # These are approximations and actual times will vary
+    
+    base_time_per_1k_examples = 0.1  # hours for 1B model on a10g-large
+    
+    # Adjust for model size
+    time = base_time_per_1k_examples * model_params * (dataset_size / 1000) * epochs
+    
+    # Adjust for hardware (relative to a10g-large baseline)
+    hardware_multipliers = {
+        "t4-small": 2.0,
+        "t4-medium": 1.5,
+        "l4x1": 1.2,
+        "a10g-small": 1.3,
+        "a10g-large": 1.0,
+        "a10g-largex2": 0.6,
+        "a10g-largex4": 0.4,
+        "a100-large": 0.7,
+    }
+    
+    multiplier = hardware_multipliers.get(hardware, 1.0)
+    time *= multiplier
+    
+    return time
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Estimate training cost for TRL jobs")
+    parser.add_argument("--model", required=True, help="Model name or size (e.g., 'Qwen/Qwen2.5-0.5B' or '0.5B')")
+    parser.add_argument("--dataset", required=True, help="Dataset name")
+    parser.add_argument("--hardware", required=True, choices=HARDWARE_COSTS.keys(), help="Hardware flavor")
+    parser.add_argument("--dataset-size", type=int, help="Override dataset size (number of examples)")
+    parser.add_argument("--epochs", type=int, default=3, help="Number of training epochs")
+    return parser.parse_args()
+
+def extract_model_size(model_name):
+    """Extract model size from name or return parsed value."""
+    for size_str, size_val in MODEL_SIZES.items():
+        if size_str in model_name:
+            return size_val
+    
+    # Try to parse directly
+    try:
+        if "B" in model_name:
+            return float(model_name.replace("B", ""))
+    except:
+        pass
+    
+    return 1.0  # Default to 1B if can't determine
+
+def main():
+    args = parse_args()
+    
+    # Extract model parameters
+    model_params = extract_model_size(args.model)
+    print(f"📊 Model: {args.model} (~{model_params}B parameters)")
+    
+    # Estimate dataset size (would need to load to get real size)
+    if args.dataset_size:
+        dataset_size = args.dataset_size
+    else:
+        # Common dataset sizes (approximations)
+        dataset_sizes = {
+            "trl-lib/Capybara": 16000,
+            "Anthropic/hh-rlhf": 160000,
+        }
+        dataset_size = dataset_sizes.get(args.dataset, 10000)
+    
+    print(f"📦 Dataset: {args.dataset} (~{dataset_size} examples)")
+    print(f"🔄 Epochs: {args.epochs}")
+    print(f"💻 Hardware: {args.hardware}")
+    print()
+    
+    # Estimate training time
+    estimated_hours = estimate_training_time(model_params, dataset_size, args.epochs, args.hardware)
+    estimated_cost = estimated_hours * HARDWARE_COSTS[args.hardware]
+    
+    # Recommend timeout with buffer
+    recommended_timeout_hours = estimated_hours * 1.3  # 30% buffer
+    
+    print(f"⏱️  Estimated training time: {estimated_hours:.1f} hours")
+    print(f"💰 Estimated cost: ${estimated_cost:.2f}")
+    print(f"⏰ Recommended timeout: {recommended_timeout_hours:.1f}h (with 30% buffer)")
+    print()
+    
+    # Warnings and recommendations
+    if estimated_hours > 4:
+        print("⚠️  Long training time - consider:")
+        print("   - Using faster hardware")
+        print("   - Reducing epochs")
+        print("   - Using a smaller dataset subset for testing")
+    
+    if model_params >= 7 and args.hardware not in ["a10g-largex2", "a10g-largex4", "a100-large"]:
+        print("⚠️  Large model - consider using:")
+        print("   - Larger GPU (a100-large)")
+        print("   - Multi-GPU setup (a10g-largex2 or a10g-largex4)")
+        print("   - LoRA/PEFT for memory efficiency")
+    
+    print()
+    print("📋 Example job configuration:")
+    print(f"""
+hf_jobs("uv", {{
+    "script": "your_training_script.py",
+    "flavor": "{args.hardware}",
+    "timeout": "{recommended_timeout_hours:.0f}h",
+    "secrets": {{"HF_TOKEN": "$HF_TOKEN"}}
+}})
+""")
+
+if __name__ == "__main__":
+    main()

trl/scripts/train_dpo_example.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+# /// script
+# dependencies = [
+#     "trl>=0.12.0",
+#     "transformers>=4.36.0",
+#     "accelerate>=0.24.0",
+#     "trackio",
+# ]
+# ///
+
+"""
+Production-ready DPO training example for preference learning.
+
+DPO (Direct Preference Optimization) trains models on preference pairs
+(chosen vs rejected responses) without requiring a reward model.
+
+Usage with hf_jobs MCP tool:
+    hf_jobs("uv", {
+        "script": '''<paste this entire file>''',
+        "flavor": "a10g-large",
+        "timeout": "3h",
+        "secrets": {"HF_TOKEN": "$HF_TOKEN"},
+    })
+
+Or submit the script content directly inline without saving to a file.
+"""
+
+import trackio
+from datasets import load_dataset
+from trl import DPOTrainer, DPOConfig
+
+# Initialize Trackio for real-time monitoring
+trackio.init(
+    project="qwen-dpo-alignment",
+    space_id="username/my-trackio-dashboard",
+    config={
+        "model": "Qwen/Qwen2.5-0.5B-Instruct",
+        "dataset": "trl-lib/ultrafeedback_binarized",
+        "method": "DPO",
+        "beta": 0.1,
+        "num_epochs": 1,
+    }
+)
+
+# Load preference dataset
+dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
+print(f"✅ Dataset loaded: {len(dataset)} preference pairs")
+
+# Training configuration
+config = DPOConfig(
+    # CRITICAL: Hub settings
+    output_dir="qwen-dpo-aligned",
+    push_to_hub=True,
+    hub_model_id="username/qwen-dpo-aligned",
+    hub_strategy="every_save",
+
+    # DPO-specific parameters
+    beta=0.1,  # KL penalty coefficient (higher = stay closer to reference)
+
+    # Training parameters
+    num_train_epochs=1,  # DPO typically needs fewer epochs than SFT
+    per_device_train_batch_size=4,
+    gradient_accumulation_steps=4,
+    learning_rate=5e-7,  # DPO uses much lower LR than SFT
+
+    # Logging & checkpointing
+    logging_steps=10,
+    save_strategy="steps",
+    save_steps=100,
+    save_total_limit=2,
+
+    # Optimization
+    warmup_ratio=0.1,
+    lr_scheduler_type="cosine",
+
+    # Monitoring
+    report_to="trackio",
+)
+
+# Initialize and train
+# Note: DPO requires an instruct-tuned model as the base
+trainer = DPOTrainer(
+    model="Qwen/Qwen2.5-0.5B-Instruct",  # Use instruct model, not base model
+    train_dataset=dataset,
+    args=config,
+)
+
+print("🚀 Starting DPO training...")
+trainer.train()
+
+print("💾 Pushing to Hub...")
+trainer.push_to_hub()
+
+# Finish Trackio tracking
+trackio.finish()
+
+print("✅ Complete! Model at: https://huggingface.co/username/qwen-dpo-aligned")
+print("📊 View metrics at: https://huggingface.co/spaces/username/my-trackio-dashboard")

trl/scripts/train_grpo_example.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+# /// script
+# dependencies = [
+#     "trl>=0.12.0",
+#     "transformers>=4.36.0",
+#     "accelerate>=0.24.0",
+#     "trackio",
+# ]
+# ///
+
+"""
+Production-ready GRPO training example for online RL.
+
+GRPO (Group Relative Policy Optimization) is an online RL method that
+optimizes relative to group performance. Best for tasks with automatic
+reward signals like code execution or math verification.
+
+Usage with hf_jobs MCP tool:
+    hf_jobs("uv", {
+        "script": '''<paste this entire file>''',
+        "flavor": "a10g-large",
+        "timeout": "4h",
+        "secrets": {"HF_TOKEN": "$HF_TOKEN"},
+    })
+
+Or submit the script content directly inline without saving to a file.
+
+Note: For most GRPO use cases, the TRL maintained script is recommended:
+    https://raw.githubusercontent.com/huggingface/trl/main/examples/scripts/grpo.py
+"""
+
+import trackio
+from datasets import load_dataset
+from trl import GRPOTrainer, GRPOConfig
+
+# Initialize Trackio for real-time monitoring
+trackio.init(
+    project="qwen-grpo-math",
+    space_id="username/my-trackio-dashboard",
+    config={
+        "model": "Qwen/Qwen2.5-0.5B-Instruct",
+        "dataset": "trl-lib/math_shepherd",
+        "method": "GRPO",
+    }
+)
+
+# Load dataset (GRPO uses prompt-only format)
+dataset = load_dataset("trl-lib/math_shepherd", split="train")
+print(f"✅ Dataset loaded: {len(dataset)} prompts")
+
+# Training configuration
+config = GRPOConfig(
+    # CRITICAL: Hub settings
+    output_dir="qwen-grpo-math",
+    push_to_hub=True,
+    hub_model_id="username/qwen-grpo-math",
+    hub_strategy="every_save",
+
+    # Training parameters
+    num_train_epochs=1,
+    per_device_train_batch_size=4,
+    gradient_accumulation_steps=4,
+    learning_rate=1e-6,
+
+    # Logging & checkpointing
+    logging_steps=10,
+    save_strategy="steps",
+    save_steps=100,
+    save_total_limit=2,
+
+    # Optimization
+    warmup_ratio=0.1,
+    lr_scheduler_type="cosine",
+
+    # Monitoring
+    report_to="trackio",
+)
+
+# Initialize and train
+# Note: GRPO requires an instruct-tuned model as the base
+trainer = GRPOTrainer(
+    model="Qwen/Qwen2.5-0.5B-Instruct",
+    train_dataset=dataset,
+    args=config,
+)
+
+print("🚀 Starting GRPO training...")
+trainer.train()
+
+print("💾 Pushing to Hub...")
+trainer.push_to_hub()
+
+# Finish Trackio tracking
+trackio.finish()
+
+print("✅ Complete! Model at: https://huggingface.co/username/qwen-grpo-math")
+print("📊 View metrics at: https://huggingface.co/spaces/username/my-trackio-dashboard")

trl/scripts/train_sft_example.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+# /// script
+# dependencies = [
+#     "trl>=0.12.0",
+#     "peft>=0.7.0",
+#     "transformers>=4.36.0",
+#     "accelerate>=0.24.0",
+#     "trackio",  # For real-time monitoring
+# ]
+# ///
+
+"""
+Production-ready SFT training example with all best practices.
+
+This script demonstrates:
+- Trackio integration for real-time monitoring
+- LoRA/PEFT for efficient training
+- Proper Hub saving configuration
+- Checkpoint management
+- Optimized training parameters
+
+Usage with hf_jobs MCP tool:
+    hf_jobs("uv", {
+        "script": '''<paste this entire file>''',
+        "flavor": "a10g-large",
+        "timeout": "3h",
+        "secrets": {"HF_TOKEN": "$HF_TOKEN"},
+    })
+
+Or submit the script content directly inline without saving to a file.
+"""
+
+import trackio
+from datasets import load_dataset
+from peft import LoraConfig
+from trl import SFTTrainer, SFTConfig
+
+# Initialize Trackio for real-time monitoring
+trackio.init(
+    project="qwen-capybara-sft",
+    space_id="username/my-trackio-dashboard",  # Creates Space if it doesn't exist
+    config={
+        "model": "Qwen/Qwen2.5-0.5B",
+        "dataset": "trl-lib/Capybara",
+        "learning_rate": 2e-5,
+        "num_epochs": 3,
+        "peft_method": "LoRA",
+    }
+)
+
+# Load and validate
+dataset = load_dataset("trl-lib/Capybara", split="train")
+print(f"✅ Dataset loaded: {len(dataset)} examples")
+
+# Training configuration
+config = SFTConfig(
+    # CRITICAL: Hub settings
+    output_dir="qwen-capybara-sft",
+    push_to_hub=True,
+    hub_model_id="username/qwen-capybara-sft",
+    hub_strategy="every_save",  # Push checkpoints
+
+    # Training parameters
+    num_train_epochs=3,
+    per_device_train_batch_size=4,
+    gradient_accumulation_steps=4,
+    learning_rate=2e-5,
+
+    # Logging & checkpointing
+    logging_steps=10,
+    save_strategy="steps",
+    save_steps=100,
+    save_total_limit=2,
+
+    # Optimization
+    warmup_ratio=0.1,
+    lr_scheduler_type="cosine",
+
+    # Monitoring
+    report_to="trackio",  # Integrate with Trackio
+)
+
+# LoRA configuration
+peft_config = LoraConfig(
+    r=16,
+    lora_alpha=32,
+    lora_dropout=0.05,
+    bias="none",
+    task_type="CAUSAL_LM",
+    target_modules=["q_proj", "v_proj"],
+)
+
+# Initialize and train
+trainer = SFTTrainer(
+    model="Qwen/Qwen2.5-0.5B",
+    train_dataset=dataset,
+    args=config,
+    peft_config=peft_config,
+)
+
+print("🚀 Starting training...")
+trainer.train()
+
+print("💾 Pushing to Hub...")
+trainer.push_to_hub()
+
+# Finish Trackio tracking
+trackio.finish()
+
+print("✅ Complete! Model at: https://huggingface.co/username/qwen-capybara-sft")
+print("📊 View metrics at: https://huggingface.co/spaces/username/my-trackio-dashboard")

trl/scripts/validate_dataset.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+# /// script
+# dependencies = [
+#     "datasets>=2.14.0",
+# ]
+# ///
+"""
+Validate dataset format for TRL training.
+
+Usage:
+    python validate_dataset.py <dataset_name> <method>
+    
+Examples:
+    python validate_dataset.py trl-lib/Capybara sft
+    python validate_dataset.py Anthropic/hh-rlhf dpo
+"""
+
+import sys
+from datasets import load_dataset
+
+def validate_sft_dataset(dataset):
+    """Validate SFT dataset format."""
+    print("🔍 Validating SFT dataset...")
+    
+    # Check for common fields
+    columns = dataset.column_names
+    print(f"📋 Columns: {columns}")
+    
+    has_messages = "messages" in columns
+    has_text = "text" in columns
+    
+    if not (has_messages or has_text):
+        print("❌ Dataset must have 'messages' or 'text' field")
+        return False
+    
+    # Check first example
+    example = dataset[0]
+    
+    if has_messages:
+        messages = example["messages"]
+        if not isinstance(messages, list):
+            print("❌ 'messages' field must be a list")
+            return False
+        
+        if len(messages) == 0:
+            print("❌ 'messages' field is empty")
+            return False
+        
+        # Check message format
+        msg = messages[0]
+        if not isinstance(msg, dict):
+            print("❌ Messages must be dictionaries")
+            return False
+        
+        if "role" not in msg or "content" not in msg:
+            print("❌ Messages must have 'role' and 'content' keys")
+            return False
+        
+        print("✅ Messages format valid")
+        print(f"   First message: {msg['role']}: {msg['content'][:50]}...")
+    
+    if has_text:
+        text = example["text"]
+        if not isinstance(text, str):
+            print("❌ 'text' field must be a string")
+            return False
+        
+        if len(text) == 0:
+            print("❌ 'text' field is empty")
+            return False
+        
+        print("✅ Text format valid")
+        print(f"   First text: {text[:100]}...")
+    
+    return True
+
+def validate_dpo_dataset(dataset):
+    """Validate DPO dataset format."""
+    print("🔍 Validating DPO dataset...")
+    
+    columns = dataset.column_names
+    print(f"📋 Columns: {columns}")
+    
+    required = ["prompt", "chosen", "rejected"]
+    missing = [col for col in required if col not in columns]
+    
+    if missing:
+        print(f"❌ Missing required fields: {missing}")
+        return False
+    
+    # Check first example
+    example = dataset[0]
+    
+    for field in required:
+        value = example[field]
+        if isinstance(value, str):
+            if len(value) == 0:
+                print(f"❌ '{field}' field is empty")
+                return False
+            print(f"✅ '{field}' format valid (string)")
+        elif isinstance(value, list):
+            if len(value) == 0:
+                print(f"❌ '{field}' field is empty")
+                return False
+            print(f"✅ '{field}' format valid (list of messages)")
+        else:
+            print(f"❌ '{field}' must be string or list")
+            return False
+    
+    return True
+
+def validate_kto_dataset(dataset):
+    """Validate KTO dataset format."""
+    print("🔍 Validating KTO dataset...")
+    
+    columns = dataset.column_names
+    print(f"📋 Columns: {columns}")
+    
+    required = ["prompt", "completion", "label"]
+    missing = [col for col in required if col not in columns]
+    
+    if missing:
+        print(f"❌ Missing required fields: {missing}")
+        return False
+    
+    # Check first example
+    example = dataset[0]
+    
+    if not isinstance(example["label"], bool):
+        print("❌ 'label' field must be boolean")
+        return False
+    
+    print("✅ KTO format valid")
+    return True
+
+def main():
+    if len(sys.argv) != 3:
+        print("Usage: python validate_dataset.py <dataset_name> <method>")
+        print("Methods: sft, dpo, kto")
+        sys.exit(1)
+    
+    dataset_name = sys.argv[1]
+    method = sys.argv[2].lower()
+    
+    print(f"📦 Loading dataset: {dataset_name}")
+    try:
+        dataset = load_dataset(dataset_name, split="train")
+        print(f"✅ Dataset loaded: {len(dataset)} examples")
+    except Exception as e:
+        print(f"❌ Failed to load dataset: {e}")
+        sys.exit(1)
+    
+    validators = {
+        "sft": validate_sft_dataset,
+        "dpo": validate_dpo_dataset,
+        "kto": validate_kto_dataset,
+    }
+    
+    if method not in validators:
+        print(f"❌ Unknown method: {method}")
+        print(f"Supported methods: {list(validators.keys())}")
+        sys.exit(1)
+    
+    validator = validators[method]
+    valid = validator(dataset)
+    
+    if valid:
+        print(f"\n✅ Dataset is valid for {method.upper()} training")
+        sys.exit(0)
+    else:
+        print(f"\n❌ Dataset is NOT valid for {method.upper()} training")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()