feat(trl): improve eval dataset handling and documentation

.gitattributes

@@ -0,0 +1,59 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

README.md

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

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/gguf_conversion.md

@@ -2,7 +2,7 @@
 
 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 based on successful conversions.** All critical dependencies and build steps are included.
+**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?
 
@@ -21,119 +21,147 @@ After training models with TRL on Hugging Face Jobs, convert them to **GGUF form
 - Deploying to edge devices
 - Sharing models for local-first use
 
-## Critical Success Factors
-
-Based on production testing, these are **essential** for reliable conversion:
-
-### 1. ✅ Install Build Tools FIRST
-**Before cloning llama.cpp**, install build dependencies:
-```python
-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)
-```
+## Conversion Process
 
-**Why:** The quantization tool requires gcc and cmake. Installing after cloning doesn't help.
+**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
 
-### 2. ✅ Use CMake (Not Make)
-**Build the quantize tool with CMake:**
-```python
-# Create build directory
-os.makedirs("/tmp/llama.cpp/build", exist_ok=True)
+## GGUF Conversion Script Template
 
-# Configure
-subprocess.run([
-    "cmake", "-B", "/tmp/llama.cpp/build", "-S", "/tmp/llama.cpp",
-    "-DGGML_CUDA=OFF"  # Faster build, CUDA not needed for quantization
-], check=True, capture_output=True, text=True)
+See `scripts/convert_to_gguf.py` for a complete, production-ready conversion script.
 
-# Build
-subprocess.run([
-    "cmake", "--build", "/tmp/llama.cpp/build",
-    "--target", "llama-quantize", "-j", "4"
-], check=True, capture_output=True, text=True)
+**Quick conversion job:**
 
-# Binary path
-quantize_bin = "/tmp/llama.cpp/build/bin/llama-quantize"
-```
-
-**Why:** CMake is more reliable than `make` and produces consistent binary paths.
-
-### 3. ✅ Include All Dependencies
-**PEP 723 header must include:**
 ```python
+hf_jobs("uv", {
+    "script": """
 # /// 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",  # Required for tokenizer
-#     "protobuf>=3.20.0",        # Required for tokenizer
+#     "sentencepiece>=0.1.99",
+#     "protobuf>=3.20.0",
 #     "numpy",
 #     "gguf",
 # ]
 # ///
-```
-
-**Why:** `sentencepiece` and `protobuf` are critical for tokenizer conversion. Missing them causes silent failures.
 
-### 4. ✅ Verify Names Before Use
-**Always verify repos exist:**
-```python
-# Before submitting job, verify:
-hub_repo_details([ADAPTER_MODEL], repo_type="model")
-hub_repo_details([BASE_MODEL], repo_type="model")
-```
-
-**Why:** Non-existent dataset/model names cause job failures that could be caught in seconds.
-
-## Complete Conversion Script
+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)
 
-See `scripts/convert_to_gguf.py` for the complete, production-ready script.
+subprocess.run([
+    "git", "clone",
+    "https://github.com/ggerganov/llama.cpp.git",
+    "/tmp/llama.cpp"
+], check=True)
 
-**Key features:**
-- ✅ All dependencies in PEP 723 header
-- ✅ Build tools installed automatically
-- ✅ CMake build process (reliable)
-- ✅ Comprehensive error handling
-- ✅ Environment variable configuration
-- ✅ Automatic README generation
+subprocess.run([
+    "pip", "install", "-r",
+    "/tmp/llama.cpp/requirements.txt"
+], check=True)
 
-## Quick Conversion Job
+# 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)
 
-```python
-# Before submitting: VERIFY MODELS EXIST
-hub_repo_details(["username/my-finetuned-model"], repo_type="model")
-hub_repo_details(["Qwen/Qwen2.5-0.5B"], repo_type="model")
+subprocess.run([
+    "cmake", "-B", "/tmp/llama.cpp/build", "-S", "/tmp/llama.cpp",
+    "-DGGML_CUDA=OFF"
+], check=True)
 
-# Submit conversion job
-hf_jobs("uv", {
-    "script": open("trl/scripts/convert_to_gguf.py").read(),  # Or inline the script
+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",
-        "HF_USERNAME": "username"  # Optional, for README
+        "OUTPUT_REPO": "username/my-model-gguf"
     }
 })
 ```
 
-## Conversion Process
-
-The script performs these steps:
-
-1. **Load and Merge** - Load base model and LoRA adapter, merge them
-2. **Install Build Tools** - Install gcc, cmake (CRITICAL: before cloning llama.cpp)
-3. **Setup llama.cpp** - Clone repo, install Python dependencies
-4. **Convert to GGUF** - Create FP16 GGUF using llama.cpp converter
-5. **Build Quantize Tool** - Use CMake to build `llama-quantize`
-6. **Quantize** - Create Q4_K_M, Q5_K_M, Q8_0 versions
-7. **Upload** - Upload all versions + README to Hub
-
 ## Quantization Options
 
 Common quantization formats (from smallest to largest):
@@ -163,7 +191,7 @@ Common quantization formats (from smallest to largest):
 
 **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)
+**With Ollama (auto-detects GPU):**
 ```bash
 # Download GGUF
 huggingface-cli download username/my-model-gguf model-q4_k_m.gguf
@@ -176,7 +204,7 @@ ollama create my-model -f Modelfile
 ollama run my-model
 ```
 
-### With llama.cpp
+**With llama.cpp:**
 ```bash
 # CPU only
 ./llama-cli -m model-q4_k_m.gguf -p "Your prompt"
@@ -185,112 +213,45 @@ ollama run my-model
 ./llama-cli -m model-q4_k_m.gguf -ngl 32 -p "Your prompt"
 ```
 
-### With LM Studio
+**With LM Studio:**
 1. Download the `.gguf` file
 2. Import into LM Studio
 3. Start chatting
 
 ## Best Practices
 
-### ✅ DO:
-1. **Verify repos exist** before submitting jobs (use `hub_repo_details`)
-2. **Install build tools FIRST** before cloning llama.cpp
-3. **Use CMake** for building quantize tool (not make)
-4. **Include all dependencies** in PEP 723 header (especially sentencepiece, protobuf)
-5. **Create multiple quantizations** - Give users choice
-6. **Test on known models** before production use
-7. **Use A10G GPU** for faster conversion
-
-### ❌ DON'T:
-1. **Assume repos exist** - Always verify with hub tools
-2. **Use make** instead of CMake - Less reliable
-3. **Remove dependencies** to "simplify" - They're all needed
-4. **Skip build tools** - Quantization will fail silently
-5. **Use default paths** - CMake puts binaries in build/bin/
+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
-**Fix:**
+**Out of memory during merge:**
 - Use larger GPU (a10g-large or a100-large)
-- Ensure `device_map="auto"` for automatic placement
-- Use `dtype=torch.float16` or `torch.bfloat16`
+- Load with `device_map="auto"` for automatic device placement
+- Use `dtype=torch.float16` or `torch.bfloat16` instead of float32
 
-### Conversion fails with architecture error
-**Fix:**
+**Conversion fails with architecture error:**
 - Ensure llama.cpp supports the model architecture
-- Check for standard architecture (Qwen, Llama, Mistral, etc.)
-- Update llama.cpp to latest: `git clone --depth 1 https://github.com/ggerganov/llama.cpp.git`
-- Check llama.cpp documentation for model support
-
-### Quantization fails
-**Fix:**
-- Verify build tools installed: `apt-get install build-essential cmake`
-- Use CMake (not make) to build quantize tool
-- Check binary path: `/tmp/llama.cpp/build/bin/llama-quantize`
-- Verify FP16 GGUF exists before quantizing
-
-### Missing sentencepiece error
-**Fix:**
-- Add to PEP 723 header: `"sentencepiece>=0.1.99", "protobuf>=3.20.0"`
-- Don't remove dependencies to "simplify" - all are required
-
-### Upload fails or times out
-**Fix:**
-- Large models (>2GB) need longer timeout: `"timeout": "1h"`
-- Upload quantized versions separately if needed
-- Check network/Hub status
-
-## Lessons Learned
-
-These are from production testing and real failures:
-
-### 1. Always Verify Before Use
-**Lesson:** Don't assume repos/datasets exist. Check first.
-```python
-# BEFORE submitting job
-hub_repo_details(["trl-lib/argilla-dpo-mix-7k"], repo_type="dataset")  # Would catch error
-```
-**Prevented failures:** Non-existent dataset names, typos in model names
-
-### 2. Prioritize Reliability Over Performance
-**Lesson:** Default to what's most likely to succeed.
-- Use CMake (not make) - more reliable
-- Disable CUDA in build - faster, not needed
-- Include all dependencies - don't "simplify"
-
-**Prevented failures:** Build failures, missing binaries
-
-### 3. Create Atomic, Self-Contained Scripts
-**Lesson:** Don't remove dependencies or steps. Scripts should work as a unit.
-- All dependencies in PEP 723 header
-- All build steps included
-- Clear error messages
-
-**Prevented failures:** Missing tokenizer libraries, build tool failures
-
-## References
-
-**In this skill:**
-- `scripts/convert_to_gguf.py` - Complete, production-ready script
-
-**External:**
-- [llama.cpp Repository](https://github.com/ggerganov/llama.cpp)
-- [GGUF Specification](https://github.com/ggerganov/ggml/blob/master/docs/gguf.md)
-- [Ollama Documentation](https://ollama.ai)
-- [LM Studio](https://lmstudio.ai)
-
-## Summary
-
-**Critical checklist for GGUF conversion:**
-- [ ] Verify adapter and base models exist on Hub
-- [ ] Use production script from `scripts/convert_to_gguf.py`
-- [ ] All dependencies in PEP 723 header (including sentencepiece, protobuf)
-- [ ] Build tools installed before cloning llama.cpp
-- [ ] CMake used for building quantize tool (not make)
-- [ ] Correct binary path: `/tmp/llama.cpp/build/bin/llama-quantize`
-- [ ] A10G GPU selected for reasonable conversion time
-- [ ] Timeout set to 45m minimum
-- [ ] HF_TOKEN in secrets for Hub upload
-
-**The script in `scripts/convert_to_gguf.py` incorporates all these lessons and has been tested successfully in production.**
+- 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/reliability_principles.md

@@ -1,371 +0,0 @@
-# Reliability Principles for Training Jobs
-
-These principles are derived from real production failures and successful fixes. Following them prevents common failure modes and ensures reliable job execution.
-
-## Principle 1: Always Verify Before Use
-
-**Rule:** Never assume repos, datasets, or resources exist. Verify with tools first.
-
-### What It Prevents
-
-- **Non-existent datasets** - Jobs fail immediately when dataset doesn't exist
-- **Typos in names** - Simple mistakes like "argilla-dpo-mix-7k" vs "ultrafeedback_binarized"
-- **Incorrect paths** - Old or moved repos, renamed files
-- **Missing dependencies** - Undocumented requirements
-
-### How to Apply
-
-**Before submitting ANY job:**
-
-```python
-# Verify dataset exists
-dataset_search({"query": "dataset-name", "author": "author-name", "limit": 5})
-hub_repo_details(["author/dataset-name"], repo_type="dataset")
-
-# Verify model exists
-hub_repo_details(["org/model-name"], repo_type="model")
-
-# Check script/file paths (for URL-based scripts)
-# Verify before using: https://github.com/user/repo/blob/main/script.py
-```
-
-**Examples that would have caught errors:**
-
-```python
-# ❌ WRONG: Assumed dataset exists
-hf_jobs("uv", {
-    "script": """...""",
-    "env": {"DATASET": "trl-lib/argilla-dpo-mix-7k"}  # Doesn't exist!
-})
-
-# ✅ CORRECT: Verify first
-dataset_search({"query": "argilla dpo", "author": "trl-lib"})
-# Would show: "trl-lib/ultrafeedback_binarized" is the correct name
-
-hub_repo_details(["trl-lib/ultrafeedback_binarized"], repo_type="dataset")
-# Confirms it exists before using
-```
-
-### Implementation Checklist
-
-- [ ] Check dataset exists before training
-- [ ] Verify base model exists before fine-tuning
-- [ ] Confirm adapter model exists before GGUF conversion
-- [ ] Test script URLs are valid before submitting
-- [ ] Validate file paths in repositories
-- [ ] Check for recent updates/renames of resources
-
-**Time cost:** 5-10 seconds  
-**Time saved:** Hours of failed job time + debugging
-
----
-
-## Principle 2: Prioritize Reliability Over Performance
-
-**Rule:** Default to what is most likely to succeed, not what is theoretically fastest.
-
-### What It Prevents
-
-- **Hardware incompatibilities** - Features that fail on certain GPUs
-- **Unstable optimizations** - Speed-ups that cause crashes
-- **Complex configurations** - More failure points
-- **Build system issues** - Unreliable compilation methods
-
-### How to Apply
-
-**Choose reliability:**
-
-```python
-# ❌ RISKY: Aggressive optimization that may fail
-SFTConfig(
-    torch_compile=True,  # Can fail on T4, A10G GPUs
-    optim="adamw_bnb_8bit",  # Requires specific setup
-    fp16=False,  # May cause training instability
-    ...
-)
-
-# ✅ SAFE: Proven defaults
-SFTConfig(
-    # torch_compile=True,  # Commented with note: "Enable on H100 for 20% speedup"
-    optim="adamw_torch",  # Standard, always works
-    fp16=True,  # Stable and fast
-    ...
-)
-```
-
-**For build processes:**
-
-```python
-# ❌ UNRELIABLE: Uses make (platform-dependent)
-subprocess.run(["make", "-C", "/tmp/llama.cpp", "llama-quantize"], check=True)
-
-# ✅ RELIABLE: Uses CMake (consistent, documented)
-subprocess.run([
-    "cmake", "-B", "/tmp/llama.cpp/build", "-S", "/tmp/llama.cpp",
-    "-DGGML_CUDA=OFF"  # Disable CUDA for faster, more reliable build
-], check=True)
-
-subprocess.run([
-    "cmake", "--build", "/tmp/llama.cpp/build",
-    "--target", "llama-quantize", "-j", "4"
-], check=True)
-```
-
-### Real-World Example
-
-**The `torch.compile` failure:**
-- Added for "20% speedup" on H100
-- **Failed fatally on T4-medium** with cryptic error
-- Misdiagnosed as dataset issue (cost hours)
-- **Fix:** Disable by default, add as optional comment
-
-**Result:** Reliability > 20% performance gain
-
-### Implementation Checklist
-
-- [ ] Use proven, standard configurations by default
-- [ ] Comment out performance optimizations with hardware notes
-- [ ] Use stable build systems (CMake > make)
-- [ ] Test on target hardware before production
-- [ ] Document known incompatibilities
-- [ ] Provide "safe" and "fast" variants when needed
-
-**Performance loss:** 10-20% in best case  
-**Reliability gain:** 95%+ success rate vs 60-70%
-
----
-
-## Principle 3: Create Atomic, Self-Contained Scripts
-
-**Rule:** Scripts should work as complete, independent units. Don't remove parts to "simplify."
-
-### What It Prevents
-
-- **Missing dependencies** - Removed "unnecessary" packages that are actually required
-- **Incomplete processes** - Skipped steps that seem redundant
-- **Environment assumptions** - Scripts that need pre-setup
-- **Partial failures** - Some parts work, others fail silently
-
-### How to Apply
-
-**Complete dependency specifications:**
-
-```python
-# ❌ INCOMPLETE: "Simplified" by removing dependencies
-# /// script
-# dependencies = [
-#     "transformers",
-#     "peft",
-#     "torch",
-# ]
-# ///
-
-# ✅ COMPLETE: All dependencies explicit
-# /// 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",  # Required for tokenizers
-#     "protobuf>=3.20.0",        # Required for tokenizers
-#     "numpy",
-#     "gguf",
-# ]
-# ///
-```
-
-**Complete build processes:**
-
-```python
-# ❌ INCOMPLETE: Assumes build tools exist
-subprocess.run(["git", "clone", "https://github.com/ggerganov/llama.cpp.git", "/tmp/llama.cpp"])
-subprocess.run(["make", "-C", "/tmp/llama.cpp", "llama-quantize"])  # FAILS: no gcc/make
-
-# ✅ COMPLETE: Installs all requirements
-subprocess.run(["apt-get", "update", "-qq"], check=True)
-subprocess.run(["apt-get", "install", "-y", "-qq", "build-essential", "cmake"], check=True)
-subprocess.run(["git", "clone", "https://github.com/ggerganov/llama.cpp.git", "/tmp/llama.cpp"])
-# ... then build
-```
-
-### Real-World Example
-
-**The `sentencepiece` failure:**
-- Original script had it: worked fine
-- "Simplified" version removed it: "doesn't look necessary"
-- **GGUF conversion failed silently** - tokenizer couldn't convert
-- Hard to debug: no obvious error message
-- **Fix:** Restore all original dependencies
-
-**Result:** Don't remove dependencies without thorough testing
-
-### Implementation Checklist
-
-- [ ] All dependencies in PEP 723 header with version pins
-- [ ] All system packages installed by script
-- [ ] No assumptions about pre-existing environment
-- [ ] No "optional" steps that are actually required
-- [ ] Test scripts in clean environment
-- [ ] Document why each dependency is needed
-
-**Complexity:** Slightly longer scripts  
-**Reliability:** Scripts "just work" every time
-
----
-
-## Principle 4: Provide Clear Error Context
-
-**Rule:** When things fail, make it obvious what went wrong and how to fix it.
-
-### How to Apply
-
-**Wrap subprocess calls:**
-
-```python
-# ❌ UNCLEAR: Silent failure
-subprocess.run([...], check=True, capture_output=True)
-
-# ✅ CLEAR: Shows what failed
-try:
-    result = subprocess.run(
-        [...],
-        check=True,
-        capture_output=True,
-        text=True
-    )
-    print(result.stdout)
-    if result.stderr:
-        print("Warnings:", result.stderr)
-except subprocess.CalledProcessError as e:
-    print(f"❌ Command failed!")
-    print("STDOUT:", e.stdout)
-    print("STDERR:", e.stderr)
-    raise
-```
-
-**Validate inputs:**
-
-```python
-# ❌ UNCLEAR: Fails later with cryptic error
-model = load_model(MODEL_NAME)
-
-# ✅ CLEAR: Fails fast with clear message
-if not MODEL_NAME:
-    raise ValueError("MODEL_NAME environment variable not set!")
-
-print(f"Loading model: {MODEL_NAME}")
-try:
-    model = load_model(MODEL_NAME)
-    print(f"✅ Model loaded successfully")
-except Exception as e:
-    print(f"❌ Failed to load model: {MODEL_NAME}")
-    print(f"Error: {e}")
-    print("Hint: Check that model exists on Hub")
-    raise
-```
-
-### Implementation Checklist
-
-- [ ] Wrap external calls with try/except
-- [ ] Print stdout/stderr on failure
-- [ ] Validate environment variables early
-- [ ] Add progress indicators (✅, ❌, 🔄)
-- [ ] Include hints for common failures
-- [ ] Log configuration at start
-
----
-
-## Principle 5: Test the Happy Path on Known-Good Inputs
-
-**Rule:** Before using new code in production, test with inputs you know work.
-
-### How to Apply
-
-**Known-good test inputs:**
-
-```python
-# For training
-TEST_DATASET = "trl-lib/Capybara"  # Small, well-formatted, widely used
-TEST_MODEL = "Qwen/Qwen2.5-0.5B"  # Small, fast, reliable
-
-# For GGUF conversion
-TEST_ADAPTER = "evalstate/qwen-capybara-medium"  # Known working model
-TEST_BASE = "Qwen/Qwen2.5-0.5B"  # Compatible base
-```
-
-**Testing workflow:**
-
-1. Test with known-good inputs first
-2. If that works, try production inputs
-3. If production fails, you know it's the inputs (not code)
-4. Isolate the difference
-
-### Implementation Checklist
-
-- [ ] Maintain list of known-good test models/datasets
-- [ ] Test new scripts with test inputs first
-- [ ] Document what makes inputs "good"
-- [ ] Keep test jobs cheap (small models, short timeouts)
-- [ ] Only move to production after test succeeds
-
-**Time cost:** 5-10 minutes for test run  
-**Debugging time saved:** Hours
-
----
-
-## Summary: The Reliability Checklist
-
-Before submitting ANY job:
-
-### Pre-Flight Checks
-- [ ] **Verified** all repos/datasets exist (hub_repo_details)
-- [ ] **Tested** with known-good inputs if new code
-- [ ] **Using** proven hardware/configuration
-- [ ] **Included** all dependencies in PEP 723 header
-- [ ] **Installed** system requirements (build tools, etc.)
-- [ ] **Set** appropriate timeout (not default 30m)
-- [ ] **Configured** Hub push with HF_TOKEN
-- [ ] **Added** clear error handling
-
-### Script Quality
-- [ ] Self-contained (no external setup needed)
-- [ ] Complete dependencies listed
-- [ ] Build tools installed by script
-- [ ] Progress indicators included
-- [ ] Error messages are clear
-- [ ] Configuration logged at start
-
-### Job Configuration
-- [ ] Timeout > expected runtime + 30% buffer
-- [ ] Hardware appropriate for model size
-- [ ] Secrets include HF_TOKEN
-- [ ] Environment variables set correctly
-- [ ] Cost estimated and acceptable
-
-**Following these principles transforms job success rate from ~60-70% to ~95%+**
-
----
-
-## When Principles Conflict
-
-Sometimes reliability and performance conflict. Here's how to choose:
-
-| Scenario | Choose | Rationale |
-|----------|--------|-----------|
-| Demo/test | Reliability | Fast failure is worse than slow success |
-| Production (first run) | Reliability | Prove it works before optimizing |
-| Production (proven) | Performance | Safe to optimize after validation |
-| Time-critical | Reliability | Failures cause more delay than slow runs |
-| Cost-critical | Balanced | Test with small model, then optimize |
-
-**General rule:** Reliability first, optimize second.
-
----
-
-## Further Reading
-
-- `troubleshooting.md` - Common issues and fixes
-- `training_patterns.md` - Proven training configurations
-- `gguf_conversion.md` - Production GGUF workflow

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/convert_to_gguf.py

@@ -13,46 +13,26 @@
 # ]
 # ///
 
-"""
-GGUF Conversion Script - Production Ready
-
-This script converts a LoRA fine-tuned model to GGUF format for use with:
-- llama.cpp
-- Ollama
-- LM Studio
-- Other GGUF-compatible tools
-
-Usage:
-    Set environment variables:
-    - ADAPTER_MODEL: Your fine-tuned model (e.g., "username/my-finetuned-model")
-    - BASE_MODEL: Base model used for fine-tuning (e.g., "Qwen/Qwen2.5-0.5B")
-    - OUTPUT_REPO: Where to upload GGUF files (e.g., "username/my-model-gguf")
-    - HF_USERNAME: Your Hugging Face username (optional, for README)
-
-Dependencies: All required packages are declared in PEP 723 header above.
-Build tools (gcc, cmake) are installed automatically by this script.
-"""
-
 import os
 import torch
 from transformers import AutoModelForCausalLM, AutoTokenizer
 from peft import PeftModel
-from huggingface_hub import HfApi
+from huggingface_hub import HfApi, snapshot_download
 import subprocess
 
 print("🔄 GGUF Conversion Script")
 print("=" * 60)
 
-# Configuration from environment variables
-ADAPTER_MODEL = os.environ.get("ADAPTER_MODEL", "evalstate/qwen-capybara-medium")
-BASE_MODEL = os.environ.get("BASE_MODEL", "Qwen/Qwen2.5-0.5B")
-OUTPUT_REPO = os.environ.get("OUTPUT_REPO", "evalstate/qwen-capybara-medium-gguf")
-username = os.environ.get("HF_USERNAME", ADAPTER_MODEL.split('/')[0])
+# 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_REPO}")
+print(f"   Output repo: {OUTPUT_MODEL_NAME}")
 
 # Step 1: Load base model and adapter
 print("\n🔧 Step 1: Loading base model and LoRA adapter...")
@@ -88,21 +68,6 @@ 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...")
-
-# CRITICAL: Install build tools FIRST (before cloning llama.cpp)
-print("   Installing build tools...")
-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
-)
-print("   ✅ Build tools installed")
-
 print("   Cloning llama.cpp repository...")
 subprocess.run(
     ["git", "clone", "https://github.com/ggerganov/llama.cpp.git", "/tmp/llama.cpp"],
@@ -117,7 +82,7 @@ subprocess.run(
     check=True,
     capture_output=True
 )
-# sentencepiece and protobuf are needed for tokenizer conversion
+# Also need sentencepiece for tokenizer conversion
 subprocess.run(
     ["pip", "install", "sentencepiece", "protobuf"],
     check=True,
@@ -131,8 +96,7 @@ gguf_output_dir = "/tmp/gguf_output"
 os.makedirs(gguf_output_dir, exist_ok=True)
 
 convert_script = "/tmp/llama.cpp/convert_hf_to_gguf.py"
-model_name = ADAPTER_MODEL.split('/')[-1]
-gguf_file = f"{gguf_output_dir}/{model_name}-f16.gguf"
+gguf_file = f"{gguf_output_dir}/qwen-capybara-medium-f16.gguf"
 
 print(f"   Running: python {convert_script} {merged_dir}")
 try:
@@ -159,38 +123,16 @@ 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 using CMake (more reliable than make)
-print("   Building quantize tool with CMake...")
-try:
-    # Create build directory
-    os.makedirs("/tmp/llama.cpp/build", exist_ok=True)
-
-    # Configure with CMake
-    subprocess.run(
-        ["cmake", "-B", "/tmp/llama.cpp/build", "-S", "/tmp/llama.cpp",
-         "-DGGML_CUDA=OFF"],  # Disable CUDA for faster build
-        check=True,
-        capture_output=True,
-        text=True
-    )
-
-    # Build just the quantize tool
-    subprocess.run(
-        ["cmake", "--build", "/tmp/llama.cpp/build", "--target", "llama-quantize", "-j", "4"],
-        check=True,
-        capture_output=True,
-        text=True
-    )
-    print("   ✅ Quantize tool built")
-except subprocess.CalledProcessError as e:
-    print(f"   ❌ Build failed!")
-    print("STDOUT:", e.stdout)
-    print("STDERR:", e.stderr)
-    raise
-
-# Use the CMake build output path
-quantize_bin = "/tmp/llama.cpp/build/bin/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 = [
@@ -202,7 +144,7 @@ quant_formats = [
 quantized_files = []
 for quant_type, description in quant_formats:
     print(f"   Creating {quant_type} quantization ({description})...")
-    quant_file = f"{gguf_output_dir}/{model_name}-{quant_type.lower()}.gguf"
+    quant_file = f"{gguf_output_dir}/qwen-capybara-medium-{quant_type.lower()}.gguf"
 
     subprocess.run(
         [quantize_bin, gguf_file, quant_file, quant_type],
@@ -220,9 +162,9 @@ print("\n☁️  Step 6: Uploading to Hugging Face Hub...")
 api = HfApi()
 
 # Create repo
-print(f"   Creating repository: {OUTPUT_REPO}")
+print(f"   Creating repository: {OUTPUT_MODEL_NAME}")
 try:
-    api.create_repo(repo_id=OUTPUT_REPO, repo_type="model", exist_ok=True)
+    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}")
@@ -231,8 +173,8 @@ except Exception as e:
 print("   Uploading FP16 GGUF...")
 api.upload_file(
     path_or_fileobj=gguf_file,
-    path_in_repo=f"{model_name}-f16.gguf",
-    repo_id=OUTPUT_REPO,
+    path_in_repo="qwen-capybara-medium-f16.gguf",
+    repo_id=OUTPUT_MODEL_NAME,
 )
 print("   ✅ FP16 uploaded")
 
@@ -241,8 +183,8 @@ 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"{model_name}-{quant_type.lower()}.gguf",
-        repo_id=OUTPUT_REPO,
+        path_in_repo=f"qwen-capybara-medium-{quant_type.lower()}.gguf",
+        repo_id=OUTPUT_MODEL_NAME,
     )
     print(f"   ✅ {quant_type} uploaded")
 
@@ -258,7 +200,7 @@ tags:
 - sft
 ---
 
-# {OUTPUT_REPO.split('/')[-1]}
+# {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}).
 
@@ -273,10 +215,10 @@ This is a GGUF conversion of [{ADAPTER_MODEL}](https://huggingface.co/{ADAPTER_M
 
 | File | Quant | Size | Description | Use Case |
 |------|-------|------|-------------|----------|
-| {model_name}-f16.gguf | F16 | ~1GB | Full precision | Best quality, slower |
-| {model_name}-q8_0.gguf | Q8_0 | ~500MB | 8-bit | High quality |
-| {model_name}-q5_k_m.gguf | Q5_K_M | ~350MB | 5-bit medium | Good quality, smaller |
-| {model_name}-q4_k_m.gguf | Q4_K_M | ~300MB | 4-bit medium | Recommended - good balance |
+| 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
 
@@ -284,23 +226,23 @@ This is a GGUF conversion of [{ADAPTER_MODEL}](https://huggingface.co/{ADAPTER_M
 
 ```bash
 # Download model
-huggingface-cli download {OUTPUT_REPO} {model_name}-q4_k_m.gguf
+huggingface-cli download {OUTPUT_MODEL_NAME} qwen-capybara-medium-q4_k_m.gguf
 
 # Run with llama.cpp
-./llama-cli -m {model_name}-q4_k_m.gguf -p "Your prompt here"
+./llama-cli -m qwen-capybara-medium-q4_k_m.gguf -p "Your prompt here"
 ```
 
 ### With Ollama
 
 1. Create a `Modelfile`:
 ```
-FROM ./{model_name}-q4_k_m.gguf
+FROM ./qwen-capybara-medium-q4_k_m.gguf
 ```
 
 2. Create the model:
 ```bash
-ollama create my-model -f Modelfile
-ollama run my-model
+ollama create qwen-capybara -f Modelfile
+ollama run qwen-capybara
 ```
 
 ### With LM Studio
@@ -309,6 +251,15 @@ ollama run my-model
 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}
@@ -316,12 +267,12 @@ Inherits the license from the base model: {BASE_MODEL}
 ## Citation
 
 ```bibtex
-@misc{{{OUTPUT_REPO.split('/')[-1].replace('-', '_')},
+@misc{{qwen-capybara-medium-gguf,
   author = {{{username}}},
-  title = {{{OUTPUT_REPO.split('/')[-1]}}},
+  title = {{Qwen Capybara Medium GGUF}},
   year = {{2025}},
   publisher = {{Hugging Face}},
-  url = {{https://huggingface.co/{OUTPUT_REPO}}}
+  url = {{https://huggingface.co/{OUTPUT_MODEL_NAME}}}
 }}
 ```
 
@@ -333,18 +284,18 @@ Inherits the license from the base model: {BASE_MODEL}
 api.upload_file(
     path_or_fileobj=readme_content.encode(),
     path_in_repo="README.md",
-    repo_id=OUTPUT_REPO,
+    repo_id=OUTPUT_MODEL_NAME,
 )
 print("   ✅ README uploaded")
 
 print("\n" + "=" * 60)
 print("✅ GGUF Conversion Complete!")
-print(f"📦 Repository: https://huggingface.co/{OUTPUT_REPO}")
-print(f"\n📥 Download with:")
-print(f"   huggingface-cli download {OUTPUT_REPO} {model_name}-q4_k_m.gguf")
-print(f"\n🚀 Use with Ollama:")
+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(f"   2. Create Modelfile: FROM ./{model_name}-q4_k_m.gguf")
-print("   3. ollama create my-model -f Modelfile")
-print("   4. ollama run my-model")
+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/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()