create-walle 0.9.21 → 0.9.23

package/template/wall-e/eval/train.py

@@ -1,320 +0,0 @@
-#!/usr/bin/env python3
-"""Fine-tune a local LLM with LoRA for Wall-E personalization.
-
-Uses unsloth for efficient LoRA training and exports to GGUF format
-for direct use with Ollama.
-
-Progress is reported as JSON lines on stdout so the Node.js runner
-can parse them in real time.
-"""
-
-import argparse
-import json
-import os
-import sys
-
-# ---------------------------------------------------------------------------
-# Model registry — mirrors SUPPORTED_BASES in trainer.js
-# ---------------------------------------------------------------------------
-
-MODEL_REGISTRY = {
-    "llama3.1-8b": "unsloth/Meta-Llama-3.1-8B-Instruct",
-    "phi-4": "unsloth/Phi-4",
-    "qwen2.5-7b": "unsloth/Qwen2.5-7B-Instruct",
-    "gemma4-4b": "unsloth/gemma-4-E4B-it",
-}
-
-# LoRA target modules per architecture
-LORA_TARGETS = {
-    "llama3.1-8b": [
-        "q_proj", "k_proj", "v_proj", "o_proj",
-        "gate_proj", "up_proj", "down_proj",
-    ],
-    "phi-4": [
-        "q_proj", "k_proj", "v_proj", "dense",
-        "fc1", "fc2",
-    ],
-    "qwen2.5-7b": [
-        "q_proj", "k_proj", "v_proj", "o_proj",
-        "gate_proj", "up_proj", "down_proj",
-    ],
-    "gemma4-4b": [
-        "q_proj", "k_proj", "v_proj", "o_proj",
-        "gate_proj", "up_proj", "down_proj",
-    ],
-}
-
-
-def report(stage, pct, msg=""):
-    """Print a JSON progress line to stdout."""
-    print(json.dumps({"stage": stage, "progress": pct, "message": msg}), flush=True)
-
-
-CHAT_TEMPLATE = """<|im_start|>system
-{system}<|im_end|>
-<|im_start|>user
-{user}<|im_end|>
-<|im_start|>assistant
-{assistant}<|im_end|>"""
-
-
-def load_data(data_path, fmt="alpaca"):
-    """Load JSONL training data and convert to Alpaca-style dicts.
-
-    Args:
-        data_path: Path to JSONL file.
-        fmt: 'alpaca' or 'chat-ml'. If 'alpaca', auto-detects chat-ml
-             when the first record has a 'messages' key.
-    """
-    samples = []
-    skipped = 0
-    raw_lines = []
-    with open(data_path, "r", encoding="utf-8") as f:
-        for line in f:
-            line = line.strip()
-            if not line:
-                continue
-            try:
-                raw_lines.append(json.loads(line))
-            except json.JSONDecodeError:
-                skipped += 1
-
-    # Auto-detect format from first record
-    effective_fmt = fmt
-    if raw_lines and fmt == "alpaca":
-        first = raw_lines[0]
-        if "messages" in first and "instruction" not in first:
-            effective_fmt = "chat-ml"
-
-    for obj in raw_lines:
-        if effective_fmt == "chat-ml" and "messages" in obj:
-            msgs = obj["messages"]
-            system_text = ""
-            user_text = ""
-            assistant_text = ""
-            for m in msgs:
-                role = m.get("role", "")
-                content = m.get("content", "")
-                if role == "system":
-                    system_text = content
-                elif role == "user":
-                    user_text = content
-                elif role == "assistant":
-                    assistant_text = content
-            samples.append({
-                "instruction": CHAT_TEMPLATE.format(
-                    system=system_text, user=user_text, assistant=assistant_text
-                ),
-                "input": "",
-                "output": assistant_text,
-            })
-        elif "instruction" in obj:
-            samples.append({
-                "instruction": obj["instruction"],
-                "input": obj.get("input", ""),
-                "output": obj.get("output", ""),
-            })
-        elif "messages" in obj:
-            # Fallback: convert chat messages to instruction/output
-            msgs = obj["messages"]
-            instruction_parts = []
-            output_text = ""
-            for m in msgs:
-                role = m.get("role", "")
-                content = m.get("content", "")
-                if role in ("system", "user"):
-                    instruction_parts.append(content)
-                elif role == "assistant":
-                    output_text = content
-            samples.append({
-                "instruction": "\n".join(instruction_parts),
-                "input": "",
-                "output": output_text,
-            })
-        else:
-            # Skip unrecognised formats
-            continue
-
-    if skipped:
-        report("init", 5, f"Skipped {skipped} malformed JSONL line(s)")
-    return samples
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Fine-tune a local LLM with LoRA for Wall-E."
-    )
-    parser.add_argument("--base", required=True, help="Base model key")
-    parser.add_argument("--data", required=True, help="Path to JSONL training data")
-    parser.add_argument("--output", required=True, help="Output directory")
-    parser.add_argument("--name", default="walle-model", help="Output model name")
-    parser.add_argument("--epochs", type=int, default=3)
-    parser.add_argument("--lr", type=float, default=2e-4)
-    parser.add_argument("--lora-rank", type=int, default=16)
-    parser.add_argument("--lora-alpha", type=int, default=32)
-    parser.add_argument("--batch-size", type=int, default=4)
-    parser.add_argument("--max-seq-length", type=int, default=2048)
-    parser.add_argument("--format", choices=["alpaca", "chat-ml"], default="alpaca",
-                        help="Input data format: 'alpaca' or 'chat-ml'")
-    args = parser.parse_args()
-
-    # --- Validate base model --------------------------------------------
-    if args.base not in MODEL_REGISTRY:
-        report("error", 0, f"Unknown base model: {args.base}")
-        sys.exit(1)
-
-    hf_model = MODEL_REGISTRY[args.base]
-
-    # --- Load data ------------------------------------------------------
-    report("init", 0, "Loading training data...")
-
-    if not os.path.isfile(args.data):
-        report("error", 0, f"Data file not found: {args.data}")
-        sys.exit(1)
-
-    samples = load_data(args.data, fmt=args.format)
-    if not samples:
-        report("error", 0, "No valid training samples found in data file")
-        sys.exit(1)
-
-    report("init", 10, f"Loaded {len(samples)} training samples")
-
-    # --- Detect device capabilities ------------------------------------
-    import torch
-    use_fp16 = torch.cuda.is_available()
-
-    # --- Import unsloth -------------------------------------------------
-    report("init", 15, "Loading unsloth...")
-
-    try:
-        from unsloth import FastLanguageModel
-        from trl import SFTTrainer
-        from transformers import TrainingArguments
-        from datasets import Dataset
-    except ImportError as e:
-        missing = str(e)
-        report(
-            "error", 0,
-            f"Required package not installed ({missing}). "
-            "Install with: pip install 'unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git' "
-            "trl datasets"
-        )
-        sys.exit(1)
-
-    # --- Load model + apply LoRA ----------------------------------------
-    report("loading", 20, f"Loading base model: {hf_model}")
-
-    lora_targets = LORA_TARGETS.get(args.base, [
-        "q_proj", "k_proj", "v_proj", "o_proj",
-        "gate_proj", "up_proj", "down_proj",
-    ])
-
-    model, tokenizer = FastLanguageModel.from_pretrained(
-        model_name=hf_model,
-        max_seq_length=args.max_seq_length,
-        dtype=None,   # auto-detect
-        load_in_4bit=True,
-    )
-
-    report("loading", 40, "Applying LoRA adapter...")
-
-    model = FastLanguageModel.get_peft_model(
-        model,
-        r=args.lora_rank,
-        target_modules=lora_targets,
-        lora_alpha=args.lora_alpha,
-        lora_dropout=0,
-        bias="none",
-        use_gradient_checkpointing="unsloth",
-    )
-
-    # --- Prepare dataset ------------------------------------------------
-    report("preparing", 50, "Formatting dataset...")
-
-    alpaca_template = (
-        "Below is an instruction that describes a task, paired with an input "
-        "that provides further context. Write a response that appropriately "
-        "completes the request.\n\n"
-        "### Instruction:\n{instruction}\n\n"
-        "### Input:\n{input}\n\n"
-        "### Response:\n{output}"
-    )
-
-    def format_sample(sample):
-        return alpaca_template.format(**sample) + tokenizer.eos_token
-
-    texts = [format_sample(s) for s in samples]
-    dataset = Dataset.from_dict({"text": texts})
-
-    report("preparing", 55, f"Dataset ready: {len(dataset)} samples")
-
-    # --- Train ----------------------------------------------------------
-    report("training", 60, "Starting training...")
-
-    output_ckpt = os.path.join(args.output, f"{args.name}-checkpoints")
-    os.makedirs(output_ckpt, exist_ok=True)
-
-    training_args = TrainingArguments(
-        per_device_train_batch_size=args.batch_size,
-        gradient_accumulation_steps=4,
-        warmup_steps=5,
-        num_train_epochs=args.epochs,
-        learning_rate=args.lr,
-        fp16=use_fp16,
-        logging_steps=1,
-        optim="adamw_8bit",
-        weight_decay=0.01,
-        lr_scheduler_type="linear",
-        seed=42,
-        output_dir=output_ckpt,
-        report_to="none",
-    )
-
-    trainer = SFTTrainer(
-        model=model,
-        tokenizer=tokenizer,
-        train_dataset=dataset,
-        dataset_text_field="text",
-        max_seq_length=args.max_seq_length,
-        dataset_num_proc=2,
-        packing=False,
-        args=training_args,
-    )
-
-    train_result = trainer.train()
-    final_loss = train_result.training_loss
-
-    report("training", 85, f"Training complete. Final loss: {final_loss:.4f}")
-
-    # --- Save to GGUF ---------------------------------------------------
-    report("saving", 90, "Exporting model to GGUF format...")
-
-    model_output = os.path.join(args.output, args.name)
-    os.makedirs(model_output, exist_ok=True)
-
-    model.save_pretrained_gguf(
-        model_output,
-        tokenizer,
-        quantization_method="q4_k_m",
-    )
-
-    report("saving", 95, "GGUF export complete")
-
-    # --- Final result ---------------------------------------------------
-    report("complete", 100, f"Model saved to {model_output}")
-
-    # Print final result object (the runner parses this)
-    print(
-        json.dumps({
-            "success": True,
-            "model_path": model_output,
-            "samples_trained": len(samples),
-            "epochs": args.epochs,
-            "final_loss": round(final_loss, 6),
-        }),
-        flush=True,
-    )
-
-
-if __name__ == "__main__":
-    main()

package/template/wall-e/eval/trainer.js

@@ -1,232 +0,0 @@
-'use strict';
-
-const { spawn } = require('node:child_process');
-const path = require('node:path');
-const fs = require('node:fs');
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const SUPPORTED_BASES = {
-  'llama3.1-8b':    { ollamaName: 'llama3.1:8b-instruct-q4_K_M', huggingFace: 'unsloth/Meta-Llama-3.1-8B-Instruct' },
-  'phi-4':          { ollamaName: 'phi4:latest',                   huggingFace: 'unsloth/Phi-4' },
-  'qwen2.5-7b':    { ollamaName: 'qwen2.5:7b-instruct-q4_K_M',   huggingFace: 'unsloth/Qwen2.5-7B-Instruct' },
-  'gemma4-4b':      { ollamaName: 'gemma4:e4b',                    huggingFace: 'unsloth/gemma-4-E4B-it' },
-};
-
-const DEFAULT_HYPERPARAMS = {
-  epochs:       3,
-  lr:           2e-4,
-  loraRank:     16,
-  loraAlpha:    32,
-  batchSize:    4,
-  maxSeqLength: 2048,
-};
-
-const TRAIN_SCRIPT = path.join(__dirname, 'train.py');
-
-// ---------------------------------------------------------------------------
-// Command builder (exported for testing)
-// ---------------------------------------------------------------------------
-
-/**
- * Build the CLI args array for the Python training script.
- * @param {Object} opts - Same shape as trainModel options
- * @returns {string[]} args array (without 'python3' prefix)
- */
-function buildTrainCommand(opts) {
-  const hp = { ...DEFAULT_HYPERPARAMS, ...opts.hyperparams };
-  const outputName = opts.outputName || `walle-${opts.baseModel}-v1`;
-
-  const args = [
-    TRAIN_SCRIPT,
-    '--base',           opts.baseModel,
-    '--data',           opts.dataPath,
-    '--output',         opts.outputDir,
-    '--name',           outputName,
-    '--epochs',         String(hp.epochs),
-    '--lr',             String(hp.lr),
-    '--lora-rank',      String(hp.loraRank),
-    '--lora-alpha',     String(hp.loraAlpha),
-    '--batch-size',     String(hp.batchSize),
-    '--max-seq-length', String(hp.maxSeqLength),
-  ];
-
-  if (opts.format) {
-    args.push('--format', opts.format);
-  }
-
-  return args;
-}
-
-// ---------------------------------------------------------------------------
-// Main entry point
-// ---------------------------------------------------------------------------
-
-/**
- * Run fine-tuning for a base model.
- * @param {Object} options
- * @param {string} options.baseModel      - Base model name: 'llama3.1-8b', 'phi-4', 'qwen2.5-7b', 'gemma4-4b'
- * @param {string} options.dataPath       - Path to JSONL training data
- * @param {string} options.outputDir      - Where to save the model
- * @param {string} [options.outputName]   - Model name (default: 'walle-{base}-v1')
- * @param {Object} [options.hyperparams]  - Override training hyperparams
- * @param {Function} [options.onProgress] - Progress callback ({ stage, progress, message })
- * @returns {Promise<{ success: boolean, modelPath: string, metrics: Object, error?: string }>}
- */
-const DEFAULT_TIMEOUT = 7200000; // 2 hours
-const SAFE_NAME_RE = /^[a-zA-Z0-9._-]+$/;
-const MAX_STDERR = 10240; // 10 KB
-
-async function trainModel(options) {
-  // --- Validate --------------------------------------------------------
-  if (!options || !options.dataPath) {
-    throw new Error('dataPath is required');
-  }
-  if (!options.baseModel) {
-    throw new Error('baseModel is required');
-  }
-  if (!options.outputDir) {
-    throw new Error('outputDir is required');
-  }
-  if (!SUPPORTED_BASES[options.baseModel]) {
-    throw new Error(
-      `Unsupported base model "${options.baseModel}". ` +
-      `Supported: ${Object.keys(SUPPORTED_BASES).join(', ')}`
-    );
-  }
-  if (options.outputName && !SAFE_NAME_RE.test(options.outputName)) {
-    throw new Error(
-      `Invalid outputName "${options.outputName}". Must match ${SAFE_NAME_RE}`
-    );
-  }
-  if (!fs.existsSync(options.dataPath)) {
-    throw new Error(`Training data not found: ${options.dataPath}`);
-  }
-
-  // --- Build command ---------------------------------------------------
-  const args = buildTrainCommand(options);
-  const onProgress = options.onProgress || (() => {});
-
-  // --- Spawn Python subprocess -----------------------------------------
-  const timeout = options.timeout || DEFAULT_TIMEOUT;
-
-  return new Promise((resolve, reject) => {
-    const proc = spawn('python3', args, {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      env: { ...process.env },
-      timeout,
-    });
-
-    let stderr = '';
-    let lastResult = null;
-    let stdoutBuffer = '';
-
-    proc.stdout.on('data', (chunk) => {
-      stdoutBuffer += chunk.toString();
-      const lines = stdoutBuffer.split('\n');
-      stdoutBuffer = lines.pop(); // keep incomplete trailing line
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          const msg = JSON.parse(line);
-          if (msg.stage) {
-            onProgress(msg);
-          }
-          // Keep the last JSON object as the final result
-          lastResult = msg;
-        } catch {
-          // Non-JSON output, ignore
-        }
-      }
-    });
-
-    proc.stderr.on('data', (chunk) => {
-      stderr += chunk.toString();
-      if (stderr.length > MAX_STDERR) stderr = stderr.slice(-MAX_STDERR);
-    });
-
-    proc.on('error', (err) => {
-      reject(new Error(`Failed to spawn python3: ${err.message}`));
-    });
-
-    proc.on('close', (code) => {
-      // Parse any remaining buffered stdout
-      if (stdoutBuffer.trim()) {
-        try {
-          const msg = JSON.parse(stdoutBuffer);
-          if (msg.stage) onProgress(msg);
-          lastResult = msg;
-        } catch {
-          // Non-JSON output, ignore
-        }
-      }
-
-      if (code !== 0) {
-        const errMsg = stderr.trim() || (lastResult && lastResult.message) || `Process exited with code ${code}`;
-        resolve({
-          success: false,
-          modelPath: '',
-          metrics: {},
-          error: errMsg,
-        });
-        return;
-      }
-
-      if (lastResult && lastResult.success) {
-        resolve({
-          success: true,
-          modelPath: lastResult.model_path || '',
-          modelName: lastResult.model_name || '',
-          metrics: {
-            samplesTrained: lastResult.samples_trained,
-            epochs: lastResult.epochs,
-            ...(lastResult.final_loss != null && { finalLoss: lastResult.final_loss }),
-          },
-        });
-      } else {
-        resolve({
-          success: false,
-          modelPath: '',
-          metrics: {},
-          error: lastResult?.message || 'Training completed but no success result received',
-        });
-      }
-    });
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Version helper
-// ---------------------------------------------------------------------------
-
-/**
- * Get the next version number for a model based on existing training runs.
- * @param {Object|null} brain - Brain module (for querying training_runs)
- * @param {string} baseModel - Base model key (e.g. 'phi-4')
- * @returns {number} Next version number (starting from 1)
- */
-function getNextVersion(brain, baseModel) {
-  if (!brain) return 1;
-  const runs = brain.getTrainingRuns({});
-  const versions = runs
-    .filter(r => r.base_model === baseModel)
-    .map(r => {
-      const match = r.model_name.match(/-v(\d+)$/);
-      return match ? parseInt(match[1]) : 0;
-    });
-  return versions.length > 0 ? Math.max(...versions) + 1 : 1;
-}
-
-module.exports = {
-  trainModel,
-  buildTrainCommand,
-  getNextVersion,
-  SUPPORTED_BASES,
-  DEFAULT_HYPERPARAMS,
-  DEFAULT_TIMEOUT,
-  SAFE_NAME_RE,
-  MAX_STDERR,
-  TRAIN_SCRIPT,
-};