feat: standalone training and merge scripts for Kaggle

- Added train_simple.py: self-contained training without package install
- Added merge_simple.py: simple LoRA merge utility
- Updated Kaggle notebook (kaggle_train_stack29_final.ipynb) to use standalone scripts
- Removes dependency on pip install -e . (broken pyproject.toml)
- Synthetic data fallback ensures training works without large datasets
- Should finally work on fresh Kaggle GPU session

kaggle_train_stack29_final.ipynb

@@ -0,0 +1,198 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 🚀 Stack 2.9 - Kaggle Training\n",
+    "\n",
+    "Free GPU training on Kaggle using Qwen2.5-Coder-7B.\n",
+    "\n",
+    "⏱️ **Runtime:** 2-4 hours  |  💾 **VRAM:** ~16GB\n",
+    "\n",
+    "**Setup:**\n",
+    "1. Settings → Accelerator → GPU **T4**\n",
+    "2. Run all cells in order\n",
+    "3. Download merged model from Output tab when done"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Check GPU\n",
+    "!nvidia-smi"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Clone repository\n",
+    "import os, shutil, subprocess\n",
+    "\n",
+    "os.chdir('/kaggle/working')\n",
+    "REPO_DIR = '/kaggle/working/stack-2.9'\n",
+    "OUTPUT_DIR = os.path.join(REPO_DIR, 'training_output')\n",
+    "\n",
+    "if os.path.exists(REPO_DIR):\n",
+    "    shutil.rmtree(REPO_DIR)\n",
+    "subprocess.run(['git', 'clone', 'https://github.com/my-ai-stack/stack-2.9.git', REPO_DIR], check=True)\n",
+    "os.chdir(REPO_DIR)\n",
+    "print('✅ Repo ready:', REPO_DIR)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Install dependencies (single command)\n",
+    "!pip install -q torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118\n",
+    "!pip install -q transformers==4.40.0 peft==0.10.0 accelerate==0.34.0 datasets==3.0.0 pyyaml tqdm scipy bitsandbytes==0.43.0\n",
+    "print('✅ Dependencies ready')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Prepare training data (auto-detect or synthetic fallback)\n",
+    "import os, json\n",
+    "\n",
+    "REPO_TRAIN_DATA = os.path.join(REPO_DIR, 'training-data/final/train.jsonl')\n",
+    "MINI_DATA_DIR = os.path.join(REPO_DIR, 'data_mini')\n",
+    "MINI_DATA_FILE = os.path.join(MINI_DATA_DIR, 'train_mini.jsonl')\n",
+    "SYNTHETIC_FILE = os.path.join(REPO_DIR, 'data/synthetic.jsonl')\n",
+    "\n",
+    "print('🔍 Data check')\n",
+    "\n",
+    "if os.path.exists(REPO_TRAIN_DATA):\n",
+    "    os.makedirs(MINI_DATA_DIR, exist_ok=True)\n",
+    "    if not os.path.exists(MINI_DATA_FILE):\n",
+    "        print('   Building mini dataset (1K samples) from full data...')\n",
+    "        !python scripts/create_mini_dataset.py --size 1000 --output {MINI_DATA_FILE} --source {REPO_TRAIN_DATA}\n",
+    "    DATA_FILE = MINI_DATA_FILE\n",
+    "    print('   Using mini dataset')\n",
+    "elif os.path.exists(MINI_DATA_FILE):\n",
+    "    DATA_FILE = MINI_DATA_FILE\n",
+    "    print('   Using existing mini dataset')\n",
+    "else:\n",
+    "    print('   Creating synthetic data (last resort)')\n",
+    "    examples = [\n",
+    "        {'instruction': 'Write a Python function to reverse a string', 'output': 'def reverse_string(s):\\n    return s[::-1]'},\n",
+    "        {'instruction': 'Write a function to check if a number is prime', 'output': 'def is_prime(n):\\n    if n <= 1:\\n        return False\\n    for i in range(2, int(n**0.5) + 1):\\n        if n % i == 0:\\n            return False\\n    return True'},\n",
+    "        {'instruction': 'Write a binary search function', 'output': 'def binary_search(arr, target):\\n    left, right = 0, len(arr) - 1\\n    while left <= right:\\n        mid = (left + right) // 2\\n        if arr[mid] == target:\\n            return mid\\n        elif arr[mid] < target:\\n            left = mid + 1\\n        else:\\n            right = mid - 1\\n    return -1'},\n",
+    "    ]\n",
+    "    samples = examples * 333\n",
+    "    os.makedirs(os.path.dirname(SYNTHETIC_FILE), exist_ok=True)\n",
+    "    with open(SYNTHETIC_FILE, 'w') as f:\n",
+    "        for s in samples:\n",
+    "            f.write(json.dumps(s) + '\\n')\n",
+    "    DATA_FILE = SYNTHETIC_FILE\n",
+    "    print(f'   Synthetic dataset: {len(samples)} examples')\n",
+    "\n",
+    "print(f'\\n✅ Data: {DATA_FILE}')\n",
+    "!ls -lh {DATA_FILE}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Generate training configuration\n",
+    "import yaml\n",
+    "\n",
+    "os.makedirs(OUTPUT_DIR, exist_ok=True)\n",
+    "\n",
+    "config = {\n",
+    "    'model': {'name': 'Qwen/Qwen2.5-Coder-7B', 'trust_remote_code': True, 'torch_dtype': 'float16'},\n",
+    "    'data': {'input_path': DATA_FILE, 'max_length': 2048, 'train_split': 1.0},\n",
+    "    'lora': {'r': 16, 'alpha': 32, 'dropout': 0.05, 'target_modules': ['q_proj', 'k_proj', 'v_proj', 'o_proj', 'gate_proj', 'up_proj', 'down_proj'], 'bias': 'none', 'task_type': 'CAUSAL_LM'},\n",
+    "    'training': {'num_epochs': 1, 'batch_size': 2, 'gradient_accumulation': 4, 'learning_rate': 2e-4, 'warmup_steps': 50, 'weight_decay': 0.01, 'max_grad_norm': 1.0, 'logging_steps': 10, 'save_steps': 100, 'save_total_limit': 2, 'fp16': True, 'bf16': False, 'gradient_checkpointing': True},\n",
+    "    'output': {'lora_dir': os.path.join(OUTPUT_DIR, 'lora'), 'logging_dir': os.path.join(OUTPUT_DIR, 'logs')},\n",
+    "    'quantization': {'enabled': False},\n",
+    "    'hardware': {'device': 'cuda', 'num_gpus': 1, 'use_4bit': False, 'use_8bit': False}\n",
+    "}\n",
+    "\n",
+    "config_path = os.path.join(OUTPUT_DIR, 'train_config.yaml')\n",
+    "with open(config_path, 'w') as f:\n",
+    "    yaml.dump(config, f, default_flow_style=False)\n",
+    "\n",
+    "print(f'✅ Config: {config_path}')\n",
+    "print(f\"   Model: {config['model']['name']}\")\n",
+    "print(f\"   Data: {config['data']['input_path']}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Train (using standalone train_simple.py - no package install needed)\n",
+    "print('='*60)\n",
+    "print('STARTING TRAINING')\n",
+    "print('='*60)\n",
+    "\n",
+    "!cd {REPO_DIR} && python train_simple.py --config {config_path}\n",
+    "\n",
+    "print('\\n✅ Training step finished')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Merge LoRA adapter into final model\n",
+    "lora_dir = os.path.join(OUTPUT_DIR, 'lora')\n",
+    "merged_dir = os.path.join(OUTPUT_DIR, 'merged')\n",
+    "\n",
+    "print('='*60)\n",
+    "print('MERGING LORA ADAPTER')\n",
+    "print('='*60)\n",
+    "\n",
+    "!cd {REPO_DIR} && python merge_simple.py \\\n",
+    "    --base-model {config['model']['name']} \\\n",
+    "    --adapter-path {lora_dir} \\\n",
+    "    --output-path {merged_dir} \\\n",
+    "    --use-safetensors\n",
+    "\n",
+    "print('\\n✅ Merge complete!')\n",
+    "print(f'Merged model: {merged_dir}')\n",
+    "!ls -lh {merged_dir}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 📥 Download Model\n",
+    "\n",
+    "1. Open **Output** tab on the right\n",
+    "2. Find `training_output/merged/`\n",
+    "3. Select all files and **Download**\n",
+    "\n",
+    "⚠️ **Do this before Kaggle session ends!**"
+   ]
+  }
+ ],
+ "metadata": {
+  "kaggle": {
+   "accelerator": "gpu"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

merge_simple.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""
+Simple LoRA merge script.
+Usage: python merge_simple.py --base-model Qwen/Qwen2.5-Coder-7B --adapter-path adapters/lora --output-path merged_model
+"""
+
+import argparse
+import os
+from pathlib import Path
+
+import torch
+from peft import PeftModel
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--base-model", type=str, required=True, help="Base model name or path")
+    parser.add_argument("--adapter-path", type=str, required=True, help="LoRA adapter directory")
+    parser.add_argument("--output-path", type=str, required=True, help="Output directory for merged model")
+    parser.add_argument("--use-safetensors", action="store_true", help="Use safetensors format")
+    args = parser.parse_args()
+
+    print("="*60)
+    print("Merging LoRA Adapter")
+    print("="*60)
+    print(f"Base model: {args.base_model}")
+    print(f"Adapter: {args.adapter_path}")
+    print(f"Output: {args.output_path}")
+
+    # Load base model
+    print("Loading base model...")
+    model = AutoModelForCausalLM.from_pretrained(
+        args.base_model,
+        torch_dtype=torch.float16,
+        device_map="auto",
+        trust_remote_code=True
+    )
+    tokenizer = AutoTokenizer.from_pretrained(args.base_model, trust_remote_code=True)
+
+    # Load and merge adapter
+    print("Loading LoRA adapter...")
+    model = PeftModel.from_pretrained(model, args.adapter_path)
+
+    print("Merging weights...")
+    model = model.merge_and_unload()
+
+    # Save
+    os.makedirs(args.output_path, exist_ok=True)
+    print(f"Saving to {args.output_path}...")
+    model.save_pretrained(args.output_path, safe_serialization=args.use_safetensors)
+    tokenizer.save_pretrained(args.output_path)
+
+    print("="*60)
+    print("✅ Merge complete!")
+    print("="*60)
+    files = list(Path(args.output_path).glob("*"))
+    print(f"Files saved ({len(files)}):")
+    for f in files:
+        print(f"  {f.name}")
+
+
+if __name__ == "__main__":
+    main()

train_simple.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+"""
+Simple standalone training script for Stack 2.9.
+No package installation required — just run: python train_simple.py --config train_config.yaml
+"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+import yaml
+from datasets import load_dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    TrainingArguments,
+    Trainer,
+    DataCollatorForLanguageModeling
+)
+from peft import LoraConfig, get_peft_model, TaskType
+import torch
+
+
+def load_config(config_path: str) -> dict:
+    with open(config_path, 'r') as f:
+        return yaml.safe_load(f)
+
+
+def load_model_and_tokenizer(model_name: str, trust_remote_code: bool = True, use_4bit: bool = False):
+    """Load base model and tokenizer."""
+    if use_4bit:
+        quantization_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_compute_dtype=torch.float16,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_use_double_quant=True
+        )
+    else:
+        quantization_config = None
+
+    tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=trust_remote_code)
+    model = AutoModelForCausalLM.from_pretrained(
+        model_name,
+        quantization_config=quantization_config,
+        torch_dtype=torch.float16,
+        trust_remote_code=trust_remote_code,
+        device_map="auto"
+    )
+    return model, tokenizer
+
+
+def load_data(data_path: str, tokenizer, max_length: int = 2048, train_split: float = 0.9):
+    """Load and tokenize dataset."""
+    raw_dataset = load_dataset("json", data_files=data_path, split="train")
+
+    def tokenize_function(examples):
+        # Combine instruction and output
+        texts = []
+        for instr, out in zip(examples.get("instruction", [""]), examples.get("output", [""])):
+            if instr and out:
+                texts.append(f"### Instruction:\n{instr}\n\n### Response:\n{out}")
+            elif out:
+                texts.append(out)
+            elif instr:
+                texts.append(instr)
+            else:
+                texts.append("")
+
+        tokenized = tokenizer(texts, truncation=True, max_length=max_length, padding="max_length")
+        tokenized["labels"] = tokenized["input_ids"].copy()
+        return tokenized
+
+    tokenized_dataset = raw_dataset.map(tokenize_function, batched=True, remove_columns=raw_dataset.column_names)
+    split = tokenized_dataset.train_test_split(train_size=train_split)
+    return split["train"], split["test"]
+
+
+def train(config: dict):
+    """Main training function."""
+    model_config = config["model"]
+    data_config = config["data"]
+    lora_config = config["lora"]
+    training_config = config["training"]
+    output_config = config["output"]
+    hardware_config = config["hardware"]
+
+    # Load model and tokenizer
+    print(f"Loading model: {model_config['name']}")
+    model, tokenizer = load_model_and_tokenizer(
+        model_name=model_config["name"],
+        trust_remote_code=model_config.get("trust_remote_code", True),
+        use_4bit=hardware_config.get("use_4bit", False)
+    )
+
+    # Load data
+    print(f"Loading dataset: {data_config['input_path']}")
+    train_dataset, eval_dataset = load_data(
+        data_path=data_config["input_path"],
+        tokenizer=tokenizer,
+        max_length=data_config.get("max_length", 2048),
+        train_split=data_config.get("train_split", 0.9)
+    )
+    print(f"   Train samples: {len(train_dataset)}")
+    print(f"   Eval samples: {len(eval_dataset)}")
+
+    # Apply LoRA
+    peft_config = LoraConfig(
+        r=lora_config["r"],
+        alpha=lora_config["alpha"],
+        dropout=lora_config["dropout"],
+        target_modules=lora_config["target_modules"],
+        bias=lora_config["bias"],
+        task_type=TaskType.CAUSAL_LM
+    )
+    model = get_peft_model(model, peft_config)
+    model.print_trainable_parameters()
+
+    # Training arguments
+    output_dir = output_config["lora_dir"]
+    os.makedirs(output_dir, exist_ok=True)
+
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        num_train_epochs=training_config["num_epochs"],
+        per_device_train_batch_size=training_config["batch_size"],
+        gradient_accumulation_steps=training_config["gradient_accumulation"],
+        learning_rate=training_config["learning_rate"],
+        warmup_steps=training_config.get("warmup_steps", 100),
+        weight_decay=training_config.get("weight_decay", 0.01),
+        max_grad_norm=training_config.get("max_grad_norm", 1.0),
+        logging_steps=training_config.get("logging_steps", 10),
+        save_steps=training_config.get("save_steps", 100),
+        save_total_limit=training_config.get("save_total_limit", 2),
+        fp16=training_config.get("fp16", True),
+        bf16=training_config.get("bf16", False),
+        gradient_checkpointing=training_config.get("gradient_checkpointing", True),
+        evaluation_strategy="steps" if eval_dataset else "no",
+        eval_steps=training_config.get("eval_steps", 100) if eval_dataset else None,
+        report_to="none",  # No WandB
+    )
+
+    data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)
+
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=eval_dataset,
+        data_collator=data_collator,
+        tokenizer=tokenizer,
+    )
+
+    print("="*60)
+    print("Starting training...")
+    print("="*60)
+    trainer.train()
+    print("Training completed!")
+
+    # Save final adapter
+    trainer.save_model(output_dir)
+    print(f"✅ Adapter saved to {output_dir}")
+
+    return trainer
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", type=str, required=True, help="Path to YAML config")
+    args = parser.parse_args()
+
+    print("="*60)
+    print("Stack 2.9 Simple Training")
+    print("="*60)
+
+    config = load_config(args.config)
+    print(f"Config loaded: {args.config}")
+    print(f"Model: {config['model']['name']}")
+    print(f"Data: {config['data']['input_path']}")
+
+    try:
+        train(config)
+        print("\n" + "="*60)
+        print("✅ TRAINING SUCCESS")
+        print("="*60)
+    except Exception as e:
+        print("\n" + "="*60)
+        print(f"❌ TRAINING FAILED: {e}")
+        print("="*60)
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()