sakthai-engine.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SakThai Engine — Qwen2.5-1.5B LoRA Fine-tune\n",
    "\n",
    "**Kaggle → HF Pipeline**\n",
    "\n",
    "Trains a LoRA adapter on Qwen2.5-1.5B-Instruct and pushes to Hugging Face Hub.\n",
    "\n",
    "---\n",
    "### Setup\n",
    "Set your HF token as a **Kaggle Secret** named `HF_TOKEN`:\n",
    "1. Go to the Kaggle Notebook sidebar → **Add-ons** → **Secrets**\n",
    "2. Add a new secret with name `HF_TOKEN` and your HF write token\n",
    "3. Enable access for this notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install deps\n",
    "!pip install -qU \\\n",
    "    transformers==4.49.0 \\\n",
    "    datasets==3.5.0 \\\n",
    "    accelerate==1.6.0 \\\n",
    "    peft==0.15.2 \\\n",
    "    trl==0.18.0 \\\n",
    "    bitsandbytes==0.46.0 \\\n",
    "    huggingface_hub==0.30.1 \\\n",
    "    wandb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import torch\n",
    "from huggingface_hub import login, HfApi\n",
    "from datasets import load_dataset\n",
    "from transformers import (\n",
    "    AutoModelForCausalLM,\n",
    "    AutoTokenizer,\n",
    "    BitsAndBytesConfig,\n",
    "    TrainingArguments\n",
    ")\n",
    "from peft import LoraConfig, get_peft_model, PeftModel\n",
    "from trl import SFTTrainer\n",
    "\n",
    "# ─── Config ─────────────────────────────────────────────────\n",
    "HF_TOKEN = os.environ.get(\"HF_TOKEN\")  # Set via Kaggle Secrets\n",
    "BASE_MODEL = \"Qwen/Qwen2.5-1.5B-Instruct\"\n",
    "DATASET_ID = \"Nanthasit/sakthai-combined-v5\"  # Your existing dataset\n",
    "HF_USER = \"Nanthasit\"\n",
    "ADAPTER_REPO = f\"{HF_USER}/sakthai-1.5b-lora-kaggle\"\n",
    "MERGED_REPO = f\"{HF_USER}/sakthai-1.5b-merged-kaggle\"\n",
    "\n",
    "print(f\"Base model: {BASE_MODEL}\")\n",
    "print(f\"Dataset: {DATASET_ID}\")\n",
    "print(f\"Output adapter: {ADAPTER_REPO}\")\n",
    "print(f\"HF_TOKEN set: {HF_TOKEN is not None}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ─── Auth ───────────────────────────────────────────────────\n",
    "if HF_TOKEN:\n",
    "    login(token=HF_TOKEN, add_to_git_credential=True)\n",
    "    api = HfApi()\n",
    "    print(f\"Authenticated as: {api.whoami()['name']}\")\n",
    "else:\n",
    "    raise ValueError(\"HF_TOKEN not set! Add it as a Kaggle Secret.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ─── Load dataset ───────────────────────────────────────────\n",
    "dataset = load_dataset(DATASET_ID, split=\"train\")\n",
    "dataset = dataset.shuffle(seed=42).select(range(min(500, len(dataset))))\n",
    "\n",
    "if \"text\" not in dataset.column_names and \"messages\" in dataset.column_names:\n",
    "    # Convert chat format to text\n",
    "    def fmt(example):\n",
    "        text = \"\"\n",
    "        for msg in example[\"messages\"]:\n",
    "            role = msg[\"role\"]\n",
    "            content = msg[\"content\"]\n",
    "            if role == \"system\":\n",
    "                text += f\"<|im_start|>system\\n{content}<|im_end|>\\n\"\n",
    "            elif role == \"user\":\n",
    "                text += f\"<|im_start|>user\\n{content}<|im_end|>\\n\"\n",
    "            elif role == \"assistant\":\n",
    "                text += f\"<|im_start|>assistant\\n{content}<|im_end|>\\n\"\n",
    "        return {\"text\": text}\n",
    "    dataset = dataset.map(fmt)\n",
    "elif \"instruction\" in dataset.column_names and \"output\" in dataset.column_names:\n",
    "    def fmt(example):\n",
    "        text = f\"<|im_start|>user\\n{example['instruction']}<|im_end|>\\n<|im_start|>assistant\\n{example['output']}<|im_end|>\\n\"\n",
    "        return {\"text\": text}\n",
    "    dataset = dataset.map(fmt)\n",
    "\n",
    "dataset = dataset.train_test_split(test_size=0.05, seed=42)\n",
    "train_data = dataset[\"train\"]\n",
    "eval_data = dataset[\"test\"]\n",
    "\n",
    "print(f\"Train: {len(train_data)} samples\")\n",
    "print(f\"Eval: {len(eval_data)} samples\")\n",
    "print(f\"\\nSample:\\n{train_data[0]['text'][:300]}...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ─── Load model + tokenizer (4-bit) ────────────────────────\n",
    "quant_config = BitsAndBytesConfig(\n",
    "    load_in_4bit=True,\n",
    "    bnb_4bit_compute_dtype=torch.bfloat16,\n",
    "    bnb_4bit_quant_type=\"nf4\",\n",
    "    bnb_4bit_use_double_quant=True,\n",
    ")\n",
    "\n",
    "model = AutoModelForCausalLM.from_pretrained(\n",
    "    BASE_MODEL,\n",
    "    quantization_config=quant_config,\n",
    "    device_map=\"auto\",\n",
    "    torch_dtype=torch.bfloat16,\n",
    "    trust_remote_code=True,\n",
    ")\n",
    "\n",
    "tokenizer = AutoTokenizer.from_pretrained(\n",
    "    BASE_MODEL,\n",
    "    trust_remote_code=True,\n",
    ")\n",
    "tokenizer.pad_token = tokenizer.eos_token\n",
    "\n",
    "print(f\"Model loaded: {model.config._name_or_path}\")\n",
    "print(f\"Params: {model.num_parameters():,}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ─── LoRA config ────────────────────────────────────────────\n",
    "lora_config = LoraConfig(\n",
    "    r=16,\n",
    "    lora_alpha=32,\n",
    "    target_modules=[\"q_proj\", \"k_proj\", \"v_proj\", \"o_proj\", \"gate_proj\", \"up_proj\", \"down_proj\"],\n",
    "    lora_dropout=0.05,\n",
    "    bias=\"none\",\n",
    "    task_type=\"CAUSAL_LM\",\n",
    ")\n",
    "\n",
    "model = get_peft_model(model, lora_config)\n",
    "model.print_trainable_parameters()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ─── Training ───────────────────────────────────────────────\n",
    "training_args = TrainingArguments(\n",
    "    output_dir=\"./sakthai-lora\",\n",
    "    num_train_epochs=3,\n",
    "    per_device_train_batch_size=4,\n",
    "    per_device_eval_batch_size=4,\n",
    "    gradient_accumulation_steps=4,\n",
    "    gradient_checkpointing=True,\n",
    "    optim=\"adamw_8bit\",\n",
    "    learning_rate=2e-4,\n",
    "    lr_scheduler_type=\"cosine\",\n",
    "    warmup_ratio=0.03,\n",
    "    logging_steps=10,\n",
    "    eval_strategy=\"steps\",\n",
    "    eval_steps=50,\n",
    "    save_strategy=\"steps\",\n",
    "    save_steps=100,\n",
    "    save_total_limit=2,\n",
    "    load_best_model_at_end=True,\n",
    "    metric_for_best_model=\"eval_loss\",\n",
    "    bf16=True,\n",
    "    tf32=True,\n",
    "    report_to=\"none\",\n",
    "    push_to_hub=False,\n",
    "    ddp_find_unused_parameters=False,\n",
    ")\n",
    "\n",
    "trainer = SFTTrainer(\n",
    "    model=model,\n",
    "    tokenizer=tokenizer,\n",
    "    args=training_args,\n",
    "    train_dataset=train_data,\n",
    "    eval_dataset=eval_data,\n",
    "    max_seq_length=1024,\n",
    "    dataset_text_field=\"text\",\n",
    ")\n",
    "\n",
    "trainer.train()\n",
    "\n",
    "# ─── Save best model ────────────────────────────────────────\n",
    "trainer.save_model(\"./sakthai-lora-best\")\n",
    "tokenizer.save_pretrained(\"./sakthai-lora-best\")\n",
    "print(\"Training complete. Model saved to ./sakthai-lora-best\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ─── Push adapter to HF Hub ─────────────────────────────────\n",
    "from huggingface_hub import HfApi\n",
    "\n",
    "api = HfApi()\n",
    "\n",
    "# Create repos if they don't exist\n",
    "api.create_repo(repo_id=ADAPTER_REPO, repo_type=\"model\", exist_ok=True, private=False)\n",
    "print(f\"Adapter repo ready: {ADAPTER_REPO}\")\n",
    "\n",
    "# Upload adapter\n",
    "api.upload_folder(\n",
    "    folder_path=\"./sakthai-lora-best\",\n",
    "    repo_id=ADAPTER_REPO,\n",
    "    path_in_repo=\".\",\n",
    "    commit_message=\"LoRA adapter from Kaggle training\",\n",
    ")\n",
    "print(f\"Adapter pushed to: https://huggingface.co/{ADAPTER_REPO}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ─── (Optional) Push merged model ───────────────────────────\n",
    "# Uncomment to merge and push the full model\n",
    "# from peft import PeftModel\n",
    "# \n",
    "# base = AutoModelForCausalLM.from_pretrained(\n",
    "#     BASE_MODEL, torch_dtype=torch.bfloat16, device_map=\"auto\", trust_remote_code=True\n",
    "# )\n",
    "# merged = PeftModel.from_pretrained(base, \"./sakthai-lora-best\")\n",
    "# merged_model = merged.merge_and_unload()\n",
    "# merged_model.save_pretrained(\"./sakthai-merged\")\n",
    "# \n",
    "# api.create_repo(repo_id=MERGED_REPO, repo_type=\"model\", exist_ok=True, private=False)\n",
    "# api.upload_folder(\n",
    "#     folder_path=\"./sakthai-merged\",\n",
    "#     repo_id=MERGED_REPO,\n",
    "#     commit_message=\"Merged model from Kaggle training\",\n",
    "# )\n",
    "# print(f\"Merged model pushed to: https://huggingface.co/{MERGED_REPO}\")\n",
    "\n",
    "print(\"\\n✅ Done! Model adapter trained on Kaggle and pushed to HF Hub.\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}