gguf-improve

README.md

@@ -1,6 +0,0 @@
----
-viewer: false
----
-
-
-working here `https://github.com/evalstate/skills-dev`

dataset_inspector.py

@@ -1,416 +0,0 @@
-#!/usr/bin/env python3
-# /// script
-# dependencies = []
-# ///
-"""
-Dataset Format Inspector for TRL Training (LLM-Optimized Output)
-
-Inspects Hugging Face datasets to determine TRL training compatibility.
-Uses Datasets Server API for instant results - no dataset download needed!
-
-ULTRA-EFFICIENT: Uses HF Datasets Server API - completes in <2 seconds.
-
-Usage with HF Jobs:
-    hf_jobs("uv", {
-        "script": "https://huggingface.co/datasets/evalstate/trl-helpers/raw/main/dataset_inspector.py",
-        "script_args": ["--dataset", "your/dataset", "--split", "train"]
-    })
-"""
-
-import argparse
-import sys
-import json
-import urllib.request
-import urllib.parse
-from typing import List, Dict, Any
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description="Inspect dataset format for TRL training")
-    parser.add_argument("--dataset", type=str, required=True, help="Dataset name")
-    parser.add_argument("--split", type=str, default="train", help="Dataset split (default: train)")
-    parser.add_argument("--config", type=str, default="default", help="Dataset config name (default: default)")
-    parser.add_argument("--preview", type=int, default=150, help="Max chars per field preview")
-    parser.add_argument("--samples", type=int, default=5, help="Number of samples to fetch (default: 5)")
-    parser.add_argument("--json-output", action="store_true", help="Output as JSON")
-    return parser.parse_args()
-
-
-def api_request(url: str) -> Dict:
-    """Make API request to Datasets Server"""
-    try:
-        with urllib.request.urlopen(url, timeout=10) as response:
-            return json.loads(response.read().decode())
-    except urllib.error.HTTPError as e:
-        if e.code == 404:
-            return None
-        raise Exception(f"API request failed: {e.code} {e.reason}")
-    except Exception as e:
-        raise Exception(f"API request failed: {str(e)}")
-
-
-def get_splits(dataset: str) -> Dict:
-    """Get available splits for dataset"""
-    url = f"https://datasets-server.huggingface.co/splits?dataset={urllib.parse.quote(dataset)}"
-    return api_request(url)
-
-
-def get_rows(dataset: str, config: str, split: str, offset: int = 0, length: int = 5) -> Dict:
-    """Get rows from dataset"""
-    url = f"https://datasets-server.huggingface.co/rows?dataset={urllib.parse.quote(dataset)}&config={config}&split={split}&offset={offset}&length={length}"
-    return api_request(url)
-
-
-def find_columns(columns: List[str], patterns: List[str]) -> List[str]:
-    """Find columns matching patterns"""
-    return [c for c in columns if any(p in c.lower() for p in patterns)]
-
-
-def check_sft_compatibility(columns: List[str]) -> Dict[str, Any]:
-    """Check SFT compatibility"""
-    has_messages = "messages" in columns
-    has_text = "text" in columns
-    has_prompt_completion = "prompt" in columns and "completion" in columns
-    
-    ready = has_messages or has_text or has_prompt_completion
-    
-    possible_prompt = find_columns(columns, ["prompt", "instruction", "question", "input"])
-    possible_response = find_columns(columns, ["response", "completion", "output", "answer"])
-    
-    return {
-        "ready": ready,
-        "reason": "messages" if has_messages else "text" if has_text else "prompt+completion" if has_prompt_completion else None,
-        "possible_prompt": possible_prompt[0] if possible_prompt else None,
-        "possible_response": possible_response[0] if possible_response else None,
-        "has_context": "context" in columns,
-    }
-
-
-def check_dpo_compatibility(columns: List[str]) -> Dict[str, Any]:
-    """Check DPO compatibility"""
-    has_standard = "prompt" in columns and "chosen" in columns and "rejected" in columns
-    
-    possible_prompt = find_columns(columns, ["prompt", "instruction", "question", "input"])
-    possible_chosen = find_columns(columns, ["chosen", "preferred", "winner"])
-    possible_rejected = find_columns(columns, ["rejected", "dispreferred", "loser"])
-    
-    can_map = bool(possible_prompt and possible_chosen and possible_rejected)
-    
-    return {
-        "ready": has_standard,
-        "can_map": can_map,
-        "prompt_col": possible_prompt[0] if possible_prompt else None,
-        "chosen_col": possible_chosen[0] if possible_chosen else None,
-        "rejected_col": possible_rejected[0] if possible_rejected else None,
-    }
-
-
-def check_grpo_compatibility(columns: List[str]) -> Dict[str, Any]:
-    """Check GRPO compatibility"""
-    has_prompt = "prompt" in columns
-    has_no_responses = "chosen" not in columns and "rejected" not in columns
-    
-    possible_prompt = find_columns(columns, ["prompt", "instruction", "question", "input"])
-    
-    return {
-        "ready": has_prompt and has_no_responses,
-        "can_map": bool(possible_prompt) and has_no_responses,
-        "prompt_col": possible_prompt[0] if possible_prompt else None,
-    }
-
-
-def check_kto_compatibility(columns: List[str]) -> Dict[str, Any]:
-    """Check KTO compatibility"""
-    return {"ready": "prompt" in columns and "completion" in columns and "label" in columns}
-
-
-def generate_mapping_code(method: str, info: Dict[str, Any]) -> str:
-    """Generate mapping code for a training method"""
-    if method == "SFT":
-        if info["ready"]:
-            return None
-        
-        prompt_col = info.get("possible_prompt")
-        response_col = info.get("possible_response")
-        has_context = info.get("has_context", False)
-        
-        if not prompt_col:
-            return None
-        
-        if has_context and response_col:
-            return f"""def format_for_sft(example):
-    text = f"Instruction: {{example['{prompt_col}']}}\\n\\n"
-    if example.get('context'):
-        text += f"Context: {{example['context']}}\\n\\n"
-    text += f"Response: {{example['{response_col}']}}"
-    return {{'text': text}}
-
-dataset = dataset.map(format_for_sft, remove_columns=dataset.column_names)"""
-        elif response_col:
-            return f"""def format_for_sft(example):
-    return {{'text': f"{{example['{prompt_col}']}}\\n\\n{{example['{response_col}']}}}}
-
-dataset = dataset.map(format_for_sft, remove_columns=dataset.column_names)"""
-        else:
-            return f"""def format_for_sft(example):
-    return {{'text': example['{prompt_col}']}}
-
-dataset = dataset.map(format_for_sft, remove_columns=dataset.column_names)"""
-    
-    elif method == "DPO":
-        if info["ready"] or not info["can_map"]:
-            return None
-        
-        return f"""def format_for_dpo(example):
-    return {{
-        'prompt': example['{info['prompt_col']}'],
-        'chosen': example['{info['chosen_col']}'],
-        'rejected': example['{info['rejected_col']}'],
-    }}
-
-dataset = dataset.map(format_for_dpo, remove_columns=dataset.column_names)"""
-    
-    elif method == "GRPO":
-        if info["ready"] or not info["can_map"]:
-            return None
-        
-        return f"""def format_for_grpo(example):
-    return {{'prompt': example['{info['prompt_col']}']}}
-
-dataset = dataset.map(format_for_grpo, remove_columns=dataset.column_names)"""
-    
-    return None
-
-
-def format_value_preview(value: Any, max_chars: int) -> str:
-    """Format value for preview"""
-    if value is None:
-        return "None"
-    elif isinstance(value, str):
-        return value[:max_chars] + ("..." if len(value) > max_chars else "")
-    elif isinstance(value, list):
-        if len(value) > 0 and isinstance(value[0], dict):
-            return f"[{len(value)} items] Keys: {list(value[0].keys())}"
-        preview = str(value)
-        return preview[:max_chars] + ("..." if len(preview) > max_chars else "")
-    else:
-        preview = str(value)
-        return preview[:max_chars] + ("..." if len(preview) > max_chars else "")
-
-
-def main():
-    args = parse_args()
-    
-    print(f"Fetching dataset info via Datasets Server API...")
-    
-    try:
-        # Get splits info
-        splits_data = get_splits(args.dataset)
-        if not splits_data or "splits" not in splits_data:
-            print(f"ERROR: Could not fetch splits for dataset '{args.dataset}'")
-            print(f"       Dataset may not exist or is not accessible via Datasets Server API")
-            sys.exit(1)
-        
-        # Find the right config
-        available_configs = set()
-        split_found = False
-        config_to_use = args.config
-        
-        for split_info in splits_data["splits"]:
-            available_configs.add(split_info["config"])
-            if split_info["config"] == args.config and split_info["split"] == args.split:
-                split_found = True
-        
-        # If default config not found, try first available
-        if not split_found and available_configs:
-            config_to_use = list(available_configs)[0]
-            print(f"Config '{args.config}' not found, trying '{config_to_use}'...")
-        
-        # Get rows
-        rows_data = get_rows(args.dataset, config_to_use, args.split, offset=0, length=args.samples)
-        
-        if not rows_data or "rows" not in rows_data:
-            print(f"ERROR: Could not fetch rows for dataset '{args.dataset}'")
-            print(f"       Split '{args.split}' may not exist")
-            print(f"       Available configs: {', '.join(sorted(available_configs))}")
-            sys.exit(1)
-        
-        rows = rows_data["rows"]
-        if not rows:
-            print(f"ERROR: No rows found in split '{args.split}'")
-            sys.exit(1)
-        
-        # Extract column info from first row
-        first_row = rows[0]["row"]
-        columns = list(first_row.keys())
-        features = rows_data.get("features", [])
-        
-        # Get total count if available
-        total_examples = "Unknown"
-        for split_info in splits_data["splits"]:
-            if split_info["config"] == config_to_use and split_info["split"] == args.split:
-                total_examples = f"{split_info.get('num_examples', 'Unknown'):,}" if isinstance(split_info.get('num_examples'), int) else "Unknown"
-                break
-        
-    except Exception as e:
-        print(f"ERROR: {str(e)}")
-        sys.exit(1)
-    
-    # Run compatibility checks
-    sft_info = check_sft_compatibility(columns)
-    dpo_info = check_dpo_compatibility(columns)
-    grpo_info = check_grpo_compatibility(columns)
-    kto_info = check_kto_compatibility(columns)
-    
-    # Determine recommended methods
-    recommended = []
-    if sft_info["ready"]:
-        recommended.append("SFT")
-    elif sft_info["possible_prompt"]:
-        recommended.append("SFT (needs mapping)")
-    
-    if dpo_info["ready"]:
-        recommended.append("DPO")
-    elif dpo_info["can_map"]:
-        recommended.append("DPO (needs mapping)")
-    
-    if grpo_info["ready"]:
-        recommended.append("GRPO")
-    elif grpo_info["can_map"]:
-        recommended.append("GRPO (needs mapping)")
-    
-    if kto_info["ready"]:
-        recommended.append("KTO")
-    
-    # JSON output mode
-    if args.json_output:
-        result = {
-            "dataset": args.dataset,
-            "config": config_to_use,
-            "split": args.split,
-            "total_examples": total_examples,
-            "columns": columns,
-            "features": [{"name": f["name"], "type": f["type"]} for f in features] if features else [],
-            "compatibility": {
-                "SFT": sft_info,
-                "DPO": dpo_info,
-                "GRPO": grpo_info,
-                "KTO": kto_info,
-            },
-            "recommended_methods": recommended,
-        }
-        print(json.dumps(result, indent=2))
-        sys.exit(0)
-    
-    # Human-readable output optimized for LLM parsing
-    print("=" * 80)
-    print(f"DATASET INSPECTION RESULTS")
-    print("=" * 80)
-    
-    print(f"\nDataset: {args.dataset}")
-    print(f"Config: {config_to_use}")
-    print(f"Split: {args.split}")
-    print(f"Total examples: {total_examples}")
-    print(f"Samples fetched: {len(rows)}")
-    
-    print(f"\n{'COLUMNS':-<80}")
-    if features:
-        for feature in features:
-            print(f"  {feature['name']}: {feature['type']}")
-    else:
-        for col in columns:
-            print(f"  {col}: (type info not available)")
-    
-    print(f"\n{'EXAMPLE DATA':-<80}")
-    example = first_row
-    for col in columns:
-        value = example.get(col)
-        display = format_value_preview(value, args.preview)
-        print(f"\n{col}:")
-        print(f"  {display}")
-    
-    print(f"\n{'TRAINING METHOD COMPATIBILITY':-<80}")
-    
-    # SFT
-    print(f"\n[SFT] {'✓ READY' if sft_info['ready'] else '✗ NEEDS MAPPING'}")
-    if sft_info["ready"]:
-        print(f"  Reason: Dataset has '{sft_info['reason']}' field")
-        print(f"  Action: Use directly with SFTTrainer")
-    elif sft_info["possible_prompt"]:
-        print(f"  Detected: prompt='{sft_info['possible_prompt']}' response='{sft_info['possible_response']}'")
-        print(f"  Action: Apply mapping code (see below)")
-    else:
-        print(f"  Status: Cannot determine mapping - manual inspection needed")
-    
-    # DPO
-    print(f"\n[DPO] {'✓ READY' if dpo_info['ready'] else '✗ NEEDS MAPPING' if dpo_info['can_map'] else '✗ INCOMPATIBLE'}")
-    if dpo_info["ready"]:
-        print(f"  Reason: Dataset has 'prompt', 'chosen', 'rejected' fields")
-        print(f"  Action: Use directly with DPOTrainer")
-    elif dpo_info["can_map"]:
-        print(f"  Detected: prompt='{dpo_info['prompt_col']}' chosen='{dpo_info['chosen_col']}' rejected='{dpo_info['rejected_col']}'")
-        print(f"  Action: Apply mapping code (see below)")
-    else:
-        print(f"  Status: Missing required fields (prompt + chosen + rejected)")
-    
-    # GRPO
-    print(f"\n[GRPO] {'✓ READY' if grpo_info['ready'] else '✗ NEEDS MAPPING' if grpo_info['can_map'] else '✗ INCOMPATIBLE'}")
-    if grpo_info["ready"]:
-        print(f"  Reason: Dataset has 'prompt' field")
-        print(f"  Action: Use directly with GRPOTrainer")
-    elif grpo_info["can_map"]:
-        print(f"  Detected: prompt='{grpo_info['prompt_col']}'")
-        print(f"  Action: Apply mapping code (see below)")
-    else:
-        print(f"  Status: Missing prompt field")
-    
-    # KTO
-    print(f"\n[KTO] {'✓ READY' if kto_info['ready'] else '✗ INCOMPATIBLE'}")
-    if kto_info["ready"]:
-        print(f"  Reason: Dataset has 'prompt', 'completion', 'label' fields")
-        print(f"  Action: Use directly with KTOTrainer")
-    else:
-        print(f"  Status: Missing required fields (prompt + completion + label)")
-    
-    # Mapping code
-    print(f"\n{'MAPPING CODE (if needed)':-<80}")
-    
-    mapping_needed = False
-    
-    sft_mapping = generate_mapping_code("SFT", sft_info)
-    if sft_mapping:
-        print(f"\n# For SFT Training:")
-        print(sft_mapping)
-        mapping_needed = True
-    
-    dpo_mapping = generate_mapping_code("DPO", dpo_info)
-    if dpo_mapping:
-        print(f"\n# For DPO Training:")
-        print(dpo_mapping)
-        mapping_needed = True
-    
-    grpo_mapping = generate_mapping_code("GRPO", grpo_info)
-    if grpo_mapping:
-        print(f"\n# For GRPO Training:")
-        print(grpo_mapping)
-        mapping_needed = True
-    
-    if not mapping_needed:
-        print("\nNo mapping needed - dataset is ready for training!")
-    
-    print(f"\n{'SUMMARY':-<80}")
-    print(f"Recommended training methods: {', '.join(recommended) if recommended else 'None (dataset needs formatting)'}")
-    print(f"\nNote: Used Datasets Server API (instant, no download required)")
-    
-    print("\n" + "=" * 80)
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except KeyboardInterrupt:
-        sys.exit(0)
-    except Exception as e:
-        print(f"ERROR: {e}", file=sys.stderr)
-        sys.exit(1)

trl/SKILL.md

@@ -1,6 +1,6 @@
 ---
 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 and reward modeling 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.
+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
 ---
 
@@ -14,7 +14,9 @@ Train language models using TRL (Transformer Reinforcement Learning) on fully ma
 - **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
@@ -30,7 +32,7 @@ hf_doc_fetch("https://huggingface.co/docs/trl/dpo_trainer")  # DPO
 
 Use this skill when users want to:
 - Fine-tune language models on cloud GPUs without local infrastructure
-- Train with TRL methods (SFT, DPO, GRPO, etc.)
+- 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
@@ -40,7 +42,7 @@ Use this skill when users want to:
 
 When assisting with training jobs:
 
-1. **ALWAYS use `hf_jobs()` MCP tool** - Submit jobs using `hf_jobs("uv", {...})`, NOT bash `trl-jobs` commands. 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()`. If user asks to "train a model", "fine-tune", or similar requests, you MUST create the training script AND submit the job immediately using `hf_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()`. If user asks to "train a model", "fine-tune", or similar requests, you MUST create the training script AND submit the job immediately.
 
 2. **Always include Trackio** - Every training script should include Trackio for real-time monitoring. Use example scripts in `scripts/` as templates.
 
@@ -50,7 +52,7 @@ When assisting with training jobs:
 
 ## Local Script Dependencies
 
-To run scripts locally (like `estimate_cost.py`), install dependencies:
+To run scripts locally (like `validate_dataset.py`, `estimate_cost.py`), install dependencies:
 ```bash
 pip install -r requirements.txt
 ```
@@ -61,14 +63,14 @@ 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 `hf_whoami()`
+- 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)
-- **ALWAYS validate unknown datasets** before GPU training to prevent format failures (see Dataset Validation section below)
+- 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**
@@ -116,9 +118,27 @@ The job is running in the background. Ask me to check status/logs when ready!
 
 ## Quick Start: Three Approaches
 
-### Approach 1: UV Scripts (Recommended—Default Choice)
+### Approach 1: TRL Jobs Package (Easiest—Recommended for Beginners)
 
-UV scripts use PEP 723 inline dependencies for clean, self-contained training. **This is the primary approach for Claude Code.**
+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", {
@@ -165,56 +185,17 @@ trackio.finish()
 })
 ```
 
-**Benefits:** Direct MCP tool usage, clean code, dependencies declared inline (PEP 723), no file saving required, full control
-**When to use:** Default choice for all training tasks in Claude Code, custom training logic, any scenario requiring `hf_jobs()`
-
-#### Working with Scripts
-
-⚠️ **Important:** The `script` parameter accepts either inline code (as shown above) OR a URL. **Local file paths do NOT work.**
-
-**Why local paths don't work:**
-Jobs run in isolated Docker containers without access to your local filesystem. Scripts must be:
-- Inline code (recommended for custom training)
-- Publicly accessible URLs
-- Private repo URLs (with HF_TOKEN)
-
-**Common mistakes:**
-```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"})
-```
-
-**Correct approaches:**
-```python
-# ✅ Inline code (recommended)
-hf_jobs("uv", {"script": "# /// script\n# dependencies = [...]\n# ///\n\n<your code>"})
-
-# ✅ From Hugging Face Hub
-hf_jobs("uv", {"script": "https://huggingface.co/user/repo/resolve/main/train.py"})
-
-# ✅ From GitHub
-hf_jobs("uv", {"script": "https://raw.githubusercontent.com/user/repo/main/train.py"})
-
-# ✅ From Gist
-hf_jobs("uv", {"script": "https://gist.githubusercontent.com/user/id/raw/train.py"})
-```
-
-**To use local scripts:** Upload to HF Hub first:
-```bash
-huggingface-cli repo create my-training-scripts --type model
-huggingface-cli upload my-training-scripts ./train.py train.py
-# Use: https://huggingface.co/USERNAME/my-training-scripts/resolve/main/train.py
-```
+**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 2: TRL Maintained Scripts (Official Examples)
+### 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://github.com/huggingface/trl/blob/main/trl/scripts/sft.py",
+    "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",
@@ -230,7 +211,7 @@ hf_jobs("uv", {
 
 **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:** Scripts are available from https://github.com/huggingface/trl/tree/main/examples/scripts
+**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
 
@@ -246,26 +227,6 @@ hub_repo_details(["uv-scripts/classification"], repo_type="dataset", include_rea
 
 **Popular collections:** ocr, classification, synthetic-data, vllm, dataset-creation
 
-### Approach 3: TRL Jobs Package (For Terminal Use)
-
-The `trl-jobs` package provides optimized defaults and one-liner training. **Note: This approach uses bash commands, not `hf_jobs()` MCP tool.**
-
-```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 working in terminal directly (not Claude Code context), quick local experimentation
-**Repository:** https://github.com/huggingface/trl-jobs
-
-⚠️ **In Claude Code context, use Approach 1 (UV Scripts) with `hf_jobs()` instead.**
-
 ## Hardware Selection
 
 | Model Size | Recommended Hardware | Cost (approx/hr) | Use Case |
@@ -398,85 +359,6 @@ hf_jobs("logs", {"job_id": "your-job-id"})
 
 **Remember:** Wait for user to request status checks. Avoid polling repeatedly.
 
-## Dataset Validation
-
-**Validate dataset format BEFORE launching GPU training to prevent the #1 cause of training failures: format mismatches.**
-
-### Why Validate
-
-- 50%+ of training failures are due to dataset format issues
-- DPO especially strict: requires exact column names (`prompt`, `chosen`, `rejected`)
-- Failed GPU jobs waste $1-10 and 30-60 minutes
-- Validation on CPU costs ~$0.01 and takes <1 minute
-
-### When to Validate
-
-**ALWAYS validate for:**
-- Unknown or custom datasets
-- DPO training (CRITICAL - 90% of datasets need mapping)
-- Any dataset not explicitly TRL-compatible
-
-**Skip validation for known TRL datasets:**
-- `trl-lib/ultrachat_200k`, `trl-lib/Capybara`, `HuggingFaceH4/ultrachat_200k`, etc.
-
-### Usage
-
-```python
-hf_jobs("uv", {
-    "script": "https://huggingface.co/datasets/mcp-tools/skills/raw/main/dataset_inspector.py",
-    "script_args": ["--dataset", "username/dataset-name", "--split", "train"]
-})
-```
-
-The script is fast, and will usually complete synchronously.
-
-### Reading Results
-
-The output shows compatibility for each training method:
-
-- **`✓ READY`** - Dataset is compatible, use directly
-- **`✗ NEEDS MAPPING`** - Compatible but needs preprocessing (mapping code provided)
-- **`✗ INCOMPATIBLE`** - Cannot be used for this method
-
-When mapping is needed, the output includes a **"MAPPING CODE"** section with copy-paste ready Python code.
-
-### Example Workflow
-
-```python
-# 1. Inspect dataset (costs ~$0.01, <1 min on CPU)
-hf_jobs("uv", {
-    "script": "https://huggingface.co/datasets/mcp-tools/skills/raw/main/dataset_inspector.py",
-    "script_args": ["--dataset", "argilla/distilabel-math-preference-dpo", "--split", "train"]
-})
-
-# 2. Check output markers:
-#    ✓ READY → proceed with training
-#    ✗ NEEDS MAPPING → apply mapping code below
-#    ✗ INCOMPATIBLE → choose different method/dataset
-
-# 3. If mapping needed, apply before training:
-def format_for_dpo(example):
-    return {
-        'prompt': example['instruction'],
-        'chosen': example['chosen_response'],
-        'rejected': example['rejected_response'],
-    }
-dataset = dataset.map(format_for_dpo, remove_columns=dataset.column_names)
-
-# 4. Launch training job with confidence
-```
-
-### Common Scenario: DPO Format Mismatch
-
-Most DPO datasets use non-standard column names. Example:
-
-```
-Dataset has: instruction, chosen_response, rejected_response
-DPO expects: prompt, chosen, rejected
-```
-
-The validator detects this and provides exact mapping code to fix it.
-
 ## Converting Models to GGUF
 
 After training, convert models to **GGUF format** for use with llama.cpp, Ollama, LM Studio, and other local inference tools.
@@ -531,13 +413,15 @@ See `references/training_patterns.md` for detailed examples including:
 ### Dataset Misformatted
 
 **Fix:**
-1. Validate first with dataset inspector:
-   ```bash
-   uv run https://huggingface.co/datasets/mcp-tools/skills/raw/main/dataset_inspector.py \
-     --dataset name --split train
+1. Validate first: `python scripts/validate_dataset.py --dataset name --method sft`
+2. Check required columns:
+   - SFT: `messages` OR `text` OR `prompt`+`completion`
+   - DPO: `prompt`, `chosen`, `rejected`
+   - GRPO: `prompt` only
+3. Apply formatting if needed:
+   ```python
+   dataset = dataset.map(lambda x: {"text": f"User: {x['input']}\nBot: {x['output']}"})
    ```
-2. Check output for compatibility markers (✓ READY, ✗ NEEDS MAPPING, ✗ INCOMPATIBLE)
-3. Apply mapping code from inspector output if needed
 
 ### Job Timeout
 
@@ -573,7 +457,7 @@ Add to PEP 723 header:
 - 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 → Validate with dataset inspector (see Dataset Validation section)
+- 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
 
@@ -586,6 +470,7 @@ Add to PEP 723 header:
 - `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
@@ -594,12 +479,10 @@ Add to PEP 723 header:
 - `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 Scripts
-- [Dataset Inspector](https://huggingface.co/datasets/mcp-tools/skills/raw/main/dataset_inspector.py) - Validate dataset format before training (use via `uv run` or `hf_jobs`)
-
 ### External Links
 - [TRL Documentation](https://huggingface.co/docs/trl)
 - [TRL Jobs Training Guide](https://huggingface.co/docs/trl/en/jobs_training)
@@ -617,7 +500,7 @@ Add to PEP 723 header:
 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. **Use UV scripts (Approach 1)** - Default to `hf_jobs("uv", {...})` with inline scripts; TRL maintained scripts for standard training; avoid bash `trl-jobs` commands in Claude Code
-8. **Use hf_doc_fetch/hf_doc_search** for latest TRL documentation
-9. **Validate dataset format** before training with dataset inspector (see Dataset Validation section)
+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/trackio_guide.md

@@ -1,12 +1,11 @@
 # Trackio Integration for TRL Training
 
-**Trackio** is an experiment tracking library that provides real-time metrics visualization for remote training on Hugging Face Jobs infrastructure.
+**Trackio** is a local-first experiment tracking library that provides real-time metrics visualization via a Gradio dashboard.
 
-⚠️ **IMPORTANT**: For Jobs training (remote cloud GPUs):
-- Training happens on ephemeral cloud runners (not your local machine)
-- Trackio syncs metrics to a Hugging Face Space for real-time monitoring
-- Without a Space, metrics are lost when the job completes
-- The Space dashboard persists your training metrics permanently
+⚠️ **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
 
@@ -36,7 +35,7 @@ import trackio
 
 trackio.init(
     project="my-training",
-    space_id="username/trackio",  # CRITICAL for Jobs! Replace 'username' with your HF username
+    space_id="username/my-trackio-dashboard",  # CRITICAL for Jobs!
     config={
         "model": "Qwen/Qwen2.5-0.5B",
         "dataset": "trl-lib/Capybara",
@@ -79,11 +78,23 @@ Trackio automatically logs:
 ## Viewing the Dashboard
 
 After starting training:
-1. Navigate to the Space: `https://huggingface.co/spaces/username/trackio`
+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

@@ -94,6 +94,19 @@ hf_jobs("uv", {
 
 **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.
@@ -107,6 +120,21 @@ hf_jobs("uv", {
 
 **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 |
@@ -114,7 +142,9 @@ hf_jobs("uv", {
 | **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
 
@@ -126,6 +156,7 @@ hf_jobs("uv", {
 **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
 
@@ -135,9 +166,8 @@ hf_doc_fetch("https://huggingface.co/docs/trl/dataset_formats")
 ```
 
 Or validate your dataset:
-```bash
-uv run https://huggingface.co/datasets/mcp-tools/skills/raw/main/dataset_inspector.py \
-  --dataset your/dataset --split train
+```python
+# See scripts/validate_dataset.py
 ```
 
 ## See Also
@@ -145,4 +175,4 @@ uv run https://huggingface.co/datasets/mcp-tools/skills/raw/main/dataset_inspect
 - `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
-- [Dataset Inspector](https://huggingface.co/datasets/mcp-tools/skills/raw/main/dataset_inspector.py) - Dataset format validation tool
+- `scripts/validate_dataset.py` - Dataset format validation tool

trl/references/training_patterns.md

@@ -39,7 +39,7 @@ from datasets import load_dataset
 from trl import DPOTrainer, DPOConfig
 import trackio
 
-trackio.init(project="dpo-training", space_id="username/trackio")
+trackio.init(project="dpo-training", space_id="username/my-dashboard")
 
 dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
 

trl/references/troubleshooting.md

@@ -103,15 +103,8 @@ trainer = SFTTrainer(
 
 2. **Validate dataset before training:**
    ```bash
-   uv run https://huggingface.co/datasets/mcp-tools/skills/raw/main/dataset_inspector.py \
-     --dataset <dataset-name> --split train
-   ```
-   Or via hf_jobs:
-   ```python
-   hf_jobs("uv", {
-       "script": "https://huggingface.co/datasets/mcp-tools/skills/raw/main/dataset_inspector.py",
-       "script_args": ["--dataset", "dataset-name", "--split", "train"]
-   })
+   python scripts/validate_dataset.py <dataset-name> <method>
+   # e.g., python scripts/validate_dataset.py trl-lib/Capybara sft
    ```
 
 3. **Verify field names:**
@@ -257,7 +250,7 @@ If issues persist:
 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
    - `references/training_patterns.md` - Eval dataset requirements
-   - SKILL.md "Working with Scripts" section - Script format and URL 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/train_dpo_example.py

@@ -32,7 +32,7 @@ from trl import DPOTrainer, DPOConfig
 # Initialize Trackio for real-time monitoring
 trackio.init(
     project="qwen-dpo-alignment",
-    space_id="username/trackio",
+    space_id="username/my-trackio-dashboard",
     config={
         "model": "Qwen/Qwen2.5-0.5B-Instruct",
         "dataset": "trl-lib/ultrafeedback_binarized",
@@ -110,4 +110,4 @@ trainer.push_to_hub()
 trackio.finish()
 
 print("✅ Complete! Model at: https://huggingface.co/username/qwen-dpo-aligned")
-print("📊 View metrics at: https://huggingface.co/spaces/username/trackio")
+print("📊 View metrics at: https://huggingface.co/spaces/username/my-trackio-dashboard")

trl/scripts/train_grpo_example.py

@@ -36,7 +36,7 @@ from trl import GRPOTrainer, GRPOConfig
 # Initialize Trackio for real-time monitoring
 trackio.init(
     project="qwen-grpo-math",
-    space_id="username/trackio",
+    space_id="username/my-trackio-dashboard",
     config={
         "model": "Qwen/Qwen2.5-0.5B-Instruct",
         "dataset": "trl-lib/math_shepherd",
@@ -94,4 +94,4 @@ trainer.push_to_hub()
 trackio.finish()
 
 print("✅ Complete! Model at: https://huggingface.co/username/qwen-grpo-math")
-print("📊 View metrics at: https://huggingface.co/spaces/username/trackio")
+print("📊 View metrics at: https://huggingface.co/spaces/username/my-trackio-dashboard")

trl/scripts/train_sft_example.py

@@ -39,7 +39,7 @@ from trl import SFTTrainer, SFTConfig
 # Initialize Trackio for real-time monitoring
 trackio.init(
     project="qwen-capybara-sft",
-    space_id="username/trackio",  # Creates Space if it doesn't exist
+    space_id="username/my-trackio-dashboard",  # Creates Space if it doesn't exist
     config={
         "model": "Qwen/Qwen2.5-0.5B",
         "dataset": "trl-lib/Capybara",
@@ -124,4 +124,4 @@ trainer.push_to_hub()
 trackio.finish()
 
 print("✅ Complete! Model at: https://huggingface.co/username/qwen-capybara-sft")
-print("📊 View metrics at: https://huggingface.co/spaces/username/trackio")
+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()