Upload EthicalHacking_Qwen3-4B_Ultimate_Colab.ipynb

EthicalHacking_Qwen3-4B_Ultimate_Colab.ipynb

@@ -4,27 +4,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# 🔐 Ultimate Ethical Hacking LLM – Colab Free Tier (T4)\n",
+    "# 🔐 Ultimate Ethical Hacking / General-Purpose LLM – Colab Free Tier (T4)\n",
     "\n",
     "**🥇 Model:** [Qwen3-4B-Instruct-2507](https://huggingface.co/Qwen/Qwen3-4B-Instruct-2507) via Unsloth 4-bit  \n",
-    "**🏆 Why this model?** Highest coding/reasoning scores among sub-10B models with confirmed Unsloth support (LiveCodeBench 35.1, MMLU-Pro 69.6). Only **3.3 GB** in 4-bit — massive VRAM headroom on T4.  \n",
-    "**📊 Datasets:** [Fenrir v2.1](https://huggingface.co/datasets/AlicanKiraz0/Cybersecurity-Dataset-Fenrir-v2.1) + [Trendyol Cybersecurity](https://huggingface.co/datasets/Trendyol/Trendyol-Cybersecurity-Instruction-Tuning-Dataset) — 153K+ instruction pairs  \n",
+    "**🏆 Why this model?** Highest coding/reasoning scores among sub-10B models (LiveCodeBench 35.1, MMLU-Pro 69.6). Only **3.3 GB** in 4-bit.  \n",
+    "**📊 Datasets:** Your choice — pick from cybersecurity, general chat, multilingual, coding, or mix them!  \n",
     "**⚡ Framework:** Unsloth + TRL SFTTrainer — 2× faster, 70% less VRAM  \n",
     "\n",
-    "> ⚠️ **Disclaimer:** This trains on **defensive cybersecurity** datasets only (pentesting education, threat analysis, CTF write-ups, incident response). Intended for **ethical hacking education and security research**.\n",
-    "\n",
-    "---\n",
-    "\n",
-    "## 🚀 Speed Optimizations Applied (vs v1)\n",
-    "\n",
-    "| Setting | v1 (slow) | v2 (this notebook) | Why |\n",
-    "|---------|-----------|-------------------|-----|\n",
-    "| Dataset size | 153K rows | **50K rows** (sampled) | LoRA converges fast; 50K is plenty |\n",
-    "| Batch size | 2 | **4** | You have 11GB free VRAM! |\n",
-    "| Grad accum | 4 | **2** | Effective batch still = 8 |\n",
-    "| Packing | False | **True** | 2-3× throughput boost |\n",
-    "| Max steps | Full epoch (19K) | **4,000** | Loss plateaus ~0.70 by step 300 |\n",
-    "| **Est. time** | ~45 hrs | **~3-4 hrs** | Same quality, massively faster |\n",
+    "> ⚠️ **Disclaimer:** Default datasets include **defensive cybersecurity** content (pentesting education, threat analysis, IR). Pick general-purpose datasets for other domains.\n",
     "\n",
     "---\n",
     "\n",
@@ -32,13 +19,12 @@
     "\n",
     "| Setting | Value | Why |\n",
     "|---------|-------|-----|\n",
-    "| `MAX_SEQ_LENGTH` | 4096 | Qwen3-4B has huge headroom on T4 |\n",
-    "| `LORA_R` | 64 | Can afford higher rank thanks to small base model |\n",
-    "| `BATCH_SIZE` | 4 | You have 11GB free after base model loads |\n",
+    "| `MAX_SEQ_LENGTH` | 4096 | Huge headroom on T4 |\n",
+    "| `LORA_R` | 64 | Higher rank = more capacity |\n",
+    "| `BATCH_SIZE` | 4 | You have ~11GB free VRAM |\n",
     "| `GRAD_ACCUM` | 2 | Effective batch = 8 |\n",
-    "| `PACKING` | True | 2-3× speedup for short chat examples |\n",
+    "| `PACKING` | True | 2-3× throughput boost |\n",
     "| `optim` | `adamw_8bit` | Massive VRAM saver |\n",
-    "| `dtype` | fp16 | T4 has no bf16 |\n",
     "\n",
     "If you still hit OOM → lower `MAX_SEQ_LENGTH` to 3072 or set `use_rslora=True`."
    ]
@@ -47,9 +33,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 1️⃣ Install Dependencies\n",
-    "\n",
-    "Unsloth + TRL + Datasets. Takes ~3–5 min on Colab."
+    "## 1️⃣ Install Dependencies"
    ]
   },
   {
@@ -66,12 +50,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 2️⃣ (Optional) Login to HuggingFace Hub\n",
-    "\n",
-    "Needed if you want to **push the fine-tuned model** back to your HF account.\n",
-    "\n",
-    "- Get token: [hf.co/settings/tokens](https://huggingface.co/settings/tokens)  \n",
-    "- Create a model repo first (e.g. `your-username/cyber-qwen3-4b-lora`)"
+    "## 2️⃣ (Optional) Login to HuggingFace Hub"
    ]
   },
   {
@@ -88,12 +67,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 3️⃣ Load Qwen3-4B-Instruct-2507 in 4-bit via Unsloth\n",
-    "\n",
-    "This is the **best small model for coding & reasoning** as of May 2026.\n",
-    "- Already **instruct-tuned** — your cybersecurity LoRA builds on solid foundations.\n",
-    "- **Thinking toggle** (`enable_thinking=True/False`) for deep chain-of-thought exploit analysis.\n",
-    "- Only ~3.3 GB quantized → leaves **~12 GB** for training on a T4."
+    "## 3️⃣ Load Qwen3-4B-Instruct-2507 in 4-bit via Unsloth"
    ]
   },
   {
@@ -106,26 +80,25 @@
     "import torch\n",
     "\n",
     "# ==================== T4-COLAB HYPERPARAMETERS ====================\n",
-    "MAX_SEQ_LENGTH = 4096          # Qwen3-4B headroom on T4 is HUGE\n",
-    "LORA_R = 64                    # higher rank = more capacity for exploit patterns\n",
-    "LORA_ALPHA = 64                # alpha = r is standard\n",
-    "BATCH_SIZE = 4                 # ← INCREASED: you have 11GB free VRAM!\n",
-    "GRAD_ACCUM = 2                 # ← REDUCED: effective batch still = 8\n",
-    "LEARNING_RATE = 2e-4           # conservative LoRA LR\n",
-    "NUM_EPOCHS = 1                 # we'll cap with max_steps instead\n",
-    "MAX_STEPS = 4000               # ← NEW: cap steps for speed (loss plateaus early)\n",
-    "WARMUP_STEPS = 200             # ← INCREASED: more warmup for stability\n",
-    "LOGGING_STEPS = 50             # ← INCREASED: less log spam\n",
-    "SAVE_STEPS = 500               # ← save less often for speed\n",
-    "PACKING = True                 # ← NEW: massive throughput boost!\n",
-    "SAMPLE_SIZE = 50000            # ← NEW: subsample dataset for 3× speedup\n",
-    "HUB_MODEL_ID = \"your-username/cyber-qwen3-4b-lora\"   # ← change before pushing\n",
+    "MAX_SEQ_LENGTH = 4096\n",
+    "LORA_R = 64\n",
+    "LORA_ALPHA = 64\n",
+    "BATCH_SIZE = 4\n",
+    "GRAD_ACCUM = 2\n",
+    "LEARNING_RATE = 2e-4\n",
+    "MAX_STEPS = 4000\n",
+    "WARMUP_STEPS = 200\n",
+    "LOGGING_STEPS = 50\n",
+    "SAVE_STEPS = 500\n",
+    "PACKING = True\n",
+    "SAMPLE_SIZE = 50000\n",
+    "HUB_MODEL_ID = \"your-username/cyber-qwen3-4b-lora\"\n",
     "# ==================================================================\n",
     "\n",
     "model, tokenizer = FastLanguageModel.from_pretrained(\n",
     "    model_name=\"unsloth/Qwen3-4B-Instruct-2507-unsloth-bnb-4bit\",\n",
     "    max_seq_length=MAX_SEQ_LENGTH,\n",
-    "    dtype=None,                   # auto-detect (fp16 on T4)\n",
+    "    dtype=None,\n",
     "    load_in_4bit=True,\n",
     ")\n",
     "\n",
@@ -135,29 +108,39 @@
     "    target_modules=[\"q_proj\", \"k_proj\", \"v_proj\", \"o_proj\",\n",
     "                   \"gate_proj\", \"up_proj\", \"down_proj\"],\n",
     "    lora_alpha=LORA_ALPHA,\n",
-    "    lora_dropout=0,               # 0 = fastest; data is large enough\n",
+    "    lora_dropout=0,\n",
     "    bias=\"none\",\n",
-    "    use_gradient_checkpointing=\"unsloth\",  # ~30% VRAM reduction\n",
+    "    use_gradient_checkpointing=\"unsloth\",\n",
     "    random_state=3407,\n",
-    "    use_rslora=False,             # set True for even smaller VRAM footprint\n",
+    "    use_rslora=False,\n",
     "    loftq_config=None,\n",
     ")\n",
     "\n",
     "trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
     "total     = sum(p.numel() for p in model.parameters())\n",
-    "print(f\"✅ Qwen3-4B loaded. Trainable params: {trainable:,} / {total:,} ({100*trainable/total:.2f}%)\")\n",
-    "print(f\"📊 Estimated VRAM used by base model: ~3.3 GB (4-bit)\")\n",
-    "print(f\"🚀 Free VRAM for training: ~{15.64 - 4.12:.1f} GB (on T4 16GB)\")"
+    "print(f\"✅ Qwen3-4B loaded. Trainable params: {trainable:,} / {total:,} ({100*trainable/total:.2f}%)\")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 4️⃣ Load, Audit, Subsample & Merge Cybersecurity Datasets\n",
+    "## 4️⃣ 🎯 CHOOSE YOUR DATASET(S)\n",
+    "\n",
+    "Uncomment **ONE** `DATASET_CHOICE` line to select your training data. You can also mix multiple datasets by setting a list.\n",
+    "\n",
+    "| Choice | Dataset | Size | Format | Best For |\n",
+    "|--------|---------|------|--------|----------|\n",
+    "| `\"cybersecurity\"` | Fenrir v2.1 + Trendyol | 153K → 50K | system/user/assistant | **Ethical hacking, pentesting education** |\n",
+    "| `\"ultrachat\"` | UltraChat 200K (SFT) | 200K → 50K | messages (user/assistant) | General conversation, chatbot tuning |\n",
+    "| `\"openhermes\"` | OpenHermes 2.5 | 1M+ → 50K | conversations (human/gpt) | Reasoning, coding, instruction following |\n",
+    "| `\"sharegpt_en\"` | ShareGPT English | ~90K → 50K | conversations (human/gpt) | Multi-turn dialogue, general QA |\n",
+    "| `\"sharegpt_de\"` | ShareGPT German | ~104K → 50K | conversations (human/gpt) | German language fine-tuning |\n",
+    "| `\"sharegpt_hi\"` | ShareGPT Hindi (27B) | ~153K → 50K | conversations (human/gpt) | Hindi language fine-tuning |\n",
+    "| `\"custom_mix\"` | Mix of your choice | — | varies | Combine datasets for hybrid tuning |\n",
     "\n",
-    "We load **two SOTA defensive-cybersecurity datasets**, audit them, **subsample to 50K rows** for speed,\n",
-    "and convert to TRL `messages` format."
+    "\n",
+    "**To mix datasets**, set `DATASET_CHOICE = \"custom_mix\"` and configure `CUSTOM_DATASETS` below."
    ]
   },
   {
@@ -167,59 +150,162 @@
    "outputs": [],
    "source": [
     "from datasets import load_dataset, concatenate_datasets\n",
+    "\n",
+    "# ═══════════════════════════════════════════════════════════════\n",
+    "#   SELECT YOUR DATASET — UNCOMMENT ONE LINE\n",
+    "# ═══════════════════════════════════════════════════════════════\n",
+    "\n",
+    "# --- Option 1: Cybersecurity (default) ---\n",
+    "DATASET_CHOICE = \"cybersecurity\"\n",
+    "\n",
+    "# --- Option 2: General-purpose chat (UltraChat) ---\n",
+    "# DATASET_CHOICE = \"ultrachat\"\n",
+    "\n",
+    "# --- Option 3: Reasoning & coding (OpenHermes 2.5) ---\n",
+    "# DATASET_CHOICE = \"openhermes\"\n",
+    "\n",
+    "# --- Option 4: Multi-turn dialogue (ShareGPT English) ---\n",
+    "# DATASET_CHOICE = \"sharegpt_en\"\n",
+    "\n",
+    "# --- Option 5: German language (ShareGPT German) ---\n",
+    "# DATASET_CHOICE = \"sharegpt_de\"\n",
+    "\n",
+    "# --- Option 6: Hindi language (ShareGPT Hindi 27B) ---\n",
+    "# DATASET_CHOICE = \"sharegpt_hi\"\n",
+    "\n",
+    "# --- Option 7: Mix multiple datasets ---\n",
+    "# DATASET_CHOICE = \"custom_mix\"\n",
+    "\n",
+    "# ═══════════════════════════════════════════════════════════════\n",
+    "#   CUSTOM MIX CONFIG (only used if DATASET_CHOICE = \"custom_mix\")\n",
+    "# ═══════════════════════════════════════════════════════════════\n",
+    "CUSTOM_DATASETS = [\n",
+    "    # (\"dataset_name_or_id\", \"split\", rows_to_take, \"format_type\")\n",
+    "    # format_type: \"messages\" | \"conversations\" | \"instruction\"\n",
+    "    (\"AlicanKiraz0/Cybersecurity-Dataset-Fenrir-v2.1\", \"train\", 10000, \"messages\"),\n",
+    "    (\"HuggingFaceH4/ultrachat_200k\", \"train_sft\", 20000, \"messages\"),\n",
+    "    (\"teknium/OpenHermes-2.5\", \"train\", 20000, \"conversations\"),\n",
+    "]\n",
+    "\n",
+    "print(f\"🎯 DATASET_CHOICE = {DATASET_CHOICE}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5️⃣ Load, Convert & Pre-process Selected Dataset\n",
+    "\n",
+    "This cell auto-detects the dataset format and converts everything to standard `messages` → `text` pipeline.\n",
+    "**No changes needed** — just run it after selecting your dataset above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "import random\n",
     "\n",
-    "# ---------- Dataset 1: Fenrir v2.1 (99,870 rows) ----------\n",
-    "print(\"📥 Loading Fenrir v2.1...\")\n",
-    "ds1 = load_dataset(\"AlicanKiraz0/Cybersecurity-Dataset-Fenrir-v2.1\", split=\"train\")\n",
-    "print(f\"   Rows: {len(ds1)} | Columns: {ds1.column_names}\")\n",
-    "\n",
-    "# Quick audit: print 2 random samples\n",
-    "for i in random.sample(range(len(ds1)), 2):\n",
-    "    print(f\"\\n--- Sample {i} ---\")\n",
-    "    print(f\"SYSTEM: {ds1[i]['system'][:120]}...\")\n",
-    "    print(f\"USER:   {ds1[i]['user'][:120]}...\")\n",
-    "    print(f\"ASSIST: {ds1[i]['assistant'][:120]}...\")\n",
-    "\n",
-    "def fenrir_to_messages(example):\n",
-    "    return {\n",
-    "        \"messages\": [\n",
-    "            {\"role\": \"system\",    \"content\": example[\"system\"]},\n",
-    "            {\"role\": \"user\",      \"content\": example[\"user\"]},\n",
-    "            {\"role\": \"assistant\", \"content\": example[\"assistant\"]},\n",
-    "        ]\n",
-    "    }\n",
-    "\n",
-    "ds1 = ds1.map(fenrir_to_messages, remove_columns=ds1.column_names, batched=False)\n",
-    "print(f\"✅ Fenrir converted to messages. Sample roles: {[m['role'] for m in ds1[0]['messages']]}\")\n",
-    "\n",
-    "# ---------- Dataset 2: Trendyol (53,202 rows) ----------\n",
-    "print(\"\\n📥 Loading Trendyol Cybersecurity...\")\n",
-    "ds2 = load_dataset(\"Trendyol/Trendyol-Cybersecurity-Instruction-Tuning-Dataset\", split=\"train\")\n",
-    "print(f\"   Rows: {len(ds2)} | Columns: {ds2.column_names}\")\n",
-    "\n",
-    "def trendyol_to_messages(example):\n",
-    "    return {\n",
-    "        \"messages\": [\n",
-    "            {\"role\": \"system\",    \"content\": example[\"system\"]},\n",
-    "            {\"role\": \"user\",      \"content\": example[\"user\"]},\n",
-    "            {\"role\": \"assistant\", \"content\": example[\"assistant\"]},\n",
-    "        ]\n",
-    "    }\n",
-    "\n",
-    "ds2 = ds2.map(trendyol_to_messages, remove_columns=ds2.column_names, batched=False)\n",
-    "print(f\"✅ Trendyol converted to messages. Sample roles: {[m['role'] for m in ds2[0]['messages']]}\")\n",
-    "\n",
-    "# ---------- Merge & Subsample ----------\n",
-    "train_dataset = concatenate_datasets([ds1, ds2])\n",
+    "def _convert_fenrir(example):\n",
+    "    return {\"messages\": [\n",
+    "        {\"role\": \"system\",    \"content\": example[\"system\"]},\n",
+    "        {\"role\": \"user\",      \"content\": example[\"user\"]},\n",
+    "        {\"role\": \"assistant\", \"content\": example[\"assistant\"]},\n",
+    "    ]}\n",
+    "\n",
+    "def _convert_trendyol(example):\n",
+    "    return {\"messages\": [\n",
+    "        {\"role\": \"system\",    \"content\": example[\"system\"]},\n",
+    "        {\"role\": \"user\",      \"content\": example[\"user\"]},\n",
+    "        {\"role\": \"assistant\", \"content\": example[\"assistant\"]},\n",
+    "    ]}\n",
+    "\n",
+    "def _convert_ultrachat(example):\n",
+    "    # Already in messages format with role/content\n",
+    "    return {\"messages\": example[\"messages\"]}\n",
+    "\n",
+    "def _convert_conversations(example):\n",
+    "    # OpenHermes / ShareGPT style: [{from: 'human'/'gpt', value: '...'}]\n",
+    "    msgs = []\n",
+    "    system_prompt = example.get(\"system_prompt\") or example.get(\"system\", \"\")\n",
+    "    if system_prompt:\n",
+    "        msgs.append({\"role\": \"system\", \"content\": system_prompt})\n",
+    "    for turn in example[\"conversations\"]:\n",
+    "        role = \"user\" if turn[\"from\"] in (\"human\", \"user\") else \"assistant\"\n",
+    "        msgs.append({\"role\": role, \"content\": turn[\"value\"]})\n",
+    "    return {\"messages\": msgs}\n",
+    "\n",
+    "# ===================== LOAD DATASET(S) =====================\n",
+    "all_datasets = []\n",
+    "\n",
+    "if DATASET_CHOICE == \"cybersecurity\":\n",
+    "    print(\"📥 Loading Fenrir v2.1...\")\n",
+    "    ds1 = load_dataset(\"AlicanKiraz0/Cybersecurity-Dataset-Fenrir-v2.1\", split=\"train\")\n",
+    "    ds1 = ds1.map(_convert_fenrir, remove_columns=ds1.column_names, batched=False)\n",
+    "    all_datasets.append(ds1)\n",
+    "\n",
+    "    print(\"📥 Loading Trendyol Cybersecurity...\")\n",
+    "    ds2 = load_dataset(\"Trendyol/Trendyol-Cybersecurity-Instruction-Tuning-Dataset\", split=\"train\")\n",
+    "    ds2 = ds2.map(_convert_trendyol, remove_columns=ds2.column_names, batched=False)\n",
+    "    all_datasets.append(ds2)\n",
+    "\n",
+    "elif DATASET_CHOICE == \"ultrachat\":\n",
+    "    print(\"📥 Loading UltraChat 200K (train_sft split)...\")\n",
+    "    ds = load_dataset(\"HuggingFaceH4/ultrachat_200k\", split=\"train_sft\")\n",
+    "    ds = ds.map(_convert_ultrachat, remove_columns=ds.column_names, batched=False)\n",
+    "    all_datasets.append(ds)\n",
+    "\n",
+    "elif DATASET_CHOICE == \"openhermes\":\n",
+    "    print(\"📥 Loading OpenHermes 2.5...\")\n",
+    "    ds = load_dataset(\"teknium/OpenHermes-2.5\", split=\"train\")\n",
+    "    ds = ds.map(_convert_conversations, remove_columns=ds.column_names, batched=False)\n",
+    "    all_datasets.append(ds)\n",
+    "\n",
+    "elif DATASET_CHOICE.startswith(\"sharegpt_\"):\n",
+    "    split_map = {\"sharegpt_en\": \"english\", \"sharegpt_de\": \"german_4b_translated\", \"sharegpt_hi\": \"hindi_27b_translated\"}\n",
+    "    split_name = split_map[DATASET_CHOICE]\n",
+    "    print(f\"📥 Loading ShareGPT multilingual ({split_name})...\")\n",
+    "    ds = load_dataset(\"deepmage121/ShareGPT_multilingual\", split=split_name)\n",
+    "    ds = ds.map(_convert_conversations, remove_columns=ds.column_names, batched=False)\n",
+    "    all_datasets.append(ds)\n",
+    "\n",
+    "elif DATASET_CHOICE == \"custom_mix\":\n",
+    "    for ds_id, split, n_rows, fmt in CUSTOM_DATASETS:\n",
+    "        print(f\"📥 Loading {ds_id} ({split}, {n_rows} rows)...\")\n",
+    "        ds = load_dataset(ds_id, split=split)\n",
+    "        if n_rows and len(ds) > n_rows:\n",
+    "            ds = ds.shuffle(seed=3407).select(range(n_rows))\n",
+    "        if fmt == \"messages\":\n",
+    "            ds = ds.map(_convert_ultrachat, remove_columns=ds.column_names, batched=False)\n",
+    "        elif fmt == \"conversations\":\n",
+    "            ds = ds.map(_convert_conversations, remove_columns=ds.column_names, batched=False)\n",
+    "        else:\n",
+    "            raise ValueError(f\"Unknown format: {fmt}\")\n",
+    "        all_datasets.append(ds)\n",
+    "\n",
+    "else:\n",
+    "    raise ValueError(f\"Unknown DATASET_CHOICE: {DATASET_CHOICE}\")\n",
+    "\n",
+    "# Merge all loaded datasets\n",
+    "if len(all_datasets) == 1:\n",
+    "    train_dataset = all_datasets[0]\n",
+    "else:\n",
+    "    train_dataset = concatenate_datasets(all_datasets)\n",
+    "\n",
     "print(f\"\\n📊 COMBINED DATASET: {len(train_dataset)} rows\")\n",
     "\n",
-    "# Subsample for speed (50K is MORE than enough for LoRA domain tuning)\n",
+    "# Show a random sample\n",
+    "sample = train_dataset[random.randint(0, len(train_dataset)-1)]\n",
+    "print(f\"\\n--- Random sample roles: {[m['role'] for m in sample['messages']]} ---\")\n",
+    "for m in sample[\"messages\"]:\n",
+    "    print(f\"  {m['role']}: {m['content'][:100]}...\")\n",
+    "\n",
+    "# Subsample for speed\n",
     "if len(train_dataset) > SAMPLE_SIZE:\n",
     "    train_dataset = train_dataset.shuffle(seed=3407).select(range(SAMPLE_SIZE))\n",
-    "    print(f\"🚀 SUBSAMPLED to {len(train_dataset)} rows for fast training\")\n",
-    "else:\n",
-    "    print(f\"✅ Dataset is {len(train_dataset)} rows, no subsampling needed\")\n",
+    "    print(f\"\\n🚀 SUBSAMPLED to {len(train_dataset)} rows\")\n",
     "\n",
     "print(f\"   Effective batch size: {BATCH_SIZE * GRAD_ACCUM}\")\n",
     "print(f\"   Steps per epoch: ~{len(train_dataset) // (BATCH_SIZE * GRAD_ACCUM)}\")\n",
@@ -230,11 +316,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 5️⃣ Pre-process Dataset to Text (Avoid Unsloth formatting_func issues)\n",
+    "## 6️⃣ Convert Messages → Text (Chat Template)\n",
     "\n",
-    "**⚠️ CRITICAL:** Unsloth's SFTTrainer has issues with `formatting_func`.\n",
-    "The **cleanest fix** is to pre-convert `messages` → `text` using `dataset.map(batched=True)`,\n",
-    "then pass `dataset_text_field=\"text\"` to SFTTrainer. No `formatting_func` needed!"
+    "Uses `tokenizer.apply_chat_template` to convert structured messages into training text. No `formatting_func` needed."
    ]
   },
   {
@@ -243,28 +327,23 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# ========== PRE-PROCESS: messages → text with chat template ==========\n",
     "def convert_messages_to_text(examples):\n",
-    "    \"\"\"\n",
-    "    Convert batched messages to formatted text strings using tokenizer chat template.\n",
-    "    Called with batched=True so examples[\"messages\"] is a list of conversations.\n",
-    "    \"\"\"\n",
     "    texts = []\n",
     "    for msgs in examples[\"messages\"]:\n",
     "        text = tokenizer.apply_chat_template(\n",
     "            msgs,\n",
-    "            tokenize=False,              # return text string\n",
-    "            add_generation_prompt=False, # don't add assistant prompt at end\n",
+    "            tokenize=False,\n",
+    "            add_generation_prompt=False,\n",
     "        )\n",
     "        texts.append(text)\n",
     "    return {\"text\": texts}\n",
     "\n",
-    "print(\"🔄 Converting messages to text with chat template (batched)...\")\n",
+    "print(\"🔄 Converting messages to text...\")\n",
     "train_dataset = train_dataset.map(\n",
     "    convert_messages_to_text,\n",
-    "    batched=True,              # process multiple examples at once\n",
-    "    remove_columns=[\"messages\"],  # drop old column, keep only \"text\"\n",
-    "    batch_size=100,           # adjust based on your RAM\n",
+    "    batched=True,\n",
+    "    remove_columns=[\"messages\"],\n",
+    "    batch_size=100,\n",
     ")\n",
     "\n",
     "print(f\"✅ Dataset pre-processed. Columns: {train_dataset.column_names}\")\n",
@@ -276,7 +355,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 6️⃣ Configure SFT Trainer (with Packing + Speed Optimizations)"
+    "## 7️⃣ Configure SFT Trainer"
    ]
   },
   {
@@ -292,54 +371,40 @@
     "    model=model,\n",
     "    tokenizer=tokenizer,\n",
     "    train_dataset=train_dataset,\n",
-    "    dataset_text_field=\"text\",          # ← standard text format, no formatting_func needed!\n",
+    "    dataset_text_field=\"text\",\n",
     "    max_seq_length=MAX_SEQ_LENGTH,\n",
-    "    dataset_num_proc=2,                   # 2 workers for tokenization\n",
-    "    packing=PACKING,                      # ← MASSIVE speedup for short chat examples\n",
+    "    dataset_num_proc=2,\n",
+    "    packing=PACKING,\n",
     "    args=TrainingArguments(\n",
     "        per_device_train_batch_size=BATCH_SIZE,\n",
     "        gradient_accumulation_steps=GRAD_ACCUM,\n",
     "        warmup_steps=WARMUP_STEPS,\n",
-    "        max_steps=MAX_STEPS,              # ← cap steps instead of full epoch\n",
-    "        # num_train_epochs=NUM_EPOCHS,   # ← commented out: use max_steps instead\n",
+    "        max_steps=MAX_STEPS,\n",
     "        learning_rate=LEARNING_RATE,\n",
-    "        fp16=True,                        # T4 = fp16 only (no bf16)\n",
+    "        fp16=True,\n",
     "        logging_steps=LOGGING_STEPS,\n",
-    "        optim=\"adamw_8bit\",            # huge VRAM saver\n",
+    "        optim=\"adamw_8bit\",\n",
     "        weight_decay=0.01,\n",
     "        lr_scheduler_type=\"linear\",\n",
     "        seed=3407,\n",
     "        output_dir=\"./outputs\",\n",
     "        save_strategy=\"steps\",\n",
     "        save_steps=SAVE_STEPS,\n",
-    "        save_total_limit=2,               # keep only last 2 checkpoints\n",
-    "        report_to=\"none\",              # change to \"tensorboard\" / \"wandb\" if desired\n",
-    "        # push_to_hub=True,              # ← uncomment to auto-push during training\n",
-    "        # hub_model_id=HUB_MODEL_ID,\n",
-    "        # hub_strategy=\"every_save\",\n",
+    "        save_total_limit=2,\n",
+    "        report_to=\"none\",\n",
     "    ),\n",
     ")\n",
     "\n",
-    "print(f\"✅ Trainer ready. Total steps: {MAX_STEPS}\")\n",
+    "print(f\"✅ Trainer ready. Dataset: {DATASET_CHOICE} | Steps: {MAX_STEPS}\")\n",
     "print(f\"   Effective batch size: {BATCH_SIZE * GRAD_ACCUM}\")\n",
-    "print(f\"   Packing enabled: {PACKING}\")\n",
-    "print(f\"   Dataset samples: {len(train_dataset)}\")\n",
-    "print(f\"   Est. time at ~0.3 it/s: ~{MAX_STEPS * 3 / 3600:.1f} hours\")"
+    "print(f\"   Packing enabled: {PACKING}\")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 7️⃣ Train 🚀\n",
-    "\n",
-    "Expected time on **Google Colab Free Tier (T4)**: **~3–4 hours** for 4,000 steps.\n",
-    "\n",
-    "If you see `CUDA out of memory`:\n",
-    "1. Lower `MAX_SEQ_LENGTH` to 3072 or 2048\n",
-    "2. Set `BATCH_SIZE = 2`\n",
-    "3. Set `PACKING = False`\n",
-    "4. Set `use_rslora=True` in the LoRA config (cell 3)"
+    "## 8️⃣ Train 🚀"
    ]
   },
   {
@@ -348,9 +413,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Optional: memory stats before training\n",
     "if torch.cuda.is_available():\n",
-    "    print(f\"VRAM before train: {torch.cuda.memory_allocated()/1e9:.2f} GB / {torch.cuda.get_device_properties(0).total_memory/1e9:.2f} GB\")\n",
+    "    print(f\"VRAM before train: {torch.cuda.memory_allocated()/1e9:.2f} GB\")\n",
     "\n",
     "trainer_stats = trainer.train()\n",
     "\n",
@@ -365,13 +429,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 8️⃣ Save & Push to HuggingFace Hub\n",
-    "\n",
-    "We save:\n",
-    "1. **LoRA adapter only** (~50–100 MB) — fast, easy to share.\n",
-    "2. **Merged 16-bit model** (~8 GB) — ready for inference without Unsloth loaded.\n",
-    "\n",
-    "Pick whichever fits your use-case."
+    "## 9️⃣ Save & Push to HuggingFace Hub"
    ]
   },
   {
@@ -380,39 +438,33 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 8A) Save LoRA adapter (tiny, fast)\n",
-    "model.save_pretrained(\"./cyber-lora-adapter\")\n",
-    "tokenizer.save_pretrained(\"./cyber-lora-adapter\")\n",
-    "print(\"✅ LoRA adapter saved to ./cyber-lora-adapter\")\n",
-    "\n",
-    "# 8B) Optional: merge & save full 16-bit model\n",
-    "#    ⚠️ Needs ~8 GB RAM. On Colab it may swap to CPU; still works but slower.\n",
-    "print(\"\\n🔄 Merging LoRA into base model (this may take a minute)...\")\n",
+    "# Save LoRA adapter (tiny, ~50-100 MB)\n",
+    "model.save_pretrained(\"./lora-adapter\")\n",
+    "tokenizer.save_pretrained(\"./lora-adapter\")\n",
+    "print(\"✅ LoRA adapter saved\")\n",
+    "\n",
+    "# Merge & save full 16-bit model (~8 GB)\n",
+    "print(\"\\n🔄 Merging LoRA into base model...\")\n",
     "merged_model = model.merge_and_unload()\n",
-    "merged_model.save_pretrained(\"./cyber-qwen3-4b-merged\")\n",
-    "tokenizer.save_pretrained(\"./cyber-qwen3-4b-merged\")\n",
-    "print(\"✅ Merged 16-bit model saved to ./cyber-qwen3-4b-merged\")\n",
+    "merged_model.save_pretrained(\"./merged-model\")\n",
+    "tokenizer.save_pretrained(\"./merged-model\")\n",
+    "print(\"✅ Merged model saved\")\n",
     "\n",
-    "# 8C) Push LoRA adapter to HF Hub (uncomment if you logged in at step 2)\n",
+    "# Push to HF Hub (uncomment if logged in)\n",
     "# model.push_to_hub(HUB_MODEL_ID)\n",
-    "# tokenizer.push_to_hub(HUB_MODEL_ID)\n",
-    "# print(f\"🚀 Pushed to https://huggingface.co/{HUB_MODEL_ID}\")"
+    "# tokenizer.push_to_hub(HUB_MODEL_ID)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 9️⃣ Inference Demo – Qwen3 Thinking Toggle\n",
-    "\n",
-    "Qwen3 has a unique **thinking mode** switch. Use it for different tasks:\n",
+    "## 🔟 Inference Demo – Qwen3 Thinking Toggle\n",
     "\n",
     "| Mode | Use Case | Speed |\n",
     "|------|----------|-------|\n",
-    "| `enable_thinking=True`  | Deep exploit analysis, CTF walkthroughs, reverse-engineering | Slower, more thorough |\n",
-    "| `enable_thinking=False` | Quick lookups, syntax checks, tool commands | Fast, direct |\n",
-    "\n",
-    "Below we test both modes on a responsible pentesting question."
+    "| `enable_thinking=True` | Deep reasoning, analysis, chain-of-thought | Slower, thorough |\n",
+    "| `enable_thinking=False` | Quick answers, coding snippets, commands | Fast, direct |"
    ]
   },
   {
@@ -421,101 +473,35 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "FastLanguageModel.for_inference(model)  # enable 2× faster inference\n",
+    "FastLanguageModel.for_inference(model)\n",
     "\n",
-    "test_prompt = (\n",
-    "    \"How would you perform a responsible penetration test on a web application? \"\n",
-    "    \"List the phases, key tools, and how to document findings for the development team.\"\n",
-    ")\n",
+    "test_prompt = \"Explain how parameterized queries prevent SQL injection, with a Python example.\"\n",
     "\n",
     "messages = [\n",
-    "    {\"role\": \"system\", \"content\": \"You are a cybersecurity expert. Explain concepts clearly and ethically.\"},\n",
+    "    {\"role\": \"system\", \"content\": \"You are a helpful and knowledgeable assistant.\"},\n",
     "    {\"role\": \"user\",     \"content\": test_prompt},\n",
     "]\n",
     "\n",
     "for think_mode in [True, False]:\n",
-    "    label = \"🧠 THINKING=ON (deep analysis)\" if think_mode else \"⚡ THINKING=OFF (fast direct)\"\n",
+    "    label = \"🧠 THINKING=ON\" if think_mode else \"⚡ THINKING=OFF\"\n",
     "    print(f\"\\n{'='*60}\")\n",
-    "    print(f\"{label}\")\n",
+    "    print(label)\n",
     "    print(f\"{'='*60}\")\n",
     "\n",
     "    inputs = tokenizer.apply_chat_template(\n",
-    "        messages,\n",
-    "        tokenize=True,\n",
-    "        add_generation_prompt=True,\n",
-    "        enable_thinking=think_mode,\n",
-    "        return_tensors=\"pt\",\n",
+    "        messages, tokenize=True, add_generation_prompt=True,\n",
+    "        enable_thinking=think_mode, return_tensors=\"pt\",\n",
     "    ).to(model.device)\n",
     "\n",
     "    outputs = model.generate(\n",
-    "        input_ids=inputs,\n",
-    "        max_new_tokens=512,\n",
-    "        temperature=0.7,\n",
-    "        top_p=0.9,\n",
-    "        do_sample=True,\n",
+    "        input_ids=inputs, max_new_tokens=512, temperature=0.7,\n",
+    "        top_p=0.9, do_sample=True,\n",
     "        pad_token_id=tokenizer.pad_token_id,\n",
     "        eos_token_id=tokenizer.eos_token_id,\n",
     "    )\n",
-    "\n",
-    "    response = tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
-    "    # Extract only the assistant's reply (after the last user turn)\n",
-    "    reply = response.split(\"user\")[-1].split(\"assistant\")[-1].strip()\n",
-    "    print(reply[:800] + (\"...\" if len(reply) > 800 else \"\"))\n",
-    "    print(f\"\\n[Tokens generated: {len(outputs[0]) - len(inputs[0])}]\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 🔟 (Bonus) Quick Benchmark – CyberMetric Sample\n",
-    "\n",
-    "Test your model's cybersecurity knowledge with a sample from the [CyberMetric benchmark](https://huggingface.co/datasets/cybermetric/cybermetric-500).\n",
-    "\n",
-    "This is **not a full evaluation** — just a sanity check that your fine-tune improved domain knowledge."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Sample CyberMetric-style question\n",
-    "benchmark_q = (\n",
-    "    \"Which of the following is the MOST effective defense against SQL injection attacks?\\n\"\n",
-    "    \"A) Input validation only\\n\"\n",
-    "    \"B) Parameterized queries (prepared statements)\\n\"\n",
-    "    \"C) Escaping special characters\\n\"\n",
-    "    \"D) Client-side filtering\\n\"\n",
-    "    \"Answer with the letter only.\"\n",
-    ")\n",
-    "\n",
-    "bench_msgs = [\n",
-    "    {\"role\": \"system\", \"content\": \"You are a cybersecurity expert. Answer accurately and concisely.\"},\n",
-    "    {\"role\": \"user\",     \"content\": benchmark_q},\n",
-    "]\n",
-    "\n",
-    "inputs = tokenizer.apply_chat_template(\n",
-    "    bench_msgs,\n",
-    "    tokenize=True,\n",
-    "    add_generation_prompt=True,\n",
-    "    enable_thinking=False,   # fast direct answer\n",
-    "    return_tensors=\"pt\",\n",
-    ").to(model.device)\n",
-    "\n",
-    "outputs = model.generate(\n",
-    "    input_ids=inputs,\n",
-    "    max_new_tokens=64,\n",
-    "    temperature=0.1,         # low temp for factual answer\n",
-    "    do_sample=True,\n",
-    "    pad_token_id=tokenizer.pad_token_id,\n",
-    "    eos_token_id=tokenizer.eos_token_id,\n",
-    ")\n",
-    "\n",
-    "answer = tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
-    "print(\"📊 Benchmark Answer:\")\n",
-    "print(answer.split(\"assistant\")[-1].strip())"
+    "    reply = tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
+    "    print(reply.split(\"assistant\")[-1].strip()[:800])\n",
+    "    print(f\"\\n[Tokens: {len(outputs[0]) - len(inputs[0])}]\")"
    ]
   },
   {
@@ -523,29 +509,20 @@
    "metadata": {},
    "source": [
     "---\n",
-    "## 📚 References & Links\n",
+    "## 📚 Dataset & Model References\n",
     "\n",
     "| Resource | Link |\n",
     "|----------|------|\n",
-    "| **Model (Qwen3-4B-Instruct-2507)** | https://huggingface.co/Qwen/Qwen3-4B-Instruct-2507 |\n",
-    "| **Unsloth 4-bit version** | https://huggingface.co/unsloth/Qwen3-4B-Instruct-2507-unsloth-bnb-4bit |\n",
-    "| **Fenrir Dataset** | https://huggingface.co/datasets/AlicanKiraz0/Cybersecurity-Dataset-Fenrir-v2.1 |\n",
-    "| **Trendyol Dataset** | https://huggingface.co/datasets/Trendyol/Trendyol-Cybersecurity-Instruction-Tuning-Dataset |\n",
+    "| **Qwen3-4B-Instruct-2507** | https://huggingface.co/Qwen/Qwen3-4B-Instruct-2507 |\n",
+    "| **UltraChat 200K** | https://huggingface.co/datasets/HuggingFaceH4/ultrachat_200k |\n",
+    "| **OpenHermes 2.5** | https://huggingface.co/datasets/teknium/OpenHermes-2.5 |\n",
+    "| **ShareGPT Multilingual** | https://huggingface.co/datasets/deepmage121/ShareGPT_multilingual |\n",
+    "| **Fenrir Cybersecurity** | https://huggingface.co/datasets/AlicanKiraz0/Cybersecurity-Dataset-Fenrir-v2.1 |\n",
+    "| **Trendyol Cybersecurity** | https://huggingface.co/datasets/Trendyol/Trendyol-Cybersecurity-Instruction-Tuning-Dataset |\n",
     "| **Unsloth Docs** | https://unsloth.ai/docs |\n",
-    "| **TRL SFTTrainer** | https://huggingface.co/docs/trl/sft_trainer |\n",
-    "| **CyberMetric Eval** | https://huggingface.co/datasets/cybermetric/cybermetric-500 |\n",
-    "\n",
-    "## 🔧 Troubleshooting\n",
-    "\n",
-    "| Problem | Solution |\n",
-    "|---------|----------|\n",
-    "| `CUDA out of memory` | Lower `MAX_SEQ_LENGTH` to 2048; set `BATCH_SIZE=2`; set `PACKING=False`; enable `use_rslora=True` |\n",
-    "| Training very slow | Increase `BATCH_SIZE` to 4 if VRAM allows; enable `PACKING=True` |\n",
-    "| Loss not decreasing | Try `LEARNING_RATE=5e-4` or train for 2 epochs |\n",
-    "| Can't push to Hub | Run `login(token=...)` with a WRITE token |\n",
     "\n",
     "---\n",
-    "*Built with ❤️ for the cybersecurity community. Use responsibly.*"
+    "*Pick any dataset. Train anything. Use responsibly.*"
    ]
   }
  ],
@@ -561,5 +538,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 4
+  "nbformat_minor": 4
 }