Duplicate from saidutta69/fable-5-premium

Co-authored-by: RACER IS OP <saidutta69@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,66 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro 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
+agent_traces/train.jsonl filter=lfs diff=lfs merge=lfs -text
+openai_chat/train.jsonl filter=lfs diff=lfs merge=lfs -text
+agent_traces/test.jsonl filter=lfs diff=lfs merge=lfs -text
+agent_traces/validation.jsonl filter=lfs diff=lfs merge=lfs -text
+openai_chat/test.jsonl filter=lfs diff=lfs merge=lfs -text
+openai_chat/validation.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,117 @@
+---
+license: mit
+language:
+  - en
+tags:
+  - fable-5
+  - claude
+  - agent-traces
+  - coding
+  - tool-use
+  - sft
+  - fine-tuning
+  - distillation
+pretty_name: Fable-5 Premium Dataset
+task_categories:
+  - text-generation
+  - token-classification
+size_categories:
+  - 10K<n<100K
+---
+
+# 🧠 Fable-5 Premium Dataset
+
+<div align="center">
+  <img src="https://res.cloudinary.com/cmazqjs6/image/upload/racer_is_op_banner_branded_pu7zud.png" alt="RACER IS OP" width="100%">
+</div>
+
+<br>
+
+A **rigorously cleaned, high-quality** supervised fine-tuning (SFT) dataset built from Claude Fable-5 agent traces.
+
+> **Priorities:** Quality > Ease of Access > Quantity
+
+## 📊 Dataset Overview
+
+| Property | Value |
+|----------|-------|
+| **Total Records** | 12,730 |
+| **Train Split** | 5,728 (45.0%) |
+| **Validation Split** | 318 (2.5%) |
+| **Test Split** | 319 (2.5%) |
+| **Created** | 2026-07-30 |
+| **License** | MIT |
+
+## 📦 Formats Available
+
+This dataset is available in **two formats**:
+
+1. **OpenAI Chat Format** — Standard `messages` array with `user`/`assistant`/`tool` roles. Ready for Axolotl, Unsloth, and OpenAI fine-tuning API.
+2. **Hugging Face Agent Traces Format** — Native HF Agent Traces viewable in Data Studio.
+
+## 🔗 Sources
+
+| Source | Fable-5 Rows | Description |
+|--------|-------------|-------------|
+
+## 🧹 Quality Pipeline
+
+1. **Deduplication** — SHA-256 content hashing across all sources (cross-source dedup)
+2. **Structural Validation** — Valid message schemas, tool call IDs, proper role sequencing
+3. **Content Filtering** — Remove empty/truncated responses, error-only sessions, placeholders
+4. **PII Scrubbing** — Remove local paths, API keys, environment-specific data
+5. **Tool Call Validation** — Ensure tool calls have matching tool responses
+6. **Quality Scoring** — Multi-dimensional quality metrics
+
+## 📈 Quality Distribution
+
+<div align="center">
+  <img src="https://huggingface.co/datasets/saidutta69/fable-5-premium/resolve/main/quality_distribution.png" alt="Quality Distribution" width="100%">
+</div>
+
+| Range | Count |
+|-------|-------|
+| 0.3-0.5 | 448 |
+| 0.7-0.8 | 532 |
+| 0.8-0.9 | 3,736 |
+| 0.9-1.0 | 6,740 |
+
+## 🎯 Usage
+
+### With Hugging Face Datasets
+
+```python
+from datasets import load_dataset
+
+# Load OpenAI Chat format
+dataset = load_dataset("saidutta69/fable-5-premium", "openai_chat", split="train")
+
+# Load Agent Traces format
+traces = load_dataset("saidutta69/fable-5-premium", "agent_traces", split="train")
+```
+
+### With Axolotl
+
+```yaml
+# axolotl config
+dataset:
+  - path: saidutta69/fable-5-premium
+    type: chat_template
+    split: train
+```
+
+### With Unsloth
+
+```python
+from unsloth import FastLanguageModel
+
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name="unsloth/llama-3-8b",
+    max_seq_length=4096,
+)
+```
+
+## 🏗️ Chain-of-Thought (CoT)
+
+- **`reasoning` field** — Separate field for models that support explicit thinking tokens
+- **Embedded `<think>` tags** — CoT merged into assistant content for standard fine-tuning

agent_traces/test.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e9a4690e996336191f9fda4ade49601222cfc994dc478ab9bba6ae01e62d5087
+size 37075042

agent_traces/test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a980447fbac184f3bda1974ef2c0a500ed51f41b63ba97c5ab3996dde8055a42
+size 17368096

agent_traces/train.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d0c206918a15dee169956ab456e87d02ebe3cfff5b41fcbf722662ccf8e02e5
+size 722838391

agent_traces/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8ddf536538c1fc44428c7856750011ddfadbce930a7ef52965083c3b5c7e8b1
+size 332137349

agent_traces/validation.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60c82100d2df9d5a708be430baf3ba150c6bde6394d35f366e01c63b5cb10fa1
+size 39922752

agent_traces/validation.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:204fb75b9db5fc75218de5b9edcacfedac57f295cfdfc13c0b7db5c135d6d66b
+size 18346309

dataset_config.json

@@ -0,0 +1,16 @@
+{
+  "dataset_name": "fable-5-premium",
+  "created": "2026-07-30T18:07:24.837688",
+  "sources": [
+    "crownelius",
+    "glint_research",
+    "suayptalha",
+    "nlile_merged"
+  ],
+  "cot_strategy": "both",
+  "formats": [
+    "openai_chat",
+    "agent_traces"
+  ],
+  "total_records": 0
+}

dataset_infos.json

@@ -0,0 +1,168 @@
+{
+  "openai_chat": {
+    "description": "OpenAI Chat format with user/assistant/tool messages. Ready for Axolotl/Unsloth.",
+    "features": {
+      "messages": [
+        {
+          "role": {
+            "dtype": "string",
+            "_type": "Value"
+          },
+          "content": {
+            "dtype": "string",
+            "_type": "Value"
+          },
+          "tool_calls": [
+            {
+              "id": {
+                "dtype": "string",
+                "_type": "Value"
+              },
+              "function": {
+                "name": {
+                  "dtype": "string",
+                  "_type": "Value"
+                },
+                "arguments": {
+                  "dtype": "string",
+                  "_type": "Value"
+                }
+              }
+            }
+          ],
+          "tool_call_id": {
+            "dtype": "string",
+            "_type": "Value"
+          }
+        }
+      ],
+      "source": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "model": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "reasoning": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "quality_scores": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "data_files": [
+      {
+        "split": "train",
+        "path": "openai_chat/train.jsonl"
+      },
+      {
+        "split": "train",
+        "path": "openai_chat/train.parquet"
+      },
+      {
+        "split": "validation",
+        "path": "openai_chat/validation.jsonl"
+      },
+      {
+        "split": "validation",
+        "path": "openai_chat/validation.parquet"
+      },
+      {
+        "split": "test",
+        "path": "openai_chat/test.jsonl"
+      },
+      {
+        "split": "test",
+        "path": "openai_chat/test.parquet"
+      }
+    ]
+  },
+  "agent_traces": {
+    "description": "Hugging Face Agent Traces format. Native trace viewer in Data Studio.",
+    "features": {
+      "session_id": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "model": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "source": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "messages": [
+        {
+          "role": {
+            "dtype": "string",
+            "_type": "Value"
+          },
+          "content": {
+            "dtype": "string",
+            "_type": "Value"
+          },
+          "tool_calls": [
+            {
+              "id": {
+                "dtype": "string",
+                "_type": "Value"
+              },
+              "function": {
+                "name": {
+                  "dtype": "string",
+                  "_type": "Value"
+                },
+                "arguments": {
+                  "dtype": "string",
+                  "_type": "Value"
+                }
+              }
+            }
+          ],
+          "tool_call_id": {
+            "dtype": "string",
+            "_type": "Value"
+          }
+        }
+      ],
+      "reasoning": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "quality_scores": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "data_files": [
+      {
+        "split": "train",
+        "path": "agent_traces/train.jsonl"
+      },
+      {
+        "split": "train",
+        "path": "agent_traces/train.parquet"
+      },
+      {
+        "split": "validation",
+        "path": "agent_traces/validation.jsonl"
+      },
+      {
+        "split": "validation",
+        "path": "agent_traces/validation.parquet"
+      },
+      {
+        "split": "test",
+        "path": "agent_traces/test.jsonl"
+      },
+      {
+        "split": "test",
+        "path": "agent_traces/test.parquet"
+      }
+    ]
+  }
+}

openai_chat/test.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4efeb35786084c125a5b2c5c0c743f3825d5000f25ec6c8c804d083da89d85cf
+size 37076507

openai_chat/test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54bcb781f6677c80681c5719f84c1762d80b0d5572409828915607f1f4e008d2
+size 17423204

openai_chat/train.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91ed91067fffea5b4fb89b92ed725cdf6648ea536cb75a7d7077805b6df22ce7
+size 722871736

openai_chat/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8a004f39b05384284b04a6ae86706d9d8902a7e8b4695a0ad2afce19edaee8b
+size 332622027

openai_chat/validation.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:740a33bc80df088d7a40fc3c61d0eb10e1919bc56c83d08adfbe4dbb193b2c9a
+size 39924232

openai_chat/validation.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00b8c90c45eb261c4751b21ebc4baaf07ab5dc5f14a00bd464c35fb3f9b41f3d
+size 18380015

scripts/finetune_demo.py

@@ -0,0 +1,389 @@
+#!/usr/bin/env python3
+"""
+Fable-5 Premium: Fine-Tuning Demo
+==================================
+A complete end-to-end demonstration of fine-tuning on the
+Fable-5 Premium Dataset — shows agentic tool-use behaviour
+transfer from Claude Fable-5 traces to a small open model.
+
+What this demo measures:
+  - Tool-call formatting accuracy (before vs after fine-tune)
+  - Multi-turn agent coherence
+  - Code-writing quality improvement
+
+Requirements:
+    pip install unsloth datasets transformers trl accelerate
+
+Usage:
+    # Full run (fine-tune + eval — ~10 min on a MacBook)
+    python scripts/finetune_demo.py --mode full
+
+    # Eval only (load existing adapter)
+    python scripts/finetune_demo.py --mode eval --adapter path/to/lora
+
+    # Quick sanity check (1 batch, no training)
+    python scripts/finetune_demo.py --mode quick
+"""
+
+import argparse
+import json
+import os
+import random
+import re
+import sys
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+# ─── Config ───────────────────────────────────────────────────────────────
+
+@dataclass
+class Config:
+    """Demo configuration — tweak for your hardware."""
+    # Dataset
+    hf_dataset: str = "saidutta69/fable-5-premium"
+    hf_config: str = "openai_chat"
+    max_train_samples: int = 500       # Use 500 for demo speed; set to -1 for full
+    max_seq_length: int = 4096
+
+    # Model
+    base_model: str = "unsloth/Qwen2.5-1.5B-bnb-4bit"  # 4-bit, runs on 8GB
+    lora_r: int = 16
+    lora_alpha: int = 32
+    lora_dropout: float = 0.05
+
+    # Training
+    batch_size: int = 2
+    grad_accum: int = 4
+    learning_rate: float = 2e-4
+    num_epochs: int = 1
+    output_dir: str = "./fable5-finetune-demo"
+
+    # Eval
+    eval_samples: int = 50
+    seed: int = 42
+
+
+# ─── Data Formatting ─────────────────────────────────────────────────────
+
+def format_messages_for_training(example: Dict) -> str:
+    """
+    Convert a messages array into a training string.
+    Handles tool calls by keeping them in natural JSON-in-text format
+    so the model learns to emit tool calls inline during generation.
+    """
+    messages = example.get("messages", [])
+    parts = []
+
+    for msg in messages:
+        role = msg.get("role", "")
+        content = msg.get("content", "") or ""
+        tool_calls = msg.get("tool_calls", [])
+
+        if role == "system":
+            parts.append(f"<|system|>\n{content}\n")
+        elif role == "user":
+            parts.append(f"<|user|>\n{content}\n")
+        elif role == "assistant":
+            # Assistant may have content + tool calls
+            text = f"<|assistant|>\n{content}"
+            if tool_calls:
+                # Serialise tool calls as JSON so the model learns the format
+                calls_json = json.dumps(
+                    [{
+                        "id": tc.get("id", ""),
+                        "type": "function",
+                        "function": {
+                            "name": tc.get("function", {}).get("name", ""),
+                            "arguments": tc.get("function", {}).get("arguments", "{}"),
+                        },
+                    } for tc in tool_calls],
+                    indent=2,
+                )
+                text += f"\n<tool_calls>\n{calls_json}\n</tool_calls>"
+            text += "\n"
+            parts.append(text)
+        elif role == "tool":
+            parts.append(f"<|tool|>\n{content}\n")
+
+    return "".join(parts) + "<|assistant|>\n"
+
+
+# ─── Evaluation ──────────────────────────────────────────────────────────
+
+@dataclass
+class EvalResult:
+    tool_call_accuracy: float
+    code_completion_rate: float
+    avg_response_length: float
+    samples: int
+
+
+def extract_tool_calls(text: str) -> List[Dict]:
+    """Parse tool calls from model output."""
+    calls = []
+    # Pattern 1: JSON inside <tool_calls> tags
+    for match in re.finditer(r'<tool_calls>\s*(.*?)\s*</tool_calls>', text, re.DOTALL):
+        try:
+            parsed = json.loads(match.group(1))
+            if isinstance(parsed, list):
+                calls.extend(parsed)
+            else:
+                calls.append(parsed)
+        except json.JSONDecodeError:
+            pass
+    # Pattern 2: Direct function call JSON blocks
+    for match in re.finditer(r'\{\s*"id":\s*"[^"]+",\s*"type":\s*"function"\s*\}', text):
+        try:
+            calls.append(json.loads(match.group()))
+        except json.JSONDecodeError:
+            pass
+    return calls
+
+
+def evaluate_model(model, tokenizer, eval_dataset, num_samples: int = 50) -> EvalResult:
+    """Run a quick evaluation loop — compares model tool-call formatting against ground truth."""
+    random.seed(42)
+    indices = list(range(len(eval_dataset)))
+    random.shuffle(indices)
+    indices = indices[:num_samples]
+
+    correct_format = 0
+    total_tool_expected = 0
+    has_code = 0
+    response_lengths = []
+
+    for idx in indices:
+        example = eval_dataset[idx]
+        messages = example.get("messages", [])
+        prompt = format_messages_for_training({"messages": messages[:-1]})
+
+        # Ground truth: does the last assistant message have tool calls?
+        last_assistant = None
+        for msg in reversed(messages):
+            if msg.get("role") == "assistant":
+                last_assistant = msg
+                break
+
+        expected_tool_calls = bool(last_assistant and last_assistant.get("tool_calls"))
+        expected_code = bool(
+            last_assistant
+            and isinstance(last_assistant.get("content"), str)
+            and len(last_assistant["content"]) > 100
+        )
+
+        if expected_tool_calls:
+            total_tool_expected += 1
+
+        # Generate
+        device = next(model.parameters()).device
+        inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=2048).to(device)
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=512,
+            temperature=0.7,
+            do_sample=True,
+            pad_token_id=tokenizer.eos_token_id,
+        )
+        response = tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
+        response_lengths.append(len(response))
+
+        # Check for tool calls in output
+        generated_calls = extract_tool_calls(response)
+        if expected_tool_calls and generated_calls:
+            correct_format += 1
+
+        if len(response) > 80:
+            has_code += 1
+
+    accuracy = correct_format / total_tool_expected if total_tool_expected > 0 else 0.0
+    code_rate = has_code / num_samples
+    avg_len = sum(response_lengths) / len(response_lengths) if response_lengths else 0
+
+    return EvalResult(
+        tool_call_accuracy=accuracy,
+        code_completion_rate=code_rate,
+        avg_response_length=avg_len,
+        samples=num_samples,
+    )
+
+
+# ─── Training ────────────────────────────────────────────────────────────
+
+def train(config: Config):
+    """Fine-tune a model on Fable-5 Premium using Unsloth LoRA."""
+    print("=" * 60)
+    print("FABLE-5 PREMIUM — FINE-TUNING DEMO")
+    print("=" * 60)
+
+    # ── 1. Load dataset ───────────────────────────────────────────────
+    print(f"\n📥 Loading dataset: {config.hf_dataset}/{config.hf_config}")
+    from datasets import load_dataset
+
+    ds = load_dataset(config.hf_dataset, config.hf_config, split="train")
+    if config.max_train_samples > 0:
+        ds = ds.select(range(min(config.max_train_samples, len(ds))))
+    print(f"   Training samples: {len(ds)}")
+
+    # Split into train/eval
+    split = ds.train_test_split(test_size=config.eval_samples / len(ds), seed=config.seed)
+    train_dataset_raw = split["train"]
+    eval_dataset_raw = split["test"]  # Keep raw messages for evaluate_model()
+
+    # Format training split into text — keep eval raw for evaluation
+    def prepare_text(examples):
+        texts = [format_messages_for_training({"messages": msgs}) for msgs in examples["messages"]]
+        return {"text": texts}
+
+    train_dataset = train_dataset_raw.map(prepare_text, batched=True, remove_columns=train_dataset_raw.column_names)
+
+    # ── 2. Load model ─────────────────────────────────────────────────
+    print(f"\n🧠 Loading base model: {config.base_model}")
+    from unsloth import FastLanguageModel
+
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=config.base_model,
+        max_seq_length=config.max_seq_length,
+        dtype=None,
+        load_in_4bit=True,
+    )
+
+    # Add padding token
+    tokenizer.pad_token = tokenizer.eos_token
+    tokenizer.padding_side = "right"
+
+    # ── 3. Add LoRA ───────────────────────────────────────────────────
+    model = FastLanguageModel.get_peft_model(
+        model,
+        r=config.lora_r,
+        target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
+                        "gate_proj", "up_proj", "down_proj"],
+        lora_alpha=config.lora_alpha,
+        lora_dropout=config.lora_dropout,
+        use_gradient_checkpointing="unsloth",
+        random_state=config.seed,
+    )
+
+    print(f"   Trainable params: {sum(p.numel() for p in model.parameters() if p.requires_grad):,}")
+
+    # ── 4. Evaluate BEFORE ────────────��───────────────────────────────
+    print("\n📊 Evaluating BEFORE fine-tuning...")
+    FastLanguageModel.for_inference(model)
+    before = evaluate_model(model, tokenizer, eval_dataset_raw, config.eval_samples)
+    print(f"   Tool-call accuracy:  {before.tool_call_accuracy:.1%}")
+    print(f"   Code completion:     {before.code_completion_rate:.1%}")
+
+    # ── 5. Train ──────────────────────────────────────────────────────
+    print(f"\n🏋️  Starting fine-tuning ({config.num_epochs} epoch(s))...")
+    from trl import SFTTrainer
+    from transformers import TrainingArguments
+
+    trainer = SFTTrainer(
+        model=model,
+        tokenizer=tokenizer,
+        train_dataset=train_dataset,
+        dataset_text_field="text",
+        max_seq_length=config.max_seq_length,
+        args=TrainingArguments(
+            per_device_train_batch_size=config.batch_size,
+            gradient_accumulation_steps=config.grad_accum,
+            learning_rate=config.learning_rate,
+            num_train_epochs=config.num_epochs,
+            logging_steps=10,
+            save_strategy="no",
+            output_dir=config.output_dir,
+            report_to="none",
+            remove_unused_columns=False,
+            optim="adamw_8bit",
+            seed=config.seed,
+        ),
+    )
+
+    trainer.train()
+
+    # ── 6. Save adapter ───────────────────────────────────────────────
+    os.makedirs(config.output_dir, exist_ok=True)
+    model.save_pretrained(config.output_dir)
+    tokenizer.save_pretrained(config.output_dir)
+    print(f"\n💾 Adapter saved to: {config.output_dir}/")
+
+    # ── 7. Evaluate AFTER ─────────────────────────────────────────────
+    print("\n📊 Evaluating AFTER fine-tuning...")
+    FastLanguageModel.for_inference(model)
+    after = evaluate_model(model, tokenizer, eval_dataset_raw, config.eval_samples)
+
+    print("\n" + "=" * 60)
+    print("RESULTS")
+    print("=" * 60)
+    print(f"                  BEFORE    AFTER    Δ")
+    print(f"  Tool-call acc:  {before.tool_call_accuracy:>6.1%}  {after.tool_call_accuracy:>6.1%}  {after.tool_call_accuracy - before.tool_call_accuracy:>+6.1%}")
+    print(f"  Code rate:      {before.code_completion_rate:>6.1%}  {after.code_completion_rate:>6.1%}  {after.code_completion_rate - before.code_completion_rate:>+6.1%}")
+    print(f"  Avg response:   {before.avg_response_length:>6.0f}   {after.avg_response_length:>6.0f}  {after.avg_response_length - before.avg_response_length:>+6.0f}")
+    print("=" * 60)
+
+    # Save results
+    results = {"before": before.__dict__, "after": after.__dict__}
+    with open(os.path.join(config.output_dir, "eval_results.json"), "w") as f:
+        json.dump(results, f, indent=2)
+    print(f"📝 Results saved to: {config.output_dir}/eval_results.json")
+
+    return model, tokenizer, before, after
+
+
+# ─── Main ────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="Fable-5 Premium Fine-Tuning Demo")
+    parser.add_argument("--mode", choices=["full", "eval", "quick"], default="full",
+                        help="full = train + eval, eval = load adapter + eval, quick = sanity check")
+    parser.add_argument("--adapter", type=str, default=None,
+                        help="Path to saved LoRA adapter (for --mode eval)")
+    args = parser.parse_args()
+
+    config = Config()
+
+    if args.mode == "full":
+        train(config)
+
+    elif args.mode == "eval":
+        if not args.adapter:
+            print("❌ --adapter path required for eval mode")
+            sys.exit(1)
+
+        print("📥 Loading dataset for eval...")
+        from datasets import load_dataset
+        ds = load_dataset(config.hf_dataset, config.hf_config, split="train")
+        _, eval_dataset_raw = ds.train_test_split(
+            test_size=config.eval_samples / len(ds), seed=config.seed
+        ).values()
+
+        print(f"🧠 Loading base model + adapter from {args.adapter}...")
+        from unsloth import FastLanguageModel
+        from peft import PeftModel
+
+        base_model, tokenizer = FastLanguageModel.from_pretrained(
+            model_name=config.base_model,
+            max_seq_length=config.max_seq_length,
+            dtype=None,
+            load_in_4bit=True,
+        )
+        model = PeftModel.from_pretrained(base_model, args.adapter)
+        FastLanguageModel.for_inference(model)
+        result = evaluate_model(model, tokenizer, eval_dataset_raw, config.eval_samples)
+        print(f"\n📊 Evaluation results:")
+        print(f"   Tool-call accuracy:  {result.tool_call_accuracy:.1%}")
+        print(f"   Code completion:     {result.code_completion_rate:.1%}")
+
+    elif args.mode == "quick":
+        print("🔍 Quick sanity check: loading dataset + model (no training)")
+        from datasets import load_dataset
+        ds = load_dataset(config.hf_dataset, config.hf_config, split="train")
+        sample = ds[0]
+        print(f"   Dataset loaded: {len(ds)} samples")
+        print(f"   Sample messages: {len(sample['messages'])} turns")
+        print(f"   Formatted preview:")
+        print(format_messages_for_training(sample)[:500])
+        print("✅ Everything works!")
+
+
+if __name__ == "__main__":
+    main()