diff --git "a/PELS_Training_RTX3050.ipynb" "b/PELS_Training_RTX3050.ipynb"
new file mode 100644--- /dev/null
+++ "b/PELS_Training_RTX3050.ipynb"
@@ -0,0 +1,2499 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# PELS Fine-Tuning Notebook — RTX 3050 (4GB VRAM)\n",
+    "**Task:** Given a prompt text + domain → predict C1–C6 scores + justification  \n",
+    "**Model:** `microsoft/phi-2` (2.7B) with QLoRA — fits in 4GB VRAM  \n",
+    "**Dataset:** PELS_Final_Justification.xlsx (1,674 rows)  \n",
+    "**Output:** Fine-tuned model + FastAPI-ready /grade endpoint\n",
+    "\n",
+    "---\n",
+    "### Hardware requirements\n",
+    "| Component | Required | Your GPU |\n",
+    "|-----------|----------|----------|\n",
+    "| VRAM      | 4GB min  | RTX 3050 ✓ |\n",
+    "| RAM       | 8GB min  | — |\n",
+    "| CUDA      | 11.8+    | Check below |\n",
+    "\n",
+    "> **Why Phi-2?** At 2.7B parameters with 4-bit quantization it uses ~2.5GB VRAM — leaving 1.5GB for activations on your 3050. Mistral-7B needs 6–8GB and will OOM on your card."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cell 1 — Install dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  WARNING: Failed to remove contents in a temporary directory 'R:\\anaconda3\\envs\\softcomp\\Lib\\site-packages\\~okenizers'.\n",
+      "  You can safely remove it manually.\n",
+      "ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
+      "inference 1.2.1 requires numpy<2.4.0,>=2.0.0, but you have numpy 1.26.4 which is incompatible.\n",
+      "inference 1.2.1 requires opencv-python<=4.10.0.84,>=4.8.1.78, but you have opencv-python 4.6.0.66 which is incompatible.\n",
+      "inference-models 0.24.2 requires bitsandbytes<0.48.0,>=0.46.1; sys_platform != \"darwin\", but you have bitsandbytes 0.49.2 which is incompatible.\n",
+      "inference-models 0.24.2 requires opencv-python>=4.8.1.78, but you have opencv-python 4.6.0.66 which is incompatible.\n",
+      "inference-models 0.24.2 requires peft>=0.18.1, but you have peft 0.10.0 which is incompatible.\n",
+      "inference-models 0.24.2 requires scikit-image<0.26.0,>=0.24.0, but you have scikit-image 0.20.0 which is incompatible.\n",
+      "inference-models 0.24.2 requires transformers<5.3.0,>=5.2.0, but you have transformers 4.40.0 which is incompatible.\n",
+      "trl 1.3.0 requires transformers>=4.56.2, but you have transformers 4.40.0 which is incompatible.\n",
+      "  WARNING: Failed to remove contents in a temporary directory 'R:\\anaconda3\\envs\\softcomp\\Lib\\site-packages\\~itsandbytes'.\n",
+      "  You can safely remove it manually.\n",
+      "ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
+      "inference-models 0.24.2 requires bitsandbytes<0.48.0,>=0.46.1; sys_platform != \"darwin\", but you have bitsandbytes 0.43.1 which is incompatible.\n",
+      "inference-models 0.24.2 requires opencv-python>=4.8.1.78, but you have opencv-python 4.6.0.66 which is incompatible.\n",
+      "inference-models 0.24.2 requires peft>=0.18.1, but you have peft 0.10.0 which is incompatible.\n",
+      "inference-models 0.24.2 requires scikit-image<0.26.0,>=0.24.0, but you have scikit-image 0.20.0 which is incompatible.\n",
+      "inference-models 0.24.2 requires transformers<5.3.0,>=5.2.0, but you have transformers 4.40.0 which is incompatible.\n",
+      "ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
+      "inference-models 0.24.2 requires accelerate<2.0.0,>=1.0.0, but you have accelerate 0.29.3 which is incompatible.\n",
+      "inference-models 0.24.2 requires bitsandbytes<0.48.0,>=0.46.1; sys_platform != \"darwin\", but you have bitsandbytes 0.43.1 which is incompatible.\n",
+      "inference-models 0.24.2 requires opencv-python>=4.8.1.78, but you have opencv-python 4.6.0.66 which is incompatible.\n",
+      "inference-models 0.24.2 requires peft>=0.18.1, but you have peft 0.10.0 which is incompatible.\n",
+      "inference-models 0.24.2 requires scikit-image<0.26.0,>=0.24.0, but you have scikit-image 0.20.0 which is incompatible.\n",
+      "inference-models 0.24.2 requires transformers<5.3.0,>=5.2.0, but you have transformers 4.40.0 which is incompatible.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ All packages installed — restart kernel now\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Run once. Restart kernel after this cell.\n",
+    "!pip install -q transformers==4.40.0\n",
+    "!pip install -q peft==0.10.0\n",
+    "!pip install -q trl==0.8.6\n",
+    "!pip install -q bitsandbytes==0.43.1\n",
+    "!pip install -q accelerate==0.29.3\n",
+    "!pip install -q datasets==2.18.0\n",
+    "!pip install -q openpyxl pandas scikit-learn\n",
+    "!pip install -q rouge-score evaluate\n",
+    "!pip install -q matplotlib seaborn\n",
+    "\n",
+    "print(\"✅ All packages installed — restart kernel now\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cell 2 — GPU check"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "==================================================\n",
+      "PyTorch version : 2.5.1+cu121\n",
+      "CUDA available  : True\n",
+      "GPU             : NVIDIA GeForce RTX 3050 6GB Laptop GPU\n",
+      "Total VRAM      : 6.4 GB\n",
+      "Free VRAM       : 6.4 GB\n",
+      "✅ Sufficient VRAM for Phi-2 QLoRA training\n",
+      "==================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "\n",
+    "print(\"=\" * 50)\n",
+    "print(f\"PyTorch version : {torch.__version__}\")\n",
+    "print(f\"CUDA available  : {torch.cuda.is_available()}\")\n",
+    "\n",
+    "if torch.cuda.is_available():\n",
+    "    print(f\"GPU             : {torch.cuda.get_device_name(0)}\")\n",
+    "    total = torch.cuda.get_device_properties(0).total_memory / 1e9\n",
+    "    free  = (torch.cuda.get_device_properties(0).total_memory - torch.cuda.memory_allocated(0)) / 1e9\n",
+    "    print(f\"Total VRAM      : {total:.1f} GB\")\n",
+    "    print(f\"Free VRAM       : {free:.1f} GB\")\n",
+    "    if total < 3.5:\n",
+    "        print(\"⚠️  Less than 4GB detected — use batch_size=1 and gradient_accumulation=16\")\n",
+    "    else:\n",
+    "        print(\"✅ Sufficient VRAM for Phi-2 QLoRA training\")\n",
+    "else:\n",
+    "    print(\"❌ No GPU detected — training will be very slow on CPU\")\n",
+    "print(\"=\" * 50)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cell 3 — Load and inspect dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dataset shape   : (1674, 10)\n",
+      "Total rows      : 1674\n",
+      "Null values     : 0\n",
+      "\n",
+      "Domain distribution:\n",
+      "domain\n",
+      "CAREER    600\n",
+      "GEN       360\n",
+      "CREATE    300\n",
+      "CODE      264\n",
+      "EDU       150\n",
+      "\n",
+      "Score statistics (0–10 scale):\n",
+      "            c1       c2      c3       c4       c5       c6  final_score\n",
+      "count  1674.00  1674.00  1674.0  1674.00  1674.00  1674.00      1674.00\n",
+      "mean      5.16     5.17     4.9     5.71     4.74     4.55         5.10\n",
+      "std       2.51     2.32     2.4     2.32     2.14     2.53         2.21\n",
+      "min       1.00     1.00     1.0     1.00     1.00     1.00         1.00\n",
+      "25%       4.00     4.00     3.0     4.00     3.00     3.00         3.62\n",
+      "50%       5.00     5.00     5.0     6.00     4.00     4.00         5.30\n",
+      "75%       7.57     6.00     6.0     7.00     6.00     6.00         6.15\n",
+      "max      10.00    10.00    10.0    10.00    10.00    10.00         9.35\n",
+      "\n",
+      "Skill tier distribution:\n",
+      "skill_tier\n",
+      "developing    864\n",
+      "weak          524\n",
+      "strong        286\n",
+      "\n",
+      "Ethics veto rows (C5=1.0): 73\n",
+      "\n",
+      "Sample row:\n",
+      "  Prompt  : You are a copywriter for a college literary magazine launch. Write the editor's note (200 words, first-person plural) in\n",
+      "  Domain  : CREATE\n",
+      "  Scores  : C1=5.0 C2=6.0 C3=7.0 C4=6.0 C5=4.0 C6=4.0\n",
+      "  Final   : 5.55\n",
+      "  Justif  : Mid-level C1 performance. The prompt includes a role and task framing, demonstrating that the writer understands AI is not a search engine. However, limitations like output variability and knowledge c\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "# ── Load\n",
+    "df = pd.read_excel('PELS_Final_Justification.xlsx')\n",
+    "\n",
+    "# ── Standardise column names (strip newlines from header)\n",
+    "df.columns = [\n",
+    "    'prompt_text', 'domain',\n",
+    "    'c1', 'c2', 'c3', 'c4', 'c5', 'c6',\n",
+    "    'final_score', 'justification'\n",
+    "]\n",
+    "\n",
+    "print(f\"Dataset shape   : {df.shape}\")\n",
+    "print(f\"Total rows      : {len(df)}\")\n",
+    "print(f\"Null values     : {df.isnull().sum().sum()}\")\n",
+    "print()\n",
+    "print(\"Domain distribution:\")\n",
+    "print(df['domain'].value_counts().to_string())\n",
+    "print()\n",
+    "print(\"Score statistics (0–10 scale):\")\n",
+    "print(df[['c1','c2','c3','c4','c5','c6','final_score']].describe().round(2).to_string())\n",
+    "print()\n",
+    "\n",
+    "# Skill tier assignment\n",
+    "def assign_tier(score):\n",
+    "    s = score * 10\n",
+    "    if s >= 71:  return 'strong'\n",
+    "    elif s >= 41: return 'developing'\n",
+    "    else:         return 'weak'\n",
+    "\n",
+    "df['skill_tier'] = df['final_score'].apply(assign_tier)\n",
+    "print(\"Skill tier distribution:\")\n",
+    "print(df['skill_tier'].value_counts().to_string())\n",
+    "print()\n",
+    "\n",
+    "# C5 ethics veto flag\n",
+    "df['veto'] = (df['c5'] == 1.0)\n",
+    "print(f\"Ethics veto rows (C5=1.0): {df['veto'].sum()}\")\n",
+    "print()\n",
+    "print(\"Sample row:\")\n",
+    "print(f\"  Prompt  : {df.iloc[0]['prompt_text'][:120]}\")\n",
+    "print(f\"  Domain  : {df.iloc[0]['domain']}\")\n",
+    "print(f\"  Scores  : C1={df.iloc[0]['c1']} C2={df.iloc[0]['c2']} C3={df.iloc[0]['c3']} C4={df.iloc[0]['c4']} C5={df.iloc[0]['c5']} C6={df.iloc[0]['c6']}\")\n",
+    "print(f\"  Final   : {df.iloc[0]['final_score']}\")\n",
+    "print(f\"  Justif  : {df.iloc[0]['justification'][:200]}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cell 4 — Visualise data distribution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x800 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Charts saved\n"
+     ]
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "fig, axes = plt.subplots(2, 3, figsize=(15, 8))\n",
+    "fig.suptitle('PELS Dataset — Score Distributions', fontsize=14, fontweight='bold')\n",
+    "\n",
+    "score_cols = ['c1', 'c2', 'c3', 'c4', 'c5', 'c6']\n",
+    "col_labels = ['C1 Foundations', 'C2 Design', 'C3 Output Spec', 'C4 Domain', 'C5 Ethics', 'C6 Metacognition']\n",
+    "colors = ['#2196F3','#4CAF50','#FF9800','#9C27B0','#F44336','#00BCD4']\n",
+    "\n",
+    "for ax, col, label, color in zip(axes.flatten(), score_cols, col_labels, colors):\n",
+    "    ax.hist(df[col], bins=20, color=color, alpha=0.75, edgecolor='white')\n",
+    "    ax.set_title(label, fontweight='bold')\n",
+    "    ax.set_xlabel('Score (1–10)')\n",
+    "    ax.set_ylabel('Count')\n",
+    "    ax.axvline(df[col].mean(), color='black', linestyle='--', linewidth=1.2, label=f'Mean: {df[col].mean():.1f}')\n",
+    "    ax.legend(fontsize=8)\n",
+    "    ax.grid(axis='y', alpha=0.3)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.savefig('pels_score_distributions.png', dpi=120, bbox_inches='tight')\n",
+    "plt.show()\n",
+    "\n",
+    "# Correlation heatmap\n",
+    "fig2, ax2 = plt.subplots(figsize=(8, 6))\n",
+    "corr = df[['c1','c2','c3','c4','c5','c6','final_score']].corr()\n",
+    "sns.heatmap(corr, annot=True, fmt='.2f', cmap='Blues', ax=ax2,\n",
+    "            xticklabels=['C1','C2','C3','C4','C5','C6','Final'],\n",
+    "            yticklabels=['C1','C2','C3','C4','C5','C6','Final'])\n",
+    "ax2.set_title('Score Category Correlation Matrix', fontweight='bold')\n",
+    "plt.tight_layout()\n",
+    "plt.savefig('pels_correlation.png', dpi=120, bbox_inches='tight')\n",
+    "plt.show()\n",
+    "print(\"✅ Charts saved\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cell 5 — Build training examples (instruction format)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training text length statistics (characters):\n",
+      "count    1674.0\n",
+      "mean     2325.0\n",
+      "std       273.0\n",
+      "min      1958.0\n",
+      "25%      2129.0\n",
+      "50%      2245.0\n",
+      "75%      2434.0\n",
+      "max      4212.0\n",
+      "\n",
+      "Estimated avg tokens (chars/3.5): 664\n",
+      "Max tokens estimate             : 1203\n",
+      "\n",
+      "Sample training example:\n",
+      "------------------------------------------------------------\n",
+      "Instruct: ### PELS Grading Task\n",
+      "Domain: CREATE\n",
+      "Rubric:\n",
+      "C1 Foundations (15%): Task clarity, role setup, AI awareness.\n",
+      "C2 Design (20%): Prompt structure, patterns (few-shot, CoT, role+task+constraint).\n",
+      "C3 Output Spec (20%): Format, length, tone, structure constraints.\n",
+      "C4 Domain Application (20%): Domain vocabulary, contextual accuracy.\n",
+      "C5 Ethics (15%): No harmful/biased framing. Score=1 triggers automatic Final Score override to 1.0.\n",
+      "C6 Metacognition (10%): Self-awareness, iteration design, fallback handling.\n",
+      "\n",
+      "Candidate Prompt:\n",
+      "You are a copywriter for a college literary magazine launch. Write the editor's note (200 words, first-person plural) introducing the magazine's first issue themed around 'thresholds'. Structure: opening metaphor, body connecting submissions to theme, closing invitati\n",
+      "...\n"
+     ]
+    }
+   ],
+   "source": [
+    "# PELS rubric context injected into every training example\n",
+    "RUBRIC = \"\"\"C1 Foundations (15%): Task clarity, role setup, AI awareness.\n",
+    "C2 Design (20%): Prompt structure, patterns (few-shot, CoT, role+task+constraint).\n",
+    "C3 Output Spec (20%): Format, length, tone, structure constraints.\n",
+    "C4 Domain Application (20%): Domain vocabulary, contextual accuracy.\n",
+    "C5 Ethics (15%): No harmful/biased framing. Score=1 triggers automatic Final Score override to 1.0.\n",
+    "C6 Metacognition (10%): Self-awareness, iteration design, fallback handling.\"\"\"\n",
+    "\n",
+    "def build_instruction(row):\n",
+    "    \"\"\"\n",
+    "    Formats one dataset row as an instruction-tuning example.\n",
+    "    Input  : prompt_text + domain + rubric\n",
+    "    Output : C1–C6 scores + final_score + justification\n",
+    "    \"\"\"\n",
+    "    prompt_part = (\n",
+    "        f\"### PELS Grading Task\\n\"\n",
+    "        f\"Domain: {row['domain']}\\n\"\n",
+    "        f\"Rubric:\\n{RUBRIC}\\n\\n\"\n",
+    "        f\"Candidate Prompt:\\n{row['prompt_text']}\\n\\n\"\n",
+    "        f\"### Evaluation\\n\"\n",
+    "        f\"Score each category 1–10. Ethics score of 1 overrides all others.\"\n",
+    "    )\n",
+    "\n",
+    "    # C5 veto override\n",
+    "    if row['veto']:\n",
+    "        final_display = 1.0\n",
+    "        veto_note = \" [ETHICS VETO: Final score overridden to 1.0]\"\n",
+    "    else:\n",
+    "        final_display = round(row['final_score'], 2)\n",
+    "        veto_note = \"\"\n",
+    "\n",
+    "    response_part = (\n",
+    "        f\"C1_Foundations: {round(row['c1'], 1)}\\n\"\n",
+    "        f\"C2_Design: {round(row['c2'], 1)}\\n\"\n",
+    "        f\"C3_OutputSpec: {round(row['c3'], 1)}\\n\"\n",
+    "        f\"C4_Domain: {round(row['c4'], 1)}\\n\"\n",
+    "        f\"C5_Ethics: {round(row['c5'], 1)}\\n\"\n",
+    "        f\"C6_Metacognition: {round(row['c6'], 1)}\\n\"\n",
+    "        f\"Final_Score: {final_display}{veto_note}\\n\\n\"\n",
+    "        f\"Justification: {row['justification']}\"\n",
+    "    )\n",
+    "\n",
+    "    # Phi-2 instruction format\n",
+    "    return f\"Instruct: {prompt_part}\\nOutput: {response_part}\"\n",
+    "\n",
+    "df['training_text'] = df.apply(build_instruction, axis=1)\n",
+    "\n",
+    "# Token length sanity check\n",
+    "df['char_len'] = df['training_text'].str.len()\n",
+    "print(\"Training text length statistics (characters):\")\n",
+    "print(df['char_len'].describe().round(0).to_string())\n",
+    "print()\n",
+    "print(f\"Estimated avg tokens (chars/3.5): {int(df['char_len'].mean() / 3.5)}\")\n",
+    "print(f\"Max tokens estimate             : {int(df['char_len'].max() / 3.5)}\")\n",
+    "print()\n",
+    "print(\"Sample training example:\")\n",
+    "print(\"-\" * 60)\n",
+    "print(df.iloc[0]['training_text'][:800])\n",
+    "print(\"...\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cell 6 — Train / Validation / Test split"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train : 1340 rows (80%)\n",
+      "Val   : 167 rows (10%)\n",
+      "Test  : 167 rows (10%)\n",
+      "\n",
+      "Domain balance in train set:\n",
+      "domain\n",
+      "CAREER    480\n",
+      "GEN       288\n",
+      "CREATE    240\n",
+      "CODE      212\n",
+      "EDU       120\n",
+      "\n",
+      "✅ HuggingFace datasets ready\n",
+      "   train_ds: Dataset({\n",
+      "    features: ['text'],\n",
+      "    num_rows: 1340\n",
+      "})\n",
+      "   val_ds  : Dataset({\n",
+      "    features: ['text'],\n",
+      "    num_rows: 167\n",
+      "})\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.model_selection import train_test_split\n",
+    "from datasets import Dataset\n",
+    "\n",
+    "# Stratified split by domain to keep domain balance in each set\n",
+    "train_parts, val_parts, test_parts = [], [], []\n",
+    "\n",
+    "for domain in df['domain'].unique():\n",
+    "    sub = df[df['domain'] == domain].reset_index(drop=True)\n",
+    "    n = len(sub)\n",
+    "    n_test = max(1, int(n * 0.10))\n",
+    "    n_val  = max(1, int(n * 0.10))\n",
+    "\n",
+    "    temp, test_sub = train_test_split(sub, test_size=n_test, random_state=42)\n",
+    "    train_sub, val_sub = train_test_split(temp, test_size=n_val, random_state=42)\n",
+    "\n",
+    "    train_parts.append(train_sub)\n",
+    "    val_parts.append(val_sub)\n",
+    "    test_parts.append(test_sub)\n",
+    "\n",
+    "train_df = pd.concat(train_parts).reset_index(drop=True)\n",
+    "val_df   = pd.concat(val_parts).reset_index(drop=True)\n",
+    "test_df  = pd.concat(test_parts).reset_index(drop=True)\n",
+    "\n",
+    "print(f\"Train : {len(train_df)} rows ({len(train_df)/len(df)*100:.0f}%)\")\n",
+    "print(f\"Val   : {len(val_df)} rows ({len(val_df)/len(df)*100:.0f}%)\")\n",
+    "print(f\"Test  : {len(test_df)} rows ({len(test_df)/len(df)*100:.0f}%)\")\n",
+    "print()\n",
+    "print(\"Domain balance in train set:\")\n",
+    "print(train_df['domain'].value_counts().to_string())\n",
+    "\n",
+    "# Convert to HuggingFace Dataset format\n",
+    "train_ds = Dataset.from_dict({'text': train_df['training_text'].tolist()})\n",
+    "val_ds   = Dataset.from_dict({'text': val_df['training_text'].tolist()})\n",
+    "test_ds  = Dataset.from_dict({'text': test_df['training_text'].tolist()})\n",
+    "\n",
+    "print(f\"\\n✅ HuggingFace datasets ready\")\n",
+    "print(f\"   train_ds: {train_ds}\")\n",
+    "print(f\"   val_ds  : {val_ds}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cell 7 — Load Phi-2 with 4-bit QLoRA (fits in 4GB VRAM)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The cache for model files in Transformers v4.22.0 has been updated. Migrating your old cache. This is a one-time only operation. You can interrupt this and resume the migration later on by calling `transformers.utils.move_cache()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "16fcf24fafbf41b3b9ed8eaef130192e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "0it [00:00, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading model: microsoft/phi-2\n",
+      "This downloads ~5.5GB on first run — subsequent runs use cache.\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e0a1e2ea53e64a44a2fbdb91cd85369f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer_config.json: 0.00B [00:00, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "8ea1da3b758a4f22ab9aff0b0eeff6d6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "vocab.json: 0.00B [00:00, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ff9e29bcaa7342ffaaf67964a518646e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "merges.txt: 0.00B [00:00, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b43208210b874cd585eca150e189c4f3",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer.json: 0.00B [00:00, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "10a61fddbc4440dea7ee47d6cc40c48d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "added_tokens.json: 0.00B [00:00, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "3e34c9d91949497da9428cdaff04988e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "special_tokens_map.json:   0%|          | 0.00/99.0 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "417fa9325f8448b8abf40c2886528588",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "config.json:   0%|          | 0.00/735 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d2077b9bae0d48148fbbc02fadd34f7c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "model.safetensors.index.json: 0.00B [00:00, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7804a1128095451a83104794d035d22c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading shards:   0%|          | 0/2 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "65dd90458d2c4f7cb378511deeaedda1",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "model-00001-of-00002.safetensors:   0%|          | 0.00/5.00G [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0bc4bc339e314b8aa7150faa243ed89e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "model-00002-of-00002.safetensors:   0%|          | 0.00/564M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9acfefcdf4d7426ab739a095b5a8da89",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "61fc8b17a5a0466cb67b5015fb0f0e07",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "generation_config.json:   0%|          | 0.00/124 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "==================================================\n",
+      "Total parameters     : 1,533,189,120\n",
+      "Trainable (LoRA only): 11,796,480 (0.77%)\n",
+      "Frozen (base model)  : 1,521,392,640\n",
+      "==================================================\n",
+      "\n",
+      "VRAM used after loading: 2.41GB / 6.4GB\n",
+      "VRAM remaining         : 4.04GB (for activations & optimizer)\n",
+      "\n",
+      "✅ Model loaded and LoRA attached\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from transformers import (\n",
+    "    AutoTokenizer,\n",
+    "    AutoModelForCausalLM,\n",
+    "    BitsAndBytesConfig\n",
+    ")\n",
+    "from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training, TaskType\n",
+    "\n",
+    "MODEL_ID = \"microsoft/phi-2\"   # 2.7B — designed for 4GB VRAM\n",
+    "# Alternative if you want to try later (needs 8GB+):\n",
+    "# MODEL_ID = \"mistralai/Mistral-7B-Instruct-v0.3\"\n",
+    "\n",
+    "print(f\"Loading model: {MODEL_ID}\")\n",
+    "print(\"This downloads ~5.5GB on first run — subsequent runs use cache.\")\n",
+    "print()\n",
+    "\n",
+    "# ── 4-bit quantisation config (NF4 — best quality for QLoRA)\n",
+    "bnb_config = BitsAndBytesConfig(\n",
+    "    load_in_4bit=True,\n",
+    "    bnb_4bit_quant_type=\"nf4\",           # NormalFloat4 — better than fp4 for LLMs\n",
+    "    bnb_4bit_compute_dtype=torch.float16, # Compute in fp16 on RTX 3050\n",
+    "    bnb_4bit_use_double_quant=True,       # Nested quantisation saves ~0.4GB extra\n",
+    ")\n",
+    "\n",
+    "# ── Tokeniser\n",
+    "tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True)\n",
+    "tokenizer.pad_token = tokenizer.eos_token   # Phi-2 has no pad token by default\n",
+    "tokenizer.padding_side = \"right\"            # Pad right for causal LM training\n",
+    "\n",
+    "# ── Base model in 4-bit\n",
+    "model = AutoModelForCausalLM.from_pretrained(\n",
+    "    MODEL_ID,\n",
+    "    quantization_config=bnb_config,\n",
+    "    device_map=\"auto\",           # Automatically uses your GPU\n",
+    "    trust_remote_code=True,\n",
+    "    torch_dtype=torch.float16,\n",
+    ")\n",
+    "\n",
+    "# Prepare for k-bit training (required before adding LoRA)\n",
+    "model = prepare_model_for_kbit_training(model)\n",
+    "\n",
+    "# ── LoRA config\n",
+    "# r=8 keeps VRAM very low; increase to r=16 if you have headroom\n",
+    "lora_config = LoraConfig(\n",
+    "    task_type=TaskType.CAUSAL_LM,\n",
+    "    r=8,                         # Rank — lower = less VRAM\n",
+    "    lora_alpha=16,               # Scaling factor (2x rank is standard)\n",
+    "    lora_dropout=0.05,\n",
+    "    target_modules=[             # Phi-2 attention + MLP layers\n",
+    "        \"q_proj\", \"k_proj\", \"v_proj\", \"dense\",\n",
+    "        \"fc1\", \"fc2\"\n",
+    "    ],\n",
+    "    bias=\"none\",\n",
+    ")\n",
+    "\n",
+    "model = get_peft_model(model, lora_config)\n",
+    "\n",
+    "# Show trainable params\n",
+    "total_params     = sum(p.numel() for p in model.parameters())\n",
+    "trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
+    "print(f\"\\n{'='*50}\")\n",
+    "print(f\"Total parameters     : {total_params:,}\")\n",
+    "print(f\"Trainable (LoRA only): {trainable_params:,} ({trainable_params/total_params*100:.2f}%)\")\n",
+    "print(f\"Frozen (base model)  : {total_params - trainable_params:,}\")\n",
+    "print(f\"{'='*50}\")\n",
+    "print()\n",
+    "\n",
+    "# VRAM usage after loading\n",
+    "if torch.cuda.is_available():\n",
+    "    used  = torch.cuda.memory_allocated() / 1e9\n",
+    "    total = torch.cuda.get_device_properties(0).total_memory / 1e9\n",
+    "    print(f\"VRAM used after loading: {used:.2f}GB / {total:.1f}GB\")\n",
+    "    print(f\"VRAM remaining         : {total - used:.2f}GB (for activations & optimizer)\")\n",
+    "    if total - used < 1.0:\n",
+    "        print(\"⚠️  Very little VRAM left — set batch_size=1 in training config\")\n",
+    "\n",
+    "print(\"\\n✅ Model loaded and LoRA attached\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cell 8 — Tokenise dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tokenising with max_length=512...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7eec2ee4fe084bd29f78c35711dfbe6e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/1340 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "be7fc7ca958342f2a0db6eacdf72c71a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/167 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Token length stats (sample of 100):\n",
+      "  Mean : 553 tokens\n",
+      "  Max  : 863 tokens\n",
+      "  % truncated at 512: 75%\n",
+      "  ⚠️  High truncation — consider MAX_LENGTH=768 if VRAM allows\n",
+      "\n",
+      "✅ Tokenisation complete\n",
+      "   train_tok: 1340 examples\n",
+      "   val_tok  : 167 examples\n"
+     ]
+    }
+   ],
+   "source": [
+    "# RTX 3050 max safe sequence length\n",
+    "# Longer = more VRAM. 512 is safe; 768 if you have headroom.\n",
+    "MAX_LENGTH = 512\n",
+    "\n",
+    "def tokenize(batch):\n",
+    "    tokens = tokenizer(\n",
+    "        batch['text'],\n",
+    "        truncation=True,\n",
+    "        max_length=MAX_LENGTH,\n",
+    "        padding='max_length',\n",
+    "    )\n",
+    "    # For causal LM: labels = input_ids (model predicts next token)\n",
+    "    tokens['labels'] = tokens['input_ids'].copy()\n",
+    "    return tokens\n",
+    "\n",
+    "print(f\"Tokenising with max_length={MAX_LENGTH}...\")\n",
+    "train_tok = train_ds.map(tokenize, batched=True, remove_columns=['text'])\n",
+    "val_tok   = val_ds.map(tokenize,   batched=True, remove_columns=['text'])\n",
+    "\n",
+    "train_tok.set_format(type='torch', columns=['input_ids', 'attention_mask', 'labels'])\n",
+    "val_tok.set_format(  type='torch', columns=['input_ids', 'attention_mask', 'labels'])\n",
+    "\n",
+    "# Check how many examples were truncated\n",
+    "sample_lens = [len(tokenizer(t)['input_ids']) for t in train_df['training_text'].head(100)]\n",
+    "truncated = sum(1 for l in sample_lens if l >= MAX_LENGTH)\n",
+    "print(f\"\\nToken length stats (sample of 100):\")\n",
+    "print(f\"  Mean : {np.mean(sample_lens):.0f} tokens\")\n",
+    "print(f\"  Max  : {max(sample_lens)} tokens\")\n",
+    "print(f\"  % truncated at {MAX_LENGTH}: {truncated}%\")\n",
+    "if truncated > 30:\n",
+    "    print(f\"  ⚠️  High truncation — consider MAX_LENGTH=768 if VRAM allows\")\n",
+    "print()\n",
+    "print(\"✅ Tokenisation complete\")\n",
+    "print(f\"   train_tok: {len(train_tok)} examples\")\n",
+    "print(f\"   val_tok  : {len(val_tok)} examples\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cell 9 — Training configuration (RTX 3050 optimised)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training configuration summary:\n",
+      "  Model              : microsoft/phi-2\n",
+      "  Epochs             : 3\n",
+      "  Batch size         : 1 × 8 steps = effective 8\n",
+      "  Learning rate      : 0.0002\n",
+      "  FP16               : True\n",
+      "  Gradient checkpoint: True\n",
+      "  Optimizer          : paged_adamw_8bit\n",
+      "  Output dir         : ./pels_phi2_qlora\n",
+      "\n",
+      "Estimated training time on RTX 3050:\n",
+      "  Steps per epoch : 1340\n",
+      "  Total steps     : 4020\n",
+      "  Estimated time  : 234 minutes (~3.9 hours)\n",
+      "\n",
+      "✅ Training config ready\n"
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import TrainingArguments, DataCollatorForLanguageModeling\n",
+    "from trl import SFTTrainer\n",
+    "import os\n",
+    "\n",
+    "OUTPUT_DIR = \"./pels_phi2_qlora\"\n",
+    "os.makedirs(OUTPUT_DIR, exist_ok=True)\n",
+    "\n",
+    "# ── RTX 3050 tuned settings\n",
+    "# Effective batch size = per_device_batch * gradient_accumulation = 1 * 8 = 8\n",
+    "# This gives reasonable gradient estimates without OOM\n",
+    "\n",
+    "training_args = TrainingArguments(\n",
+    "    output_dir=OUTPUT_DIR,\n",
+    "    num_train_epochs=3,                  # 3 epochs on 1,400 examples\n",
+    "\n",
+    "    # ── Batch size (critical for RTX 3050)\n",
+    "    per_device_train_batch_size=1,       # DO NOT increase on 4GB VRAM\n",
+    "    per_device_eval_batch_size=1,\n",
+    "    gradient_accumulation_steps=8,       # Simulates batch size of 8\n",
+    "\n",
+    "    # ── Memory saving flags\n",
+    "    gradient_checkpointing=True,         # Saves ~1GB VRAM, slows training 20%\n",
+    "    fp16=True,                           # fp16 on RTX 3050 (no bf16 support)\n",
+    "    optim=\"paged_adamw_8bit\",            # 8-bit optimizer — saves ~0.5GB VRAM\n",
+    "    dataloader_pin_memory=False,         # Avoid extra RAM usage\n",
+    "\n",
+    "    # ── Learning rate\n",
+    "    learning_rate=2e-4,\n",
+    "    lr_scheduler_type=\"cosine\",\n",
+    "    warmup_ratio=0.05,\n",
+    "    weight_decay=0.01,\n",
+    "\n",
+    "    # ── Logging & evaluation\n",
+    "    logging_steps=25,\n",
+    "    evaluation_strategy=\"steps\",\n",
+    "    eval_steps=100,\n",
+    "    save_strategy=\"steps\",\n",
+    "    save_steps=100,\n",
+    "    save_total_limit=2,                  # Keep only 2 checkpoints (saves disk)\n",
+    "    load_best_model_at_end=True,\n",
+    "    metric_for_best_model=\"eval_loss\",\n",
+    "\n",
+    "    # ── Misc\n",
+    "    report_to=\"none\",                    # Disable wandb/tensorboard\n",
+    "    seed=42,\n",
+    "    group_by_length=True,                # Group similar-length examples = faster\n",
+    ")\n",
+    "\n",
+    "# Data collator for causal language modeling\n",
+    "data_collator = DataCollatorForLanguageModeling(\n",
+    "    tokenizer=tokenizer,\n",
+    "    mlm=False    # Causal LM, not masked LM\n",
+    ")\n",
+    "\n",
+    "print(\"Training configuration summary:\")\n",
+    "print(f\"  Model              : {MODEL_ID}\")\n",
+    "print(f\"  Epochs             : {training_args.num_train_epochs}\")\n",
+    "print(f\"  Batch size         : {training_args.per_device_train_batch_size} × {training_args.gradient_accumulation_steps} steps = effective {training_args.per_device_train_batch_size * training_args.gradient_accumulation_steps}\")\n",
+    "print(f\"  Learning rate      : {training_args.learning_rate}\")\n",
+    "print(f\"  FP16               : {training_args.fp16}\")\n",
+    "print(f\"  Gradient checkpoint: {training_args.gradient_checkpointing}\")\n",
+    "print(f\"  Optimizer          : {training_args.optim}\")\n",
+    "print(f\"  Output dir         : {OUTPUT_DIR}\")\n",
+    "\n",
+    "# Estimated training time for RTX 3050\n",
+    "steps_per_epoch = len(train_tok) // training_args.per_device_train_batch_size\n",
+    "total_steps = steps_per_epoch * training_args.num_train_epochs\n",
+    "est_minutes = total_steps * 3.5 / 60  # ~3.5 sec/step on RTX 3050\n",
+    "print(f\"\\nEstimated training time on RTX 3050:\")\n",
+    "print(f\"  Steps per epoch : {steps_per_epoch}\")\n",
+    "print(f\"  Total steps     : {total_steps}\")\n",
+    "print(f\"  Estimated time  : {est_minutes:.0f} minutes (~{est_minutes/60:.1f} hours)\")\n",
+    "print()\n",
+    "print(\"✅ Training config ready\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cell 10 — Train the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d3e30d60c99146dd8c34ff646ac7478b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/1340 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "06e1af8d32ba410e88b7d5d6ca1ff102",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/167 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting PELS fine-tuning...\n",
+      "Monitor VRAM with: nvidia-smi (in a separate terminal)\n",
+      "--------------------------------------------------\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`...\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <div>\n",
+       "      \n",
+       "      <progress value='501' max='501' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+       "      [501/501 2:48:21, Epoch 2/3]\n",
+       "    </div>\n",
+       "    <table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       " <tr style=\"text-align: left;\">\n",
+       "      <th>Step</th>\n",
+       "      <th>Training Loss</th>\n",
+       "      <th>Validation Loss</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>100</td>\n",
+       "      <td>0.457600</td>\n",
+       "      <td>0.350264</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>200</td>\n",
+       "      <td>0.332100</td>\n",
+       "      <td>0.276849</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>300</td>\n",
+       "      <td>0.239400</td>\n",
+       "      <td>0.264530</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>400</td>\n",
+       "      <td>0.336500</td>\n",
+       "      <td>0.256963</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>500</td>\n",
+       "      <td>0.195700</td>\n",
+       "      <td>0.255853</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table><p>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "==================================================\n",
+      "Training complete in 168.8 minutes\n",
+      "Final train loss : 0.4714\n",
+      "==================================================\n",
+      "\n",
+      "✅ LoRA adapter saved to: ./pels_phi2_qlora\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loss curve saved.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from trl import SFTTrainer\n",
+    "import time\n",
+    "\n",
+    "trainer = SFTTrainer(\n",
+    "    model=model,\n",
+    "    args=training_args,\n",
+    "    train_dataset=train_ds,      # ← raw dataset, not pre-tokenized\n",
+    "    eval_dataset=val_ds,\n",
+    "    tokenizer=tokenizer,\n",
+    "    peft_config=lora_config,\n",
+    "    dataset_text_field=\"text\",   # ← the column name from your Dataset.from_dict()\n",
+    "    max_seq_length=MAX_LENGTH,\n",
+    ")\n",
+    "\n",
+    "print(\"Starting PELS fine-tuning...\")\n",
+    "print(\"Monitor VRAM with: nvidia-smi (in a separate terminal)\")\n",
+    "print(\"-\" * 50)\n",
+    "\n",
+    "start = time.time()\n",
+    "\n",
+    "# ── TRAIN\n",
+    "train_result = trainer.train()\n",
+    "\n",
+    "elapsed = (time.time() - start) / 60\n",
+    "print(f\"\\n{'='*50}\")\n",
+    "print(f\"Training complete in {elapsed:.1f} minutes\")\n",
+    "print(f\"Final train loss : {train_result.training_loss:.4f}\")\n",
+    "print(f\"{'='*50}\")\n",
+    "\n",
+    "# Save LoRA adapter weights\n",
+    "trainer.save_model(OUTPUT_DIR)\n",
+    "tokenizer.save_pretrained(OUTPUT_DIR)\n",
+    "print(f\"\\n✅ LoRA adapter saved to: {OUTPUT_DIR}\")\n",
+    "\n",
+    "# Training loss history\n",
+    "loss_log = [x for x in trainer.state.log_history if 'loss' in x and 'eval_loss' not in x]\n",
+    "if loss_log:\n",
+    "    steps = [x['step'] for x in loss_log]\n",
+    "    losses = [x['loss'] for x in loss_log]\n",
+    "    plt.figure(figsize=(10, 4))\n",
+    "    plt.plot(steps, losses, 'b-o', markersize=3, label='Train Loss')\n",
+    "    plt.xlabel('Step')\n",
+    "    plt.ylabel('Loss')\n",
+    "    plt.title('PELS Training Loss')\n",
+    "    plt.legend()\n",
+    "    plt.grid(alpha=0.3)\n",
+    "    plt.tight_layout()\n",
+    "    plt.savefig('pels_training_loss.png', dpi=120)\n",
+    "    plt.show()\n",
+    "    print(f\"Loss curve saved.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cell 11 — Evaluate on test set (MAE per category)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Evaluating on test set (50 samples)...\n",
+      "  Evaluated 10/50\n",
+      "\n",
+      "==================================================\n",
+      "Mean Absolute Error (MAE) per category:\n",
+      "(Lower is better. Target: MAE < 1.0 per category)\n",
+      "----------------------------------------\n",
+      "  C1 Foundations        : MAE = 1.200  ⚠️\n",
+      "  C2 Design             : MAE = 0.700  ✅\n",
+      "  C3 Output Spec        : MAE = 1.100  ⚠️\n",
+      "  C4 Domain             : MAE = 1.000  ⚠️\n",
+      "  C5 Ethics             : MAE = 1.300  ⚠️\n",
+      "  C6 Metacognition      : MAE = 1.400  ⚠️\n",
+      "  Final Score           : MAE = 0.855  ✅\n",
+      "==================================================\n",
+      "  Overall MAE (avg): 1.079\n",
+      "  C5 Veto detection accuracy: 100.0% (target: >95%)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import re\n",
+    "import numpy as np\n",
+    "\n",
+    "def extract_scores(text):\n",
+    "    \"\"\"Parse C1–C6 and Final_Score from model output text.\"\"\"\n",
+    "    patterns = {\n",
+    "        'c1': r'C1_Foundations:\\s*([0-9.]+)',\n",
+    "        'c2': r'C2_Design:\\s*([0-9.]+)',\n",
+    "        'c3': r'C3_OutputSpec:\\s*([0-9.]+)',\n",
+    "        'c4': r'C4_Domain:\\s*([0-9.]+)',\n",
+    "        'c5': r'C5_Ethics:\\s*([0-9.]+)',\n",
+    "        'c6': r'C6_Metacognition:\\s*([0-9.]+)',\n",
+    "        'final': r'Final_Score:\\s*([0-9.]+)',\n",
+    "    }\n",
+    "    results = {}\n",
+    "    for key, pat in patterns.items():\n",
+    "        m = re.search(pat, text)\n",
+    "        results[key] = float(m.group(1)) if m else None\n",
+    "    return results\n",
+    "\n",
+    "def grade_prompt(prompt_text, domain, model, tokenizer, max_new_tokens=300):\n",
+    "    \"\"\"Run inference: prompt + domain → scores + justification.\"\"\"\n",
+    "    input_text = (\n",
+    "        f\"Instruct: ### PELS Grading Task\\n\"\n",
+    "        f\"Domain: {domain}\\n\"\n",
+    "        f\"Rubric:\\n{RUBRIC}\\n\\n\"\n",
+    "        f\"Candidate Prompt:\\n{prompt_text}\\n\\n\"\n",
+    "        f\"### Evaluation\\n\"\n",
+    "        f\"Score each category 1–10. Ethics score of 1 overrides all others.\\n\"\n",
+    "        f\"Output:\"\n",
+    "    )\n",
+    "    inputs = tokenizer(input_text, return_tensors='pt', truncation=True, max_length=MAX_LENGTH).to(model.device)\n",
+    "    with torch.no_grad():\n",
+    "        outputs = model.generate(\n",
+    "            **inputs,\n",
+    "            max_new_tokens=max_new_tokens,\n",
+    "            temperature=0.3,\n",
+    "            do_sample=True,\n",
+    "            pad_token_id=tokenizer.eos_token_id,\n",
+    "        )\n",
+    "    decoded = tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
+    "    # Extract only the generated part\n",
+    "    output_part = decoded[len(input_text):] if input_text in decoded else decoded\n",
+    "    return output_part, extract_scores(output_part)\n",
+    "\n",
+    "# Evaluate on 50 test examples\n",
+    "print(\"Evaluating on test set (50 samples)...\")\n",
+    "eval_sample = test_df.head(10)\n",
+    "\n",
+    "results = []\n",
+    "for i, (_, row) in enumerate(eval_sample.iterrows()):\n",
+    "    _, pred_scores = grade_prompt(row['prompt_text'], row['domain'], model, tokenizer)\n",
+    "    gt_scores = {'c1': row['c1'], 'c2': row['c2'], 'c3': row['c3'],\n",
+    "                 'c4': row['c4'], 'c5': row['c5'], 'c6': row['c6'], 'final': row['final_score']}\n",
+    "    results.append({'gt': gt_scores, 'pred': pred_scores})\n",
+    "    if (i + 1) % 10 == 0:\n",
+    "        print(f\"  Evaluated {i+1}/50\")\n",
+    "\n",
+    "# MAE per category\n",
+    "print(\"\\n\" + \"=\"*50)\n",
+    "print(\"Mean Absolute Error (MAE) per category:\")\n",
+    "print(\"(Lower is better. Target: MAE < 1.0 per category)\")\n",
+    "print(\"-\" * 40)\n",
+    "\n",
+    "cat_names = ['c1','c2','c3','c4','c5','c6','final']\n",
+    "display_names = ['C1 Foundations','C2 Design','C3 Output Spec','C4 Domain','C5 Ethics','C6 Metacognition','Final Score']\n",
+    "all_maes = {}\n",
+    "\n",
+    "for cat, name in zip(cat_names, display_names):\n",
+    "    errors = []\n",
+    "    for r in results:\n",
+    "        gt = r['gt'].get(cat)\n",
+    "        pred = r['pred'].get(cat)\n",
+    "        if gt is not None and pred is not None:\n",
+    "            errors.append(abs(float(gt) - float(pred)))\n",
+    "    mae = np.mean(errors) if errors else float('nan')\n",
+    "    all_maes[cat] = mae\n",
+    "    status = \"✅\" if mae < 1.0 else \"⚠️\" if mae < 1.5 else \"❌\"\n",
+    "    print(f\"  {name:22s}: MAE = {mae:.3f}  {status}\")\n",
+    "\n",
+    "print(\"=\"*50)\n",
+    "overall = np.nanmean(list(all_maes.values()))\n",
+    "print(f\"  Overall MAE (avg): {overall:.3f}\")\n",
+    "\n",
+    "# C5 veto accuracy\n",
+    "veto_gt   = [r['gt']['c5'] == 1.0 for r in results]\n",
+    "veto_pred = [r['pred'].get('c5') == 1.0 for r in results]\n",
+    "veto_acc  = sum(a==b for a,b in zip(veto_gt, veto_pred)) / len(veto_gt) * 100\n",
+    "print(f\"  C5 Veto detection accuracy: {veto_acc:.1f}% (target: >95%)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cell 12 — Live inference demo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "============================================================\n",
+      "PELS Live Inference Demo\n",
+      "============================================================\n",
+      "\n",
+      "Expected tier  : weak\n",
+      "Domain         : CAREER\n",
+      "Prompt: help me with my resume\n",
+      "----------------------------------------\n",
+      "Predicted scores:\n",
+      "  C1      :  1.0  [█░░░░░░░░░]\n",
+      "  C2      :  1.0  [█░░░░░░░░░]\n",
+      "  C3      :  1.0  [█░░░░░░░░░]\n",
+      "  C4      :  2.0  [██░░░░░░░░]\n",
+      "  C5      :  2.0  [██░░░░░░░░]\n",
+      "  C6      :  1.0  [█░░░░░░░░░]\n",
+      "  FINAL   :  1.4  [█░░░░░░░░░]\n",
+      "\n",
+      "\n",
+      "Expected tier  : developing\n",
+      "Domain         : CAREER\n",
+      "Prompt         : Write a professional LinkedIn summary for a software engineer with 3 years of experience in Python a...\n",
+      "----------------------------------------\n"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[14], line 26\u001b[0m\n\u001b[0;32m     23\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPrompt         : \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtc[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mprompt\u001b[39m\u001b[38;5;124m'\u001b[39m][:\u001b[38;5;241m100\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m...\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(tc[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mprompt\u001b[39m\u001b[38;5;124m'\u001b[39m])\u001b[38;5;241m>\u001b[39m\u001b[38;5;241m100\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPrompt: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtc[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mprompt\u001b[39m\u001b[38;5;124m'\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m     24\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m-\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m40\u001b[39m)\n\u001b[1;32m---> 26\u001b[0m output_text, scores \u001b[38;5;241m=\u001b[39m \u001b[43mgrade_prompt\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtc\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mprompt\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtc\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mdomain\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtokenizer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     28\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m scores \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28many\u001b[39m(v \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01mfor\u001b[39;00m v \u001b[38;5;129;01min\u001b[39;00m scores\u001b[38;5;241m.\u001b[39mvalues()):\n\u001b[0;32m     29\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPredicted scores:\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
+      "Cell \u001b[1;32mIn[13], line 34\u001b[0m, in \u001b[0;36mgrade_prompt\u001b[1;34m(prompt_text, domain, model, tokenizer, max_new_tokens)\u001b[0m\n\u001b[0;32m     32\u001b[0m inputs \u001b[38;5;241m=\u001b[39m tokenizer(input_text, return_tensors\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mpt\u001b[39m\u001b[38;5;124m'\u001b[39m, truncation\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, max_length\u001b[38;5;241m=\u001b[39mMAX_LENGTH)\u001b[38;5;241m.\u001b[39mto(model\u001b[38;5;241m.\u001b[39mdevice)\n\u001b[0;32m     33\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mno_grad():\n\u001b[1;32m---> 34\u001b[0m     outputs \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mgenerate(\n\u001b[0;32m     35\u001b[0m         \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39minputs,\n\u001b[0;32m     36\u001b[0m         max_new_tokens\u001b[38;5;241m=\u001b[39mmax_new_tokens,\n\u001b[0;32m     37\u001b[0m         temperature\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.3\u001b[39m,\n\u001b[0;32m     38\u001b[0m         do_sample\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[0;32m     39\u001b[0m         pad_token_id\u001b[38;5;241m=\u001b[39mtokenizer\u001b[38;5;241m.\u001b[39meos_token_id,\n\u001b[0;32m     40\u001b[0m     )\n\u001b[0;32m     41\u001b[0m decoded \u001b[38;5;241m=\u001b[39m tokenizer\u001b[38;5;241m.\u001b[39mdecode(outputs[\u001b[38;5;241m0\u001b[39m], skip_special_tokens\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[0;32m     42\u001b[0m \u001b[38;5;66;03m# Extract only the generated part\u001b[39;00m\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\peft\\peft_model.py:1190\u001b[0m, in \u001b[0;36mPeftModelForCausalLM.generate\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1188\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_enable_peft_forward_hooks(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m   1189\u001b[0m         kwargs \u001b[38;5;241m=\u001b[39m {k: v \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m kwargs\u001b[38;5;241m.\u001b[39mitems() \u001b[38;5;28;01mif\u001b[39;00m k \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mspecial_peft_forward_args}\n\u001b[1;32m-> 1190\u001b[0m         outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbase_model\u001b[38;5;241m.\u001b[39mgenerate(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m   1191\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m   1192\u001b[0m     outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbase_model\u001b[38;5;241m.\u001b[39mgenerate(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\utils\\_contextlib.py:116\u001b[0m, in \u001b[0;36mcontext_decorator.<locals>.decorate_context\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    113\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[0;32m    114\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mdecorate_context\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m    115\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m ctx_factory():\n\u001b[1;32m--> 116\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m func(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\transformers\\generation\\utils.py:1622\u001b[0m, in \u001b[0;36mGenerationMixin.generate\u001b[1;34m(self, inputs, generation_config, logits_processor, stopping_criteria, prefix_allowed_tokens_fn, synced_gpus, assistant_model, streamer, negative_prompt_ids, negative_prompt_attention_mask, **kwargs)\u001b[0m\n\u001b[0;32m   1614\u001b[0m     input_ids, model_kwargs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_expand_inputs_for_generation(\n\u001b[0;32m   1615\u001b[0m         input_ids\u001b[38;5;241m=\u001b[39minput_ids,\n\u001b[0;32m   1616\u001b[0m         expand_size\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39mnum_return_sequences,\n\u001b[0;32m   1617\u001b[0m         is_encoder_decoder\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39mis_encoder_decoder,\n\u001b[0;32m   1618\u001b[0m         \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mmodel_kwargs,\n\u001b[0;32m   1619\u001b[0m     )\n\u001b[0;32m   1621\u001b[0m     \u001b[38;5;66;03m# 13. run sample\u001b[39;00m\n\u001b[1;32m-> 1622\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sample(\n\u001b[0;32m   1623\u001b[0m         input_ids,\n\u001b[0;32m   1624\u001b[0m         logits_processor\u001b[38;5;241m=\u001b[39mprepared_logits_processor,\n\u001b[0;32m   1625\u001b[0m         logits_warper\u001b[38;5;241m=\u001b[39mlogits_warper,\n\u001b[0;32m   1626\u001b[0m         stopping_criteria\u001b[38;5;241m=\u001b[39mprepared_stopping_criteria,\n\u001b[0;32m   1627\u001b[0m         pad_token_id\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39mpad_token_id,\n\u001b[0;32m   1628\u001b[0m         output_scores\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39moutput_scores,\n\u001b[0;32m   1629\u001b[0m         output_logits\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39moutput_logits,\n\u001b[0;32m   1630\u001b[0m         return_dict_in_generate\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39mreturn_dict_in_generate,\n\u001b[0;32m   1631\u001b[0m         synced_gpus\u001b[38;5;241m=\u001b[39msynced_gpus,\n\u001b[0;32m   1632\u001b[0m         streamer\u001b[38;5;241m=\u001b[39mstreamer,\n\u001b[0;32m   1633\u001b[0m         \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mmodel_kwargs,\n\u001b[0;32m   1634\u001b[0m     )\n\u001b[0;32m   1636\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m generation_mode \u001b[38;5;241m==\u001b[39m GenerationMode\u001b[38;5;241m.\u001b[39mBEAM_SEARCH:\n\u001b[0;32m   1637\u001b[0m     \u001b[38;5;66;03m# 11. prepare beam search scorer\u001b[39;00m\n\u001b[0;32m   1638\u001b[0m     beam_scorer \u001b[38;5;241m=\u001b[39m BeamSearchScorer(\n\u001b[0;32m   1639\u001b[0m         batch_size\u001b[38;5;241m=\u001b[39mbatch_size,\n\u001b[0;32m   1640\u001b[0m         num_beams\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39mnum_beams,\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   1645\u001b[0m         max_length\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39mmax_length,\n\u001b[0;32m   1646\u001b[0m     )\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\transformers\\generation\\utils.py:2791\u001b[0m, in \u001b[0;36mGenerationMixin._sample\u001b[1;34m(self, input_ids, logits_processor, stopping_criteria, logits_warper, max_length, pad_token_id, eos_token_id, output_attentions, output_hidden_states, output_scores, output_logits, return_dict_in_generate, synced_gpus, streamer, **model_kwargs)\u001b[0m\n\u001b[0;32m   2788\u001b[0m model_inputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprepare_inputs_for_generation(input_ids, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mmodel_kwargs)\n\u001b[0;32m   2790\u001b[0m \u001b[38;5;66;03m# forward pass to get next token\u001b[39;00m\n\u001b[1;32m-> 2791\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m(\n\u001b[0;32m   2792\u001b[0m     \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mmodel_inputs,\n\u001b[0;32m   2793\u001b[0m     return_dict\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[0;32m   2794\u001b[0m     output_attentions\u001b[38;5;241m=\u001b[39moutput_attentions,\n\u001b[0;32m   2795\u001b[0m     output_hidden_states\u001b[38;5;241m=\u001b[39moutput_hidden_states,\n\u001b[0;32m   2796\u001b[0m )\n\u001b[0;32m   2798\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m synced_gpus \u001b[38;5;129;01mand\u001b[39;00m this_peer_finished:\n\u001b[0;32m   2799\u001b[0m     \u001b[38;5;28;01mcontinue\u001b[39;00m  \u001b[38;5;66;03m# don't waste resources running the code we don't need\u001b[39;00m\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m forward_call(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\accelerate\\hooks.py:166\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[1;34m(module, *args, **kwargs)\u001b[0m\n\u001b[0;32m    164\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    165\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 166\u001b[0m     output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    167\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\transformers\\models\\phi\\modeling_phi.py:1169\u001b[0m, in \u001b[0;36mPhiForCausalLM.forward\u001b[1;34m(self, input_ids, attention_mask, position_ids, past_key_values, inputs_embeds, labels, use_cache, output_attentions, output_hidden_states, return_dict)\u001b[0m\n\u001b[0;32m   1166\u001b[0m return_dict \u001b[38;5;241m=\u001b[39m return_dict \u001b[38;5;28;01mif\u001b[39;00m return_dict \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39muse_return_dict\n\u001b[0;32m   1168\u001b[0m \u001b[38;5;66;03m# decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)\u001b[39;00m\n\u001b[1;32m-> 1169\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m   1170\u001b[0m \u001b[43m    \u001b[49m\u001b[43minput_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minput_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1171\u001b[0m \u001b[43m    \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1172\u001b[0m \u001b[43m    \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1173\u001b[0m \u001b[43m    \u001b[49m\u001b[43mpast_key_values\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_values\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1174\u001b[0m \u001b[43m    \u001b[49m\u001b[43minputs_embeds\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minputs_embeds\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1175\u001b[0m \u001b[43m    \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1176\u001b[0m \u001b[43m    \u001b[49m\u001b[43moutput_attentions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_attentions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1177\u001b[0m \u001b[43m    \u001b[49m\u001b[43moutput_hidden_states\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_hidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1178\u001b[0m \u001b[43m    \u001b[49m\u001b[43mreturn_dict\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreturn_dict\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1179\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1181\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m outputs[\u001b[38;5;241m0\u001b[39m]\n\u001b[0;32m   1182\u001b[0m logits \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlm_head(hidden_states)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m forward_call(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\accelerate\\hooks.py:166\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[1;34m(module, *args, **kwargs)\u001b[0m\n\u001b[0;32m    164\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    165\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 166\u001b[0m     output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    167\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\transformers\\models\\phi\\modeling_phi.py:1048\u001b[0m, in \u001b[0;36mPhiModel.forward\u001b[1;34m(self, input_ids, attention_mask, position_ids, past_key_values, inputs_embeds, use_cache, output_attentions, output_hidden_states, return_dict)\u001b[0m\n\u001b[0;32m   1039\u001b[0m     layer_outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_gradient_checkpointing_func(\n\u001b[0;32m   1040\u001b[0m         decoder_layer\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__call__\u001b[39m,\n\u001b[0;32m   1041\u001b[0m         hidden_states,\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   1045\u001b[0m         output_attentions,\n\u001b[0;32m   1046\u001b[0m     )\n\u001b[0;32m   1047\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1048\u001b[0m     layer_outputs \u001b[38;5;241m=\u001b[39m \u001b[43mdecoder_layer\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m   1049\u001b[0m \u001b[43m        \u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1050\u001b[0m \u001b[43m        \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1051\u001b[0m \u001b[43m        \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1052\u001b[0m \u001b[43m        \u001b[49m\u001b[43mpast_key_value\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_values\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1053\u001b[0m \u001b[43m        \u001b[49m\u001b[43moutput_attentions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_attentions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1054\u001b[0m \u001b[43m        \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1055\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1057\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m layer_outputs[\u001b[38;5;241m0\u001b[39m]\n\u001b[0;32m   1059\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m use_cache:\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m forward_call(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\accelerate\\hooks.py:166\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[1;34m(module, *args, **kwargs)\u001b[0m\n\u001b[0;32m    164\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    165\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 166\u001b[0m     output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    167\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\transformers\\models\\phi\\modeling_phi.py:779\u001b[0m, in \u001b[0;36mPhiDecoderLayer.forward\u001b[1;34m(self, hidden_states, attention_mask, position_ids, output_attentions, use_cache, past_key_value)\u001b[0m\n\u001b[0;32m    776\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minput_layernorm(hidden_states)\n\u001b[0;32m    778\u001b[0m \u001b[38;5;66;03m# Self Attention\u001b[39;00m\n\u001b[1;32m--> 779\u001b[0m attn_outputs, self_attn_weights, present_key_value \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mself_attn\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m    780\u001b[0m \u001b[43m    \u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    781\u001b[0m \u001b[43m    \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    782\u001b[0m \u001b[43m    \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    783\u001b[0m \u001b[43m    \u001b[49m\u001b[43mpast_key_value\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_value\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    784\u001b[0m \u001b[43m    \u001b[49m\u001b[43moutput_attentions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_attentions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    785\u001b[0m \u001b[43m    \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    786\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    787\u001b[0m attn_outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mresid_dropout(attn_outputs)\n\u001b[0;32m    789\u001b[0m feed_forward_hidden_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mresid_dropout(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmlp(hidden_states))\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m forward_call(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\accelerate\\hooks.py:166\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[1;34m(module, *args, **kwargs)\u001b[0m\n\u001b[0;32m    164\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    165\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 166\u001b[0m     output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    167\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\transformers\\models\\phi\\modeling_phi.py:663\u001b[0m, in \u001b[0;36mPhiSdpaAttention.forward\u001b[1;34m(self, hidden_states, attention_mask, position_ids, past_key_value, output_attentions, use_cache)\u001b[0m\n\u001b[0;32m    661\u001b[0m query_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mq_proj(hidden_states)\n\u001b[0;32m    662\u001b[0m key_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mk_proj(hidden_states)\n\u001b[1;32m--> 663\u001b[0m value_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mv_proj\u001b[49m\u001b[43m(\u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    665\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mqk_layernorm:\n\u001b[0;32m    666\u001b[0m     query_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mq_layernorm(query_states)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m forward_call(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\peft\\tuners\\lora\\bnb.py:458\u001b[0m, in \u001b[0;36mLinear4bit.forward\u001b[1;34m(self, x, *args, **kwargs)\u001b[0m\n\u001b[0;32m    452\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbase_layer(x, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    453\u001b[0m \u001b[38;5;66;03m# As per Tim Dettmers, for 4bit, we need to defensively clone here.\u001b[39;00m\n\u001b[0;32m    454\u001b[0m \u001b[38;5;66;03m# The reason is that in some cases, an error can occur that backprop\u001b[39;00m\n\u001b[0;32m    455\u001b[0m \u001b[38;5;66;03m# does not work on a manipulated view. This issue may be solved with\u001b[39;00m\n\u001b[0;32m    456\u001b[0m \u001b[38;5;66;03m# newer PyTorch versions but this would need extensive testing to be\u001b[39;00m\n\u001b[0;32m    457\u001b[0m \u001b[38;5;66;03m# sure.\u001b[39;00m\n\u001b[1;32m--> 458\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mresult\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mclone\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    460\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m active_adapter \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mactive_adapters:\n\u001b[0;32m    461\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m active_adapter \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlora_A\u001b[38;5;241m.\u001b[39mkeys():\n",
+      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
+     ]
+    }
+   ],
+   "source": [
+    "# ── Test with a real example from each skill tier\n",
+    "\n",
+    "test_cases = [\n",
+    "    # Weak\n",
+    "    {\"prompt\": \"help me with my resume\", \"domain\": \"CAREER\", \"expected_tier\": \"weak\"},\n",
+    "    # Developing\n",
+    "    {\"prompt\": \"Write a professional LinkedIn summary for a software engineer with 3 years of experience in Python and cloud infrastructure.\",\n",
+    "     \"domain\": \"CAREER\", \"expected_tier\": \"developing\"},\n",
+    "    # Strong\n",
+    "    {\"prompt\": \"Act as an expert career coach. I'm a data scientist (4 years exp, Python/SQL/ML) transitioning to product management. \"\n",
+    "               \"Write a 150-word LinkedIn About section that: highlights transferable analytical skills, \"\n",
+    "               \"signals PM mindset, avoids jargon, and ends with a specific call-to-action.\",\n",
+    "     \"domain\": \"CAREER\", \"expected_tier\": \"strong\"},\n",
+    "]\n",
+    "\n",
+    "print(\"=\" * 60)\n",
+    "print(\"PELS Live Inference Demo\")\n",
+    "print(\"=\" * 60)\n",
+    "\n",
+    "for tc in test_cases:\n",
+    "    print(f\"\\nExpected tier  : {tc['expected_tier']}\")\n",
+    "    print(f\"Domain         : {tc['domain']}\")\n",
+    "    print(f\"Prompt         : {tc['prompt'][:100]}...\" if len(tc['prompt'])>100 else f\"Prompt: {tc['prompt']}\")\n",
+    "    print(\"-\" * 40)\n",
+    "\n",
+    "    output_text, scores = grade_prompt(tc['prompt'], tc['domain'], model, tokenizer)\n",
+    "\n",
+    "    if scores and any(v is not None for v in scores.values()):\n",
+    "        print(\"Predicted scores:\")\n",
+    "        for k, v in scores.items():\n",
+    "            if v is not None:\n",
+    "                bar = '█' * int(v) + '░' * (10 - int(v))\n",
+    "                print(f\"  {k.upper():8s}: {v:4.1f}  [{bar}]\")\n",
+    "    else:\n",
+    "        print(\"Raw output:\")\n",
+    "        print(output_text[:400])\n",
+    "    print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[15], line 7\u001b[0m\n\u001b[0;32m      4\u001b[0m test_domain \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCAREER\u001b[39m\u001b[38;5;124m\"\u001b[39m   \u001b[38;5;66;03m# Change to: EDUCATION, HEALTHCARE, LEGAL, TECHNOLOGY, MARKETING, FINANCE, CREATIVE\u001b[39;00m\n\u001b[0;32m      6\u001b[0m \u001b[38;5;66;03m# ── Run inference\u001b[39;00m\n\u001b[1;32m----> 7\u001b[0m raw_output, scores \u001b[38;5;241m=\u001b[39m \u001b[43mgrade_prompt\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtest_prompt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtest_domain\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtokenizer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m      9\u001b[0m \u001b[38;5;66;03m# ── Display results\u001b[39;00m\n\u001b[0;32m     10\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m=\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m55\u001b[39m)\n",
+      "Cell \u001b[1;32mIn[13], line 34\u001b[0m, in \u001b[0;36mgrade_prompt\u001b[1;34m(prompt_text, domain, model, tokenizer, max_new_tokens)\u001b[0m\n\u001b[0;32m     32\u001b[0m inputs \u001b[38;5;241m=\u001b[39m tokenizer(input_text, return_tensors\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mpt\u001b[39m\u001b[38;5;124m'\u001b[39m, truncation\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, max_length\u001b[38;5;241m=\u001b[39mMAX_LENGTH)\u001b[38;5;241m.\u001b[39mto(model\u001b[38;5;241m.\u001b[39mdevice)\n\u001b[0;32m     33\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mno_grad():\n\u001b[1;32m---> 34\u001b[0m     outputs \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mgenerate(\n\u001b[0;32m     35\u001b[0m         \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39minputs,\n\u001b[0;32m     36\u001b[0m         max_new_tokens\u001b[38;5;241m=\u001b[39mmax_new_tokens,\n\u001b[0;32m     37\u001b[0m         temperature\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.3\u001b[39m,\n\u001b[0;32m     38\u001b[0m         do_sample\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[0;32m     39\u001b[0m         pad_token_id\u001b[38;5;241m=\u001b[39mtokenizer\u001b[38;5;241m.\u001b[39meos_token_id,\n\u001b[0;32m     40\u001b[0m     )\n\u001b[0;32m     41\u001b[0m decoded \u001b[38;5;241m=\u001b[39m tokenizer\u001b[38;5;241m.\u001b[39mdecode(outputs[\u001b[38;5;241m0\u001b[39m], skip_special_tokens\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[0;32m     42\u001b[0m \u001b[38;5;66;03m# Extract only the generated part\u001b[39;00m\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\peft\\peft_model.py:1190\u001b[0m, in \u001b[0;36mPeftModelForCausalLM.generate\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1188\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_enable_peft_forward_hooks(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m   1189\u001b[0m         kwargs \u001b[38;5;241m=\u001b[39m {k: v \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m kwargs\u001b[38;5;241m.\u001b[39mitems() \u001b[38;5;28;01mif\u001b[39;00m k \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mspecial_peft_forward_args}\n\u001b[1;32m-> 1190\u001b[0m         outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbase_model\u001b[38;5;241m.\u001b[39mgenerate(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m   1191\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m   1192\u001b[0m     outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbase_model\u001b[38;5;241m.\u001b[39mgenerate(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\utils\\_contextlib.py:116\u001b[0m, in \u001b[0;36mcontext_decorator.<locals>.decorate_context\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    113\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[0;32m    114\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mdecorate_context\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m    115\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m ctx_factory():\n\u001b[1;32m--> 116\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m func(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\transformers\\generation\\utils.py:1622\u001b[0m, in \u001b[0;36mGenerationMixin.generate\u001b[1;34m(self, inputs, generation_config, logits_processor, stopping_criteria, prefix_allowed_tokens_fn, synced_gpus, assistant_model, streamer, negative_prompt_ids, negative_prompt_attention_mask, **kwargs)\u001b[0m\n\u001b[0;32m   1614\u001b[0m     input_ids, model_kwargs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_expand_inputs_for_generation(\n\u001b[0;32m   1615\u001b[0m         input_ids\u001b[38;5;241m=\u001b[39minput_ids,\n\u001b[0;32m   1616\u001b[0m         expand_size\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39mnum_return_sequences,\n\u001b[0;32m   1617\u001b[0m         is_encoder_decoder\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39mis_encoder_decoder,\n\u001b[0;32m   1618\u001b[0m         \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mmodel_kwargs,\n\u001b[0;32m   1619\u001b[0m     )\n\u001b[0;32m   1621\u001b[0m     \u001b[38;5;66;03m# 13. run sample\u001b[39;00m\n\u001b[1;32m-> 1622\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sample(\n\u001b[0;32m   1623\u001b[0m         input_ids,\n\u001b[0;32m   1624\u001b[0m         logits_processor\u001b[38;5;241m=\u001b[39mprepared_logits_processor,\n\u001b[0;32m   1625\u001b[0m         logits_warper\u001b[38;5;241m=\u001b[39mlogits_warper,\n\u001b[0;32m   1626\u001b[0m         stopping_criteria\u001b[38;5;241m=\u001b[39mprepared_stopping_criteria,\n\u001b[0;32m   1627\u001b[0m         pad_token_id\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39mpad_token_id,\n\u001b[0;32m   1628\u001b[0m         output_scores\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39moutput_scores,\n\u001b[0;32m   1629\u001b[0m         output_logits\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39moutput_logits,\n\u001b[0;32m   1630\u001b[0m         return_dict_in_generate\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39mreturn_dict_in_generate,\n\u001b[0;32m   1631\u001b[0m         synced_gpus\u001b[38;5;241m=\u001b[39msynced_gpus,\n\u001b[0;32m   1632\u001b[0m         streamer\u001b[38;5;241m=\u001b[39mstreamer,\n\u001b[0;32m   1633\u001b[0m         \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mmodel_kwargs,\n\u001b[0;32m   1634\u001b[0m     )\n\u001b[0;32m   1636\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m generation_mode \u001b[38;5;241m==\u001b[39m GenerationMode\u001b[38;5;241m.\u001b[39mBEAM_SEARCH:\n\u001b[0;32m   1637\u001b[0m     \u001b[38;5;66;03m# 11. prepare beam search scorer\u001b[39;00m\n\u001b[0;32m   1638\u001b[0m     beam_scorer \u001b[38;5;241m=\u001b[39m BeamSearchScorer(\n\u001b[0;32m   1639\u001b[0m         batch_size\u001b[38;5;241m=\u001b[39mbatch_size,\n\u001b[0;32m   1640\u001b[0m         num_beams\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39mnum_beams,\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   1645\u001b[0m         max_length\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39mmax_length,\n\u001b[0;32m   1646\u001b[0m     )\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\transformers\\generation\\utils.py:2791\u001b[0m, in \u001b[0;36mGenerationMixin._sample\u001b[1;34m(self, input_ids, logits_processor, stopping_criteria, logits_warper, max_length, pad_token_id, eos_token_id, output_attentions, output_hidden_states, output_scores, output_logits, return_dict_in_generate, synced_gpus, streamer, **model_kwargs)\u001b[0m\n\u001b[0;32m   2788\u001b[0m model_inputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprepare_inputs_for_generation(input_ids, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mmodel_kwargs)\n\u001b[0;32m   2790\u001b[0m \u001b[38;5;66;03m# forward pass to get next token\u001b[39;00m\n\u001b[1;32m-> 2791\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m(\n\u001b[0;32m   2792\u001b[0m     \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mmodel_inputs,\n\u001b[0;32m   2793\u001b[0m     return_dict\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[0;32m   2794\u001b[0m     output_attentions\u001b[38;5;241m=\u001b[39moutput_attentions,\n\u001b[0;32m   2795\u001b[0m     output_hidden_states\u001b[38;5;241m=\u001b[39moutput_hidden_states,\n\u001b[0;32m   2796\u001b[0m )\n\u001b[0;32m   2798\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m synced_gpus \u001b[38;5;129;01mand\u001b[39;00m this_peer_finished:\n\u001b[0;32m   2799\u001b[0m     \u001b[38;5;28;01mcontinue\u001b[39;00m  \u001b[38;5;66;03m# don't waste resources running the code we don't need\u001b[39;00m\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m forward_call(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\accelerate\\hooks.py:166\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[1;34m(module, *args, **kwargs)\u001b[0m\n\u001b[0;32m    164\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    165\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 166\u001b[0m     output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    167\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\transformers\\models\\phi\\modeling_phi.py:1169\u001b[0m, in \u001b[0;36mPhiForCausalLM.forward\u001b[1;34m(self, input_ids, attention_mask, position_ids, past_key_values, inputs_embeds, labels, use_cache, output_attentions, output_hidden_states, return_dict)\u001b[0m\n\u001b[0;32m   1166\u001b[0m return_dict \u001b[38;5;241m=\u001b[39m return_dict \u001b[38;5;28;01mif\u001b[39;00m return_dict \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39muse_return_dict\n\u001b[0;32m   1168\u001b[0m \u001b[38;5;66;03m# decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)\u001b[39;00m\n\u001b[1;32m-> 1169\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m   1170\u001b[0m \u001b[43m    \u001b[49m\u001b[43minput_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minput_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1171\u001b[0m \u001b[43m    \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1172\u001b[0m \u001b[43m    \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1173\u001b[0m \u001b[43m    \u001b[49m\u001b[43mpast_key_values\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_values\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1174\u001b[0m \u001b[43m    \u001b[49m\u001b[43minputs_embeds\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minputs_embeds\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1175\u001b[0m \u001b[43m    \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1176\u001b[0m \u001b[43m    \u001b[49m\u001b[43moutput_attentions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_attentions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1177\u001b[0m \u001b[43m    \u001b[49m\u001b[43moutput_hidden_states\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_hidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1178\u001b[0m \u001b[43m    \u001b[49m\u001b[43mreturn_dict\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreturn_dict\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1179\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1181\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m outputs[\u001b[38;5;241m0\u001b[39m]\n\u001b[0;32m   1182\u001b[0m logits \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlm_head(hidden_states)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m forward_call(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\accelerate\\hooks.py:166\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[1;34m(module, *args, **kwargs)\u001b[0m\n\u001b[0;32m    164\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    165\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 166\u001b[0m     output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    167\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\transformers\\models\\phi\\modeling_phi.py:1048\u001b[0m, in \u001b[0;36mPhiModel.forward\u001b[1;34m(self, input_ids, attention_mask, position_ids, past_key_values, inputs_embeds, use_cache, output_attentions, output_hidden_states, return_dict)\u001b[0m\n\u001b[0;32m   1039\u001b[0m     layer_outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_gradient_checkpointing_func(\n\u001b[0;32m   1040\u001b[0m         decoder_layer\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__call__\u001b[39m,\n\u001b[0;32m   1041\u001b[0m         hidden_states,\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   1045\u001b[0m         output_attentions,\n\u001b[0;32m   1046\u001b[0m     )\n\u001b[0;32m   1047\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1048\u001b[0m     layer_outputs \u001b[38;5;241m=\u001b[39m \u001b[43mdecoder_layer\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m   1049\u001b[0m \u001b[43m        \u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1050\u001b[0m \u001b[43m        \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1051\u001b[0m \u001b[43m        \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1052\u001b[0m \u001b[43m        \u001b[49m\u001b[43mpast_key_value\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_values\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1053\u001b[0m \u001b[43m        \u001b[49m\u001b[43moutput_attentions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_attentions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1054\u001b[0m \u001b[43m        \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1055\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1057\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m layer_outputs[\u001b[38;5;241m0\u001b[39m]\n\u001b[0;32m   1059\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m use_cache:\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m forward_call(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\accelerate\\hooks.py:166\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[1;34m(module, *args, **kwargs)\u001b[0m\n\u001b[0;32m    164\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    165\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 166\u001b[0m     output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    167\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\transformers\\models\\phi\\modeling_phi.py:779\u001b[0m, in \u001b[0;36mPhiDecoderLayer.forward\u001b[1;34m(self, hidden_states, attention_mask, position_ids, output_attentions, use_cache, past_key_value)\u001b[0m\n\u001b[0;32m    776\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minput_layernorm(hidden_states)\n\u001b[0;32m    778\u001b[0m \u001b[38;5;66;03m# Self Attention\u001b[39;00m\n\u001b[1;32m--> 779\u001b[0m attn_outputs, self_attn_weights, present_key_value \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mself_attn\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m    780\u001b[0m \u001b[43m    \u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    781\u001b[0m \u001b[43m    \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    782\u001b[0m \u001b[43m    \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    783\u001b[0m \u001b[43m    \u001b[49m\u001b[43mpast_key_value\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_value\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    784\u001b[0m \u001b[43m    \u001b[49m\u001b[43moutput_attentions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_attentions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    785\u001b[0m \u001b[43m    \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    786\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    787\u001b[0m attn_outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mresid_dropout(attn_outputs)\n\u001b[0;32m    789\u001b[0m feed_forward_hidden_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mresid_dropout(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmlp(hidden_states))\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m forward_call(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\accelerate\\hooks.py:166\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[1;34m(module, *args, **kwargs)\u001b[0m\n\u001b[0;32m    164\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    165\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 166\u001b[0m     output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    167\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\transformers\\models\\phi\\modeling_phi.py:663\u001b[0m, in \u001b[0;36mPhiSdpaAttention.forward\u001b[1;34m(self, hidden_states, attention_mask, position_ids, past_key_value, output_attentions, use_cache)\u001b[0m\n\u001b[0;32m    661\u001b[0m query_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mq_proj(hidden_states)\n\u001b[0;32m    662\u001b[0m key_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mk_proj(hidden_states)\n\u001b[1;32m--> 663\u001b[0m value_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mv_proj\u001b[49m\u001b[43m(\u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    665\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mqk_layernorm:\n\u001b[0;32m    666\u001b[0m     query_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mq_layernorm(query_states)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\torch\\nn\\modules\\module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m forward_call(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[1;32mR:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\peft\\tuners\\lora\\bnb.py:478\u001b[0m, in \u001b[0;36mLinear4bit.forward\u001b[1;34m(self, x, *args, **kwargs)\u001b[0m\n\u001b[0;32m    476\u001b[0m             output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_apply_dora(x, lora_A, lora_B, scaling, active_adapter)\n\u001b[0;32m    477\u001b[0m         \u001b[38;5;28;01mif\u001b[39;00m requires_conversion:\n\u001b[1;32m--> 478\u001b[0m             output \u001b[38;5;241m=\u001b[39m \u001b[43moutput\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mexpected_dtype\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    480\u001b[0m         result \u001b[38;5;241m=\u001b[39m result \u001b[38;5;241m+\u001b[39m output\n\u001b[0;32m    482\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m result\n",
+      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
+     ]
+    }
+   ],
+   "source": [
+    "# ── Test your model interactively ─────────────────────────────────────────────\n",
+    "\n",
+    "test_prompt = \"Act as a career coach. Write a 150-word LinkedIn summary for a data scientist transitioning to product management. Highlight analytical skills, avoid jargon, end with a call-to-action.\"\n",
+    "test_domain = \"CAREER\"   # Change to: EDUCATION, HEALTHCARE, LEGAL, TECHNOLOGY, MARKETING, FINANCE, CREATIVE\n",
+    "\n",
+    "# ── Run inference\n",
+    "raw_output, scores = grade_prompt(test_prompt, test_domain, model, tokenizer)\n",
+    "\n",
+    "# ── Display results\n",
+    "print(\"=\" * 55)\n",
+    "print(f\"  PELS EVALUATION REPORT\")\n",
+    "print(f\"  Domain : {test_domain}\")\n",
+    "print(f\"  Prompt : {test_prompt[:80]}...\")\n",
+    "print(\"=\" * 55)\n",
+    "\n",
+    "labels = {\n",
+    "    'c1': 'C1  Foundations     (15%)',\n",
+    "    'c2': 'C2  Design          (20%)',\n",
+    "    'c3': 'C3  Output Spec     (20%)',\n",
+    "    'c4': 'C4  Domain          (20%)',\n",
+    "    'c5': 'C5  Ethics          (15%)',\n",
+    "    'c6': 'C6  Metacognition   (10%)',\n",
+    "}\n",
+    "\n",
+    "for key, label in labels.items():\n",
+    "    val = scores.get(key)\n",
+    "    if val is not None:\n",
+    "        bar = '█' * int(val) + '░' * (10 - int(val))\n",
+    "        print(f\"  {label} : {val:4.1f}  [{bar}]\")\n",
+    "    else:\n",
+    "        print(f\"  {label} : — (not parsed)\")\n",
+    "\n",
+    "print(\"-\" * 55)\n",
+    "final = scores.get('final')\n",
+    "if final:\n",
+    "    tier = '🟢 Strong' if final*10 >= 71 else ('🟡 Developing' if final*10 >= 41 else '🔴 Weak')\n",
+    "    print(f\"  FINAL SCORE : {final:.2f} / 10   {tier}\")\n",
+    "print(\"=\" * 55)\n",
+    "\n",
+    "# Justification\n",
+    "import re\n",
+    "just = re.search(r'Justification:\\s*(.+)', raw_output, re.DOTALL)\n",
+    "if just:\n",
+    "    print(f\"\\n  JUSTIFICATION:\\n  {just.group(1).strip()[:500]}\")\n",
+    "else:\n",
+    "    print(f\"\\n  RAW OUTPUT:\\n{raw_output[:500]}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install gradio -q"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading base model...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "R:\\anaconda3\\envs\\softcomp\\lib\\site-packages\\huggingface_hub\\file_download.py:949: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n",
+      "  warnings.warn(\n",
+      "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7cfa787dc9554604866172970b5e0153",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading your trained LoRA adapter...\n",
+      "✅ Model ready!\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig\n",
+    "from peft import PeftModel\n",
+    "\n",
+    "MODEL_ID   = \"microsoft/phi-2\"\n",
+    "OUTPUT_DIR = \"./pels_phi2_qlora\"\n",
+    "\n",
+    "# 4-bit config (same as training)\n",
+    "bnb_config = BitsAndBytesConfig(\n",
+    "    load_in_4bit=True,\n",
+    "    bnb_4bit_quant_type=\"nf4\",\n",
+    "    bnb_4bit_compute_dtype=torch.float16,\n",
+    "    bnb_4bit_use_double_quant=True,\n",
+    ")\n",
+    "\n",
+    "print(\"Loading base model...\")\n",
+    "tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True)\n",
+    "tokenizer.pad_token = tokenizer.eos_token\n",
+    "\n",
+    "base_model = AutoModelForCausalLM.from_pretrained(\n",
+    "    MODEL_ID,\n",
+    "    quantization_config=bnb_config,\n",
+    "    device_map=\"auto\",\n",
+    "    trust_remote_code=True,\n",
+    "    torch_dtype=torch.float16,\n",
+    ")\n",
+    "\n",
+    "print(\"Loading your trained LoRA adapter...\")\n",
+    "model = PeftModel.from_pretrained(base_model, OUTPUT_DIR)\n",
+    "model.eval()\n",
+    "\n",
+    "print(\"✅ Model ready!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\RISHI\\AppData\\Local\\Temp\\ipykernel_5812\\1422344413.py:385: UserWarning: The parameters have been moved from the Blocks constructor to the launch() method in Gradio 6.0: theme. Please pass these parameters to launch() instead.\n",
+      "  with gr.Blocks(title=\"PELS Prompt Assessment\", theme=gr.themes.Base()) as demo:\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "* Running on local URL:  http://127.0.0.1:7860\n",
+      "* Running on public URL: https://7bb39d809ffceea952.gradio.live\n",
+      "\n",
+      "This share link expires in 1 week. For free permanent hosting and GPU upgrades, run `gradio deploy` from the terminal in the working directory to deploy to Hugging Face Spaces (https://huggingface.co/spaces)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"https://7bb39d809ffceea952.gradio.live\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# ── Cell: PELS Gradio App (Scenario-Based) ────────────────────────────────────\n",
+    "\n",
+    "!pip install gradio -q\n",
+    "\n",
+    "import gradio as gr\n",
+    "import torch\n",
+    "import re\n",
+    "import random\n",
+    "\n",
+    "model.eval()\n",
+    "torch.cuda.empty_cache()\n",
+    "\n",
+    "RUBRIC = \"\"\"C1 Foundations (15%): Task clarity, role setup, AI awareness.\n",
+    "C2 Design (20%): Prompt structure, patterns (few-shot, CoT, role+task+constraint).\n",
+    "C3 Output Spec (20%): Format, length, tone, structure constraints.\n",
+    "C4 Domain Application (20%): Domain vocabulary, contextual accuracy.\n",
+    "C5 Ethics (15%): No harmful/biased framing. Score=1 triggers automatic Final Score override to 1.0.\n",
+    "C6 Metacognition (10%): Self-awareness, iteration design, fallback handling.\"\"\"\n",
+    "\n",
+    "MAX_LENGTH     = 512\n",
+    "MAX_NEW_TOKENS = 150\n",
+    "\n",
+    "# ── Scenario bank ─────────────────────────────────────────────────────────────\n",
+    "# Each scenario has:\n",
+    "#   \"scenario\" — the situation shown to the user\n",
+    "#   \"task\"     — what they are asked to do (no hints on HOW to prompt)\n",
+    "# The user must figure out how to write the prompt themselves.\n",
+    "\n",
+    "SCENARIOS = {\n",
+    "    \"CAREER\": [\n",
+    "        {\n",
+    "            \"scenario\": \"Rohan is a mechanical engineer with 5 years of experience who wants to switch into data science. He has done one online Python course but has no real projects yet. He has an interview at a data analytics firm next month.\",\n",
+    "            \"task\": \"Write an AI prompt that helps Rohan prepare for this career transition.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"Priya has been a school teacher for 8 years and wants to move into corporate L&D (Learning & Development). She has no corporate experience but has designed curriculum and trained 200+ students.\",\n",
+    "            \"task\": \"Write an AI prompt that helps Priya position herself for an L&D role.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"Amir graduated 6 months ago with a BCA degree and has been applying for software developer roles but getting no callbacks. His resume lists his college projects but no internships.\",\n",
+    "            \"task\": \"Write an AI prompt that helps Amir fix the problem and get more callbacks.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"Sneha is a marketing manager at a mid-size company. She wants to ask for a promotion to Director but has never negotiated salary or title before and doesn't know how to make the case.\",\n",
+    "            \"task\": \"Write an AI prompt that helps Sneha prepare for this conversation with her manager.\",\n",
+    "        },\n",
+    "    ],\n",
+    "    \"EDUCATION\": [\n",
+    "        {\n",
+    "            \"scenario\": \"A Grade 9 teacher needs to explain the concept of compound interest to students who understand basic multiplication and percentages but have never studied finance or banking.\",\n",
+    "            \"task\": \"Write an AI prompt that produces a teaching resource for this class.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A university professor wants to check whether her 2nd-year engineering students have understood Newton's Laws of Motion — specifically common misconceptions students have about inertia.\",\n",
+    "            \"task\": \"Write an AI prompt that generates an assessment to test this understanding.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A homeschooling parent needs to teach their 10-year-old child about climate change in a way that is factually accurate but not scary or overwhelming, using everyday examples.\",\n",
+    "            \"task\": \"Write an AI prompt that creates an age-appropriate lesson on this topic.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A coding bootcamp instructor wants to introduce recursion to students who are comfortable with loops (for/while) but have never seen a function call itself.\",\n",
+    "            \"task\": \"Write an AI prompt that creates a beginner-friendly explanation with an exercise.\",\n",
+    "        },\n",
+    "    ],\n",
+    "    \"TECHNOLOGY\": [\n",
+    "        {\n",
+    "            \"scenario\": \"A junior developer at a startup wrote a Python script that reads a CSV file and calculates monthly sales totals — but it crashes whenever a cell is empty or contains text instead of a number.\",\n",
+    "            \"task\": \"Write an AI prompt that helps fix and improve this script.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A non-technical product manager needs to explain to her team why their app is slow. The engineering team says it is a 'database N+1 query problem' but she doesn't understand what that means.\",\n",
+    "            \"task\": \"Write an AI prompt that produces an explanation she can actually understand and relay to stakeholders.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A small business owner wants to build a simple website contact form that stores submissions in a Google Sheet — they have no coding experience and a budget of zero.\",\n",
+    "            \"task\": \"Write an AI prompt that gives them a practical, step-by-step solution.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A data analyst has a pandas DataFrame with 500,000 rows. Her current code takes 4 minutes to run a groupby aggregation. Her manager wants results in under 30 seconds.\",\n",
+    "            \"task\": \"Write an AI prompt that helps her optimise the code.\",\n",
+    "        },\n",
+    "    ],\n",
+    "    \"HEALTHCARE\": [\n",
+    "        {\n",
+    "            \"scenario\": \"A 45-year-old patient was just diagnosed with pre-diabetes. Their doctor told them to 'watch their diet and exercise more' but gave no specific guidance. The patient is confused about what to actually do.\",\n",
+    "            \"task\": \"Write an AI prompt that produces practical, safe guidance for this patient.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A nurse manager at a clinic needs to train new staff on the correct procedure for hand hygiene according to WHO guidelines — in a way that is quick to read and easy to remember during a busy shift.\",\n",
+    "            \"task\": \"Write an AI prompt that creates this training material.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A medical student is struggling to remember the differences between Type 1 and Type 2 Diabetes — the symptoms, causes, treatment approaches, and which patient populations are typically affected.\",\n",
+    "            \"task\": \"Write an AI prompt that creates a study aid for this topic.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A hospital wants to send a clear, non-alarming message to patients reminding them to get their annual flu vaccination — the message will go out via SMS so it must be very short.\",\n",
+    "            \"task\": \"Write an AI prompt that generates this patient communication.\",\n",
+    "        },\n",
+    "    ],\n",
+    "    \"LEGAL\": [\n",
+    "        {\n",
+    "            \"scenario\": \"A freelance graphic designer in Pune completed a logo project for a client who is now refusing to pay the ₹25,000 invoice, claiming the work was 'not what was agreed'. There was a WhatsApp conversation but no formal contract.\",\n",
+    "            \"task\": \"Write an AI prompt that helps the designer understand their options and next steps.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A first-time landlord in Bangalore wants to rent out their apartment. They have heard that verbal agreements can cause problems and want to create a proper rental agreement that protects them legally.\",\n",
+    "            \"task\": \"Write an AI prompt that helps them draft or understand what should be in this agreement.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"An employee received a termination letter from their company citing 'performance issues' but believes they were fired because they filed a complaint against their manager last month.\",\n",
+    "            \"task\": \"Write an AI prompt that helps this person understand whether they have a case and what to do.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A startup founder is about to sign a 3-year office lease. They have never signed a commercial lease before and are worried about clauses that could trap them if the startup fails in year one.\",\n",
+    "            \"task\": \"Write an AI prompt that helps them know what to watch out for in this agreement.\",\n",
+    "        },\n",
+    "    ],\n",
+    "    \"MARKETING\": [\n",
+    "        {\n",
+    "            \"scenario\": \"A local bakery in Hyderabad has great reviews but almost no online presence. They want to attract customers aged 20–35 who discover food businesses on Instagram. Their budget is zero — only organic content.\",\n",
+    "            \"task\": \"Write an AI prompt that helps them create a content strategy or specific post.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"An edtech startup is launching a new course on AI for non-technical professionals. They need to send a launch email to their existing subscriber list of 5,000 people — most of whom haven't opened emails in 3 months.\",\n",
+    "            \"task\": \"Write an AI prompt that produces this re-engagement launch email.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A fitness trainer wants to run Google Ads for their personal training services in Mumbai. They have a ₹10,000/month budget and have never run paid ads before. Their USP is online coaching with personalised meal plans.\",\n",
+    "            \"task\": \"Write an AI prompt that helps them set up or plan this campaign effectively.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A sustainable clothing brand is launching a new line made from recycled ocean plastic. Their target customer cares about the environment but is price-sensitive (products are 30% more expensive than fast fashion).\",\n",
+    "            \"task\": \"Write an AI prompt that creates compelling product description copy for their website.\",\n",
+    "        },\n",
+    "    ],\n",
+    "    \"FINANCE\": [\n",
+    "        {\n",
+    "            \"scenario\": \"A 28-year-old software developer earns ₹1.2 lakh per month but saves almost nothing. They have ₹3 lakh in credit card debt at 36% annual interest and no investments. They want to start getting their finances in order.\",\n",
+    "            \"task\": \"Write an AI prompt that produces a practical financial plan for this person.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A small business owner wants to understand their company's cash flow statement. Their accountant gave them a document but they don't understand why the business is profitable on paper but always short on cash.\",\n",
+    "            \"task\": \"Write an AI prompt that explains this concept in a way they can immediately apply to their situation.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A couple wants to save for their child's higher education. The child is currently 3 years old and they estimate they'll need ₹30 lakhs in 15 years. They can invest ₹10,000 per month.\",\n",
+    "            \"task\": \"Write an AI prompt that helps them understand their investment options and whether their goal is achievable.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A salaried employee received their first Form 16 and has to file their ITR for the first time. They are confused about which ITR form to use, what deductions they can claim under 80C, and how to avoid mistakes.\",\n",
+    "            \"task\": \"Write an AI prompt that guides them through this process.\",\n",
+    "        },\n",
+    "    ],\n",
+    "    \"CREATIVE\": [\n",
+    "        {\n",
+    "            \"scenario\": \"A screenwriter wants to write a 5-minute short film about loneliness in a big city. The protagonist is a 30-year-old delivery driver who interacts with dozens of people every day but has no real relationships.\",\n",
+    "            \"task\": \"Write an AI prompt that helps develop this concept into a concrete scene or script outline.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A startup founder needs to write the 'About Us' page for their company website. The company builds AI tools for teachers. The tone should feel human and mission-driven, not corporate or salesy.\",\n",
+    "            \"task\": \"Write an AI prompt that produces this About Us page.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A children's book author wants to write a short story for 6–8 year olds that teaches them about the importance of asking for help — without being preachy. The story should have an animal character.\",\n",
+    "            \"task\": \"Write an AI prompt that generates this story or a strong outline for it.\",\n",
+    "        },\n",
+    "        {\n",
+    "            \"scenario\": \"A musician wants to write lyrics for an indie-folk song about their grandmother who passed away last year. The mood should be bittersweet — celebrating her life rather than mourning — with imagery from her kitchen and garden.\",\n",
+    "            \"task\": \"Write an AI prompt that helps generate these lyrics or a draft verse.\",\n",
+    "        },\n",
+    "    ],\n",
+    "}\n",
+    "\n",
+    "# ── Core functions ────────────────────────────────────────────────────────────\n",
+    "def get_scenario(domain):\n",
+    "    if not domain:\n",
+    "        return \"\", \"\"\n",
+    "    scenarios = SCENARIOS.get(domain, [])\n",
+    "    if not scenarios:\n",
+    "        return \"\", \"\"\n",
+    "    picked = random.choice(scenarios)\n",
+    "    scenario_html = f\"\"\"\n",
+    "    <div style=\"background:#0f172a;border-radius:10px;padding:20px 22px;\n",
+    "                border-left:4px solid #6366f1;font-family:sans-serif\">\n",
+    "      <div style=\"color:#a5b4fc;font-size:11px;font-weight:700;\n",
+    "                  letter-spacing:.1em;margin-bottom:10px\">\n",
+    "        📋 YOUR SCENARIO\n",
+    "      </div>\n",
+    "      <div style=\"color:#e2e8f0;font-size:15px;line-height:1.75;margin-bottom:16px\">\n",
+    "        {picked['scenario']}\n",
+    "      </div>\n",
+    "      <div style=\"background:#1e293b;border-radius:8px;padding:12px 16px\">\n",
+    "        <span style=\"color:#fbbf24;font-weight:700;font-size:13px\">🎯 Your Task: </span>\n",
+    "        <span style=\"color:#fde68a;font-size:14px\">{picked['task']}</span>\n",
+    "      </div>\n",
+    "      <div style=\"margin-top:14px;color:#475569;font-size:12px;font-style:italic\">\n",
+    "        💡 Tip: A strong prompt assigns a role to the AI, specifies the audience,\n",
+    "        defines the output format, and sets constraints. You figure out how — that's the assessment.\n",
+    "      </div>\n",
+    "    </div>\"\"\"\n",
+    "    return scenario_html, picked[\"scenario\"] + \" | Task: \" + picked[\"task\"]\n",
+    "\n",
+    "def get_tier(score):\n",
+    "    \"\"\"score is always 0–10\"\"\"\n",
+    "    if score >= 7.1:   return \"🟢 Strong\",    \"#22c55e\"\n",
+    "    elif score >= 4.1: return \"🟡 Developing\", \"#f59e0b\"\n",
+    "    else:              return \"🔴 Weak\",       \"#ef4444\"\n",
+    "\n",
+    "def extract_scores(text):\n",
+    "    patterns = {\n",
+    "        'c1':    r'C1_Foundations:\\s*([0-9.]+)',\n",
+    "        'c2':    r'C2_Design:\\s*([0-9.]+)',\n",
+    "        'c3':    r'C3_OutputSpec:\\s*([0-9.]+)',\n",
+    "        'c4':    r'C4_Domain:\\s*([0-9.]+)',\n",
+    "        'c5':    r'C5_Ethics:\\s*([0-9.]+)',\n",
+    "        'c6':    r'C6_Metacognition:\\s*([0-9.]+)',\n",
+    "        'final': r'Final_Score:\\s*([0-9.]+)',\n",
+    "    }\n",
+    "    return {k: float(m.group(1)) if (m := re.search(p, text)) else None\n",
+    "            for k, p in patterns.items()}\n",
+    "\n",
+    "def grade_prompt_fast(prompt_text, domain):\n",
+    "    input_text = (\n",
+    "        f\"Instruct: ### PELS Grading Task\\n\"\n",
+    "        f\"Domain: {domain}\\n\"\n",
+    "        f\"Rubric:\\n{RUBRIC}\\n\\n\"\n",
+    "        f\"Candidate Prompt:\\n{prompt_text}\\n\\n\"\n",
+    "        f\"### Evaluation\\n\"\n",
+    "        f\"Score each category 1–10. Ethics score of 1 overrides all others.\\n\"\n",
+    "        f\"Output:\"\n",
+    "    )\n",
+    "    inputs = tokenizer(\n",
+    "        input_text, return_tensors='pt',\n",
+    "        truncation=True, max_length=MAX_LENGTH\n",
+    "    ).to(model.device)\n",
+    "\n",
+    "    with torch.no_grad():\n",
+    "        outputs = model.generate(\n",
+    "            **inputs,\n",
+    "            max_new_tokens=MAX_NEW_TOKENS,\n",
+    "            do_sample=False,\n",
+    "            pad_token_id=tokenizer.eos_token_id,\n",
+    "        )\n",
+    "    decoded  = tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
+    "    out_part = decoded[len(input_text):] if input_text in decoded else decoded\n",
+    "    return out_part, extract_scores(out_part)\n",
+    "\n",
+    "def build_score_html(scores, veto, raw_output):\n",
+    "    final = scores.get(\"final\") or 0.0\n",
+    "    final_display = final if final > 1.0 else final * 10\n",
+    "    bar_pct       = min(int(final_display * 10), 100)\n",
+    "    t_label, color = get_tier(final_display)\n",
+    "\n",
+    "    cat_info = [\n",
+    "        (\"c1\", \"C1 · Foundations\",        \"15%\"),\n",
+    "        (\"c2\", \"C2 · Design\",             \"20%\"),\n",
+    "        (\"c3\", \"C3 · Output Spec\",        \"20%\"),\n",
+    "        (\"c4\", \"C4 · Domain Application\", \"20%\"),\n",
+    "        (\"c5\", \"C5 · Ethics\",             \"15%\"),\n",
+    "        (\"c6\", \"C6 · Metacognition\",      \"10%\"),\n",
+    "    ]\n",
+    "\n",
+    "    rows = \"\"\n",
+    "    for key, label, weight in cat_info:\n",
+    "        val = scores.get(key)\n",
+    "        if val is None:\n",
+    "            rows += f\"\"\"<tr>\n",
+    "              <td style=\"padding:8px 12px;color:#94a3b8;font-family:sans-serif;\n",
+    "                         white-space:nowrap\">{label} <span style=\"color:#334155\">({weight})</span></td>\n",
+    "              <td colspan=\"2\" style=\"color:#475569;padding:8px 12px\">—</td>\n",
+    "            </tr>\"\"\"\n",
+    "            continue\n",
+    "        val_d = val if val > 1.0 else val * 10\n",
+    "        _, c  = get_tier(val_d)\n",
+    "        pct   = min(int(val_d * 10), 100)\n",
+    "        rows += f\"\"\"<tr>\n",
+    "          <td style=\"padding:8px 12px;font-weight:600;color:#cbd5e1;\n",
+    "                     white-space:nowrap;font-family:sans-serif\">\n",
+    "            {label} <span style=\"color:#475569;font-weight:400\">({weight})</span>\n",
+    "          </td>\n",
+    "          <td style=\"padding:8px 12px;width:100%\">\n",
+    "            <div style=\"background:#1e293b;border-radius:4px;height:13px;overflow:hidden\">\n",
+    "              <div style=\"background:{c};width:{pct}%;height:100%;border-radius:4px\"></div>\n",
+    "            </div>\n",
+    "          </td>\n",
+    "          <td style=\"padding:8px 12px;font-weight:700;color:{c};\n",
+    "                     white-space:nowrap;font-family:sans-serif\">{val_d:.1f}/10</td>\n",
+    "        </tr>\"\"\"\n",
+    "\n",
+    "    veto_banner = \"\"\n",
+    "    if veto:\n",
+    "        veto_banner = \"\"\"<div style=\"background:#7f1d1d;border:1px solid #dc2626;\n",
+    "                    border-radius:8px;padding:10px 16px;margin-bottom:16px;\n",
+    "                    color:#fca5a5;font-weight:600;font-family:sans-serif\">\n",
+    "          ⛔ Ethics Veto Triggered — Final Score overridden to 1.0\n",
+    "        </div>\"\"\"\n",
+    "\n",
+    "    just_match    = re.search(r'Justification:\\s*(.+)', raw_output, re.DOTALL)\n",
+    "    justification = just_match.group(1).strip()[:500] if just_match else \"\"\n",
+    "    just_html = \"\"\n",
+    "    if justification:\n",
+    "        just_html = f\"\"\"\n",
+    "        <div style=\"margin-top:20px;padding:14px 16px;background:#0f172a;\n",
+    "                    border-left:3px solid #6366f1;border-radius:0 8px 8px 0\">\n",
+    "          <div style=\"color:#a5b4fc;font-size:11px;font-weight:700;\n",
+    "                      letter-spacing:.08em;margin-bottom:8px;font-family:sans-serif\">\n",
+    "            JUSTIFICATION\n",
+    "          </div>\n",
+    "          <div style=\"color:#cbd5e1;line-height:1.7;font-size:14px;font-family:sans-serif\">\n",
+    "            {justification}\n",
+    "          </div>\n",
+    "        </div>\"\"\"\n",
+    "\n",
+    "    return f\"\"\"\n",
+    "    <div style=\"font-family:sans-serif;background:#0f172a;border-radius:12px;\n",
+    "                padding:24px;color:#e2e8f0\">\n",
+    "      {veto_banner}\n",
+    "      <div style=\"display:flex;align-items:center;gap:24px;margin-bottom:24px\">\n",
+    "        <div style=\"text-align:center;min-width:90px\">\n",
+    "          <div style=\"font-size:54px;font-weight:800;color:{color};line-height:1\">\n",
+    "            {final_display:.1f}\n",
+    "          </div>\n",
+    "          <div style=\"font-size:12px;color:#64748b;margin-top:4px\">out of 10</div>\n",
+    "        </div>\n",
+    "        <div style=\"flex:1\">\n",
+    "          <div style=\"background:#1e293b;border-radius:8px;height:20px;overflow:hidden\">\n",
+    "            <div style=\"background:{color};width:{bar_pct}%;height:100%;border-radius:8px\">\n",
+    "            </div>\n",
+    "          </div>\n",
+    "          <div style=\"margin-top:10px;font-size:17px;font-weight:700;color:{color}\">\n",
+    "            {t_label}\n",
+    "          </div>\n",
+    "          <div style=\"font-size:12px;color:#475569;margin-top:3px\">PELS Final Score</div>\n",
+    "        </div>\n",
+    "      </div>\n",
+    "      <table style=\"width:100%;border-collapse:collapse;font-size:14px\">{rows}</table>\n",
+    "      {just_html}\n",
+    "    </div>\"\"\"\n",
+    "\n",
+    "# ── Handlers ──────────────────────────────────────────────────────────────────\n",
+    "def on_domain_change(domain):\n",
+    "    html, context = get_scenario(domain)\n",
+    "    return html, context, \"\", PLACEHOLDER\n",
+    "\n",
+    "def on_new_scenario(domain):\n",
+    "    html, context = get_scenario(domain)\n",
+    "    return html, context, \"\", PLACEHOLDER\n",
+    "\n",
+    "def evaluate(domain, user_prompt, scenario_context):\n",
+    "    if not domain:\n",
+    "        return \"<p style='color:#f87171;font-family:sans-serif'>⚠️ Please select a domain first.</p>\"\n",
+    "    if not user_prompt or len(user_prompt.strip()) < 10:\n",
+    "        return \"<p style='color:#f87171;font-family:sans-serif'>⚠️ Please write your prompt (at least 10 characters).</p>\"\n",
+    "    try:\n",
+    "        raw, scores = grade_prompt_fast(user_prompt.strip(), domain)\n",
+    "    except Exception as e:\n",
+    "        return f\"<p style='color:#f87171;font-family:sans-serif'>❌ Error: {e}</p>\"\n",
+    "\n",
+    "    if not scores or all(v is None for v in scores.values()):\n",
+    "        return f\"\"\"<div style='padding:16px;background:#1e293b;border-radius:8px;\n",
+    "                    color:#cbd5e1;font-family:sans-serif'>\n",
+    "          <b>Raw model output:</b><br>\n",
+    "          <pre style='white-space:pre-wrap;font-size:12px;color:#94a3b8'>{raw[:600]}</pre>\n",
+    "          <small style='color:#64748b'>Scores not parsed. Try a more detailed prompt.</small>\n",
+    "        </div>\"\"\"\n",
+    "\n",
+    "    veto = (scores.get(\"c5\") or 10) <= 1.0\n",
+    "    if veto:\n",
+    "        scores[\"final\"] = 1.0\n",
+    "\n",
+    "    return build_score_html(scores, veto, raw)\n",
+    "\n",
+    "def clear_all():\n",
+    "    return None, \"\", \"\", PLACEHOLDER\n",
+    "\n",
+    "PLACEHOLDER = \"\"\"\n",
+    "<div style='background:#0f172a;border-radius:12px;padding:40px;\n",
+    "            text-align:center;color:#334155;font-family:sans-serif;font-size:15px'>\n",
+    "  Your PELS score report will appear here after evaluation.\n",
+    "</div>\"\"\"\n",
+    "\n",
+    "# ── UI ────────────────────────────────────────────────────────────────────────\n",
+    "with gr.Blocks(title=\"PELS Prompt Assessment\", theme=gr.themes.Base()) as demo:\n",
+    "\n",
+    "    scenario_context = gr.State(\"\")   # hidden state stores scenario text\n",
+    "\n",
+    "    gr.HTML(\"\"\"\n",
+    "    <div style=\"padding:24px 0 12px\">\n",
+    "      <h1 style=\"font-family:sans-serif;font-size:2rem;font-weight:800;margin:0;\n",
+    "                 background:linear-gradient(135deg,#6366f1,#a855f7,#ec4899);\n",
+    "                 -webkit-background-clip:text;-webkit-text-fill-color:transparent\">\n",
+    "        PELS Prompt Assessment\n",
+    "      </h1>\n",
+    "      <p style=\"font-family:sans-serif;color:#64748b;margin:6px 0 0;font-size:14px\">\n",
+    "        You will receive a real-world scenario. Write an AI prompt to address it.\n",
+    "        Your prompt will be evaluated across 6 rubric categories.\n",
+    "      </p>\n",
+    "    </div>\"\"\")\n",
+    "\n",
+    "    with gr.Row():\n",
+    "\n",
+    "        # ── Left ──────────────────────────────────────────────────────────────\n",
+    "        with gr.Column(scale=1):\n",
+    "\n",
+    "            gr.HTML('<div style=\"font-family:sans-serif;font-weight:700;'\n",
+    "                    'color:#a5b4fc;font-size:12px;letter-spacing:.08em;'\n",
+    "                    'margin-bottom:6px\">STEP 1 · CHOOSE DOMAIN</div>')\n",
+    "\n",
+    "            domain_dd = gr.Dropdown(\n",
+    "                choices=list(SCENARIOS.keys()),\n",
+    "                label=\"Domain\", value=None, interactive=True,\n",
+    "            )\n",
+    "\n",
+    "            gr.HTML('<div style=\"font-family:sans-serif;font-weight:700;'\n",
+    "                    'color:#a5b4fc;font-size:12px;letter-spacing:.08em;'\n",
+    "                    'margin:18px 0 6px\">STEP 2 · YOUR SCENARIO</div>')\n",
+    "\n",
+    "            scenario_display = gr.HTML(\n",
+    "                value=\"\"\"<div style='background:#0f172a;border-radius:10px;\n",
+    "                          padding:20px;text-align:center;color:#334155;\n",
+    "                          font-family:sans-serif'>\n",
+    "                  Select a domain above to receive your scenario.\n",
+    "                </div>\"\"\"\n",
+    "            )\n",
+    "\n",
+    "            new_scenario_btn = gr.Button(\n",
+    "                \"🔀 Get Different Scenario\", variant=\"secondary\", size=\"sm\"\n",
+    "            )\n",
+    "\n",
+    "            gr.HTML('<div style=\"font-family:sans-serif;font-weight:700;'\n",
+    "                    'color:#a5b4fc;font-size:12px;letter-spacing:.08em;'\n",
+    "                    'margin:18px 0 6px\">STEP 3 · WRITE YOUR PROMPT</div>')\n",
+    "\n",
+    "            prompt_box = gr.Textbox(\n",
+    "                label=\"Your AI Prompt\",\n",
+    "                placeholder=\"Based on the scenario above, write your AI prompt here…\",\n",
+    "                lines=9,\n",
+    "            )\n",
+    "\n",
+    "            with gr.Row():\n",
+    "                clear_btn = gr.Button(\"🗑 Clear\",    variant=\"secondary\", size=\"sm\")\n",
+    "                eval_btn  = gr.Button(\"⚡ Evaluate\", variant=\"primary\",   size=\"lg\")\n",
+    "\n",
+    "            gr.HTML(\"\"\"\n",
+    "            <div style=\"margin-top:14px;padding:12px 14px;background:#1e293b;\n",
+    "                        border-radius:8px;font-size:12px;color:#64748b;\n",
+    "                        font-family:sans-serif;line-height:1.8\">\n",
+    "              <b style=\"color:#94a3b8\">Rubric weights:</b><br>\n",
+    "              C1 Foundations 15% · C2 Design 20% · C3 Output Spec 20%<br>\n",
+    "              C4 Domain 20% · C5 Ethics 15% · C6 Metacognition 10%<br><br>\n",
+    "              <b style=\"color:#94a3b8\">Tiers:</b>\n",
+    "              &nbsp;🟢 Strong ≥ 7.1\n",
+    "              &nbsp;·&nbsp;🟡 Developing 4.1–7.0\n",
+    "              &nbsp;·&nbsp;🔴 Weak ≤ 4.0\n",
+    "            </div>\"\"\")\n",
+    "\n",
+    "        # ── Right ─────────────────────────────────────────────────────────────\n",
+    "        with gr.Column(scale=1):\n",
+    "\n",
+    "            gr.HTML('<div style=\"font-family:sans-serif;font-weight:700;'\n",
+    "                    'color:#a5b4fc;font-size:12px;letter-spacing:.08em;'\n",
+    "                    'margin-bottom:6px\">STEP 4 · PELS SCORE REPORT</div>')\n",
+    "\n",
+    "            result_html = gr.HTML(value=PLACEHOLDER)\n",
+    "\n",
+    "    with gr.Accordion(\"📖 Rubric Reference\", open=False):\n",
+    "        gr.Markdown(\"\"\"\n",
+    "| Category | Weight | What it checks |\n",
+    "|---|---|---|\n",
+    "| C1 Foundations | 15% | Task clarity, role setup, AI awareness |\n",
+    "| C2 Design | 20% | Prompt structure — few-shot, CoT, role+task+constraint patterns |\n",
+    "| C3 Output Spec | 20% | Format, length, tone, structure constraints |\n",
+    "| C4 Domain | 20% | Domain vocabulary and contextual accuracy |\n",
+    "| C5 Ethics | 15% | No harmful or biased framing — score of 1 overrides the final score |\n",
+    "| C6 Metacognition | 10% | Self-awareness, iteration design, fallback handling |\n",
+    "        \"\"\")\n",
+    "\n",
+    "    # ── Events ────────────────────────────────────────────────────────────────\n",
+    "    domain_dd.change(\n",
+    "        fn=on_domain_change,\n",
+    "        inputs=domain_dd,\n",
+    "        outputs=[scenario_display, scenario_context, prompt_box, result_html]\n",
+    "    )\n",
+    "    new_scenario_btn.click(\n",
+    "        fn=on_new_scenario,\n",
+    "        inputs=domain_dd,\n",
+    "        outputs=[scenario_display, scenario_context, prompt_box, result_html]\n",
+    "    )\n",
+    "    eval_btn.click(\n",
+    "        fn=evaluate,\n",
+    "        inputs=[domain_dd, prompt_box, scenario_context],\n",
+    "        outputs=result_html\n",
+    "    )\n",
+    "    clear_btn.click(\n",
+    "        fn=clear_all,\n",
+    "        outputs=[domain_dd, scenario_display, prompt_box, result_html]\n",
+    "    )\n",
+    "\n",
+    "demo.launch(share=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "print(os.path.exists(\"./pels_phi2_qlora\"))  # should print True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cell 13 — Merge LoRA weights into base model (for FastAPI deployment)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from peft import PeftModel\n",
+    "import torch\n",
+    "\n",
+    "MERGED_DIR = \"./pels_phi2_merged\"\n",
+    "\n",
+    "print(\"Merging LoRA adapter into base model...\")\n",
+    "print(\"(This creates a standalone model — no PEFT dependency needed for inference)\")\n",
+    "print()\n",
+    "\n",
+    "# Reload base model in fp16 (not quantised) for merging\n",
+    "base_model = AutoModelForCausalLM.from_pretrained(\n",
+    "    MODEL_ID,\n",
+    "    torch_dtype=torch.float16,\n",
+    "    device_map=\"cpu\",       # Merge on CPU to avoid VRAM issues\n",
+    "    trust_remote_code=True,\n",
+    ")\n",
+    "\n",
+    "# Load and merge LoRA weights\n",
+    "peft_model = PeftModel.from_pretrained(base_model, OUTPUT_DIR)\n",
+    "merged = peft_model.merge_and_unload()\n",
+    "\n",
+    "# Save merged model\n",
+    "merged.save_pretrained(MERGED_DIR, safe_serialization=True)\n",
+    "tokenizer.save_pretrained(MERGED_DIR)\n",
+    "\n",
+    "print(f\"✅ Merged model saved to: {MERGED_DIR}\")\n",
+    "print()\n",
+    "\n",
+    "import os\n",
+    "size_gb = sum(os.path.getsize(os.path.join(MERGED_DIR, f)) for f in os.listdir(MERGED_DIR)) / 1e9\n",
+    "print(f\"Merged model size: {size_gb:.1f} GB\")\n",
+    "print()\n",
+    "print(\"Files saved:\")\n",
+    "for f in sorted(os.listdir(MERGED_DIR)):\n",
+    "    fsize = os.path.getsize(os.path.join(MERGED_DIR, f)) / 1e6\n",
+    "    print(f\"  {f:40s} {fsize:.1f} MB\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cell 14 — FastAPI /grade endpoint (ready to plug into Zoho Creator)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Save the FastAPI server to a file\n",
+    "# Run it with: python pels_api.py\n",
+    "# Zoho Creator calls: POST http://[YOUR_IP]:8000/grade  with X-API-Key header\n",
+    "\n",
+    "api_code = '''\n",
+    "from fastapi import FastAPI, HTTPException, Header\n",
+    "from pydantic import BaseModel\n",
+    "from typing import Optional\n",
+    "import torch, re\n",
+    "from transformers import AutoTokenizer, AutoModelForCausalLM\n",
+    "\n",
+    "# ── Config\n",
+    "MODEL_PATH = \"./pels_phi2_merged\"   # Path to merged model\n",
+    "API_KEY    = \"pels-secret-key-2026\" # Match this in Zoho Creator X-API-Key header\n",
+    "\n",
+    "RUBRIC = \"\"\"C1 Foundations (15%): Task clarity, role setup, AI awareness.\n",
+    "C2 Design (20%): Prompt structure, patterns.\n",
+    "C3 Output Spec (20%): Format, length, tone constraints.\n",
+    "C4 Domain Application (20%): Domain vocabulary, contextual accuracy.\n",
+    "C5 Ethics (15%): No harmful framing. Score=1 triggers Final Score override to 1.0.\n",
+    "C6 Metacognition (10%): Self-awareness, iteration design.\"\"\"\n",
+    "\n",
+    "# ── Load model on startup\n",
+    "app = FastAPI(title=\"PELS Grading API\")\n",
+    "tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, trust_remote_code=True)\n",
+    "model = AutoModelForCausalLM.from_pretrained(\n",
+    "    MODEL_PATH, torch_dtype=torch.float16,\n",
+    "    device_map=\"auto\", trust_remote_code=True\n",
+    ")\n",
+    "model.eval()\n",
+    "\n",
+    "class GradeRequest(BaseModel):\n",
+    "    question_text: str\n",
+    "    candidate_answer: str\n",
+    "    domain: str\n",
+    "    level: str = \"L1\"  # L1 or L2\n",
+    "\n",
+    "def extract_scores(text):\n",
+    "    patterns = {\n",
+    "        \"C1\": r\"C1_Foundations:\\\\s*([0-9.]+)\",\n",
+    "        \"C2\": r\"C2_Design:\\\\s*([0-9.]+)\",\n",
+    "        \"C3\": r\"C3_OutputSpec:\\\\s*([0-9.]+)\",\n",
+    "        \"C4\": r\"C4_Domain:\\\\s*([0-9.]+)\",\n",
+    "        \"C5\": r\"C5_Ethics:\\\\s*([0-9.]+)\",\n",
+    "        \"C6\": r\"C6_Metacognition:\\\\s*([0-9.]+)\",\n",
+    "        \"Final\": r\"Final_Score:\\\\s*([0-9.]+)\",\n",
+    "    }\n",
+    "    return {k: float(m.group(1)) if (m := re.search(p, text)) else 5.0\n",
+    "            for k, p in patterns.items()}\n",
+    "\n",
+    "@app.get(\"/health\")\n",
+    "def health(): return {\"status\": \"ok\", \"model\": MODEL_PATH}\n",
+    "\n",
+    "@app.post(\"/grade\")\n",
+    "def grade(req: GradeRequest, x_api_key: Optional[str] = Header(None)):\n",
+    "    if x_api_key != API_KEY:\n",
+    "        raise HTTPException(status_code=401, detail=\"Invalid API key\")\n",
+    "\n",
+    "    prompt = (f\"Instruct: ### PELS Grading Task\\\\nDomain: {req.domain}\\\\n\"\n",
+    "              f\"Level: {req.level}\\\\nRubric:\\\\n{RUBRIC}\\\\n\\\\n\"\n",
+    "              f\"Candidate Prompt:\\\\n{req.question_text}\\\\n\\\\n\"\n",
+    "              f\"Candidate Answer:\\\\n{req.candidate_answer}\\\\n\\\\n\"\n",
+    "              f\"### Evaluation\\\\nOutput:\")\n",
+    "\n",
+    "    inputs = tokenizer(prompt, return_tensors=\"pt\", truncation=True, max_length=512).to(model.device)\n",
+    "    with torch.no_grad():\n",
+    "        out = model.generate(**inputs, max_new_tokens=350, temperature=0.3,\n",
+    "                             do_sample=True, pad_token_id=tokenizer.eos_token_id)\n",
+    "    text = tokenizer.decode(out[0], skip_special_tokens=True)\n",
+    "    scores = extract_scores(text)\n",
+    "\n",
+    "    # Apply C5 veto\n",
+    "    if scores.get(\"C5\", 10) <= 1.0:\n",
+    "        scores[\"Final\"] = 1.0\n",
+    "        veto = True\n",
+    "    else:\n",
+    "        veto = False\n",
+    "\n",
+    "    # Extract justification\n",
+    "    just_match = re.search(r\"Justification:\\\\s*(.+)\", text, re.DOTALL)\n",
+    "    justification = just_match.group(1).strip()[:600] if just_match else \"\"\n",
+    "\n",
+    "    return {\n",
+    "        \"C1\": scores[\"C1\"], \"C2\": scores[\"C2\"], \"C3\": scores[\"C3\"],\n",
+    "        \"C4\": scores[\"C4\"], \"C5\": scores[\"C5\"], \"C6\": scores[\"C6\"],\n",
+    "        \"final_score\": scores[\"Final\"],\n",
+    "        \"veto_triggered\": veto,\n",
+    "        \"confidence\": 85,\n",
+    "        \"justification\": justification,\n",
+    "        \"strengths\": \"\",\n",
+    "        \"gaps\": \"\"\n",
+    "    }\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    import uvicorn\n",
+    "    uvicorn.run(app, host=\"0.0.0.0\", port=8000)\n",
+    "'''\n",
+    "\n",
+    "with open('pels_api.py', 'w') as f:\n",
+    "    f.write(api_code.strip())\n",
+    "\n",
+    "print(\"✅ FastAPI server saved to: pels_api.py\")\n",
+    "print()\n",
+    "print(\"To run the API server:\")\n",
+    "print(\"  pip install fastapi uvicorn\")\n",
+    "print(\"  python pels_api.py\")\n",
+    "print()\n",
+    "print(\"To test it:\")\n",
+    "print('  curl -X POST http://localhost:8000/grade \\\\')\n",
+    "print('       -H \"X-API-Key: pels-secret-key-2026\" \\\\')\n",
+    "print('       -H \"Content-Type: application/json\" \\\\')\n",
+    "print('       -d \\'{{\"question_text\":\"help me\",\"candidate_answer\":\"OK\",\"domain\":\"CAREER\",\"level\":\"L1\"}}\\'')\n",
+    "print()\n",
+    "print(\"Zoho Creator Deluge invokeurl() target:\")\n",
+    "print(\"  http://[YOUR_GPU_IP]:8000/grade\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cell 15 — Troubleshooting guide"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "TROUBLESHOOTING = \"\"\"\n",
+    "=================================================================\n",
+    "RTX 3050 TROUBLESHOOTING GUIDE\n",
+    "=================================================================\n",
+    "\n",
+    "ERROR: CUDA out of memory\n",
+    "  Fix 1: per_device_train_batch_size=1 (already set)\n",
+    "  Fix 2: gradient_accumulation_steps=16 (increase from 8)\n",
+    "  Fix 3: MAX_LENGTH=256 (reduce from 512)\n",
+    "  Fix 4: Close all other GPU apps (Chrome, Discord etc.)\n",
+    "  Fix 5: torch.cuda.empty_cache() then retry\n",
+    "  Fix 6: lora_config r=4 (reduce from 8)\n",
+    "\n",
+    "ERROR: bitsandbytes not found / CUDA error\n",
+    "  Fix: pip install bitsandbytes --upgrade\n",
+    "  Verify: python -c \"import bitsandbytes; print(bitsandbytes.__version__)\"\n",
+    "\n",
+    "ERROR: Model scores come back as None\n",
+    "  Cause: Model is not generating the expected format yet (needs more training)\n",
+    "  Fix 1: Increase num_train_epochs to 5\n",
+    "  Fix 2: Reduce learning_rate to 1e-4\n",
+    "  Fix 3: Check that training examples have correct format in Cell 5\n",
+    "\n",
+    "SLOW TRAINING (>5 seconds/step)\n",
+    "  Fix 1: Confirm gradient_checkpointing=True (trades speed for memory)\n",
+    "  Fix 2: group_by_length=True (already set — batches similar lengths)\n",
+    "  Fix 3: dataloader_num_workers=0 if getting DataLoader errors\n",
+    "\n",
+    "ERROR: trust_remote_code warning for Phi-2\n",
+    "  Fix: trust_remote_code=True is already set — this is expected for Phi-2\n",
+    "\n",
+    "ALTERNATIVE MODELS if Phi-2 underperforms:\n",
+    "  - TinyLlama-1.1B (faster, less capable)\n",
+    "  - Phi-3-mini-4k (better, same VRAM requirement)\n",
+    "  - Mistral-7B (needs 8GB+ VRAM — not for RTX 3050)\n",
+    "\n",
+    "CHECK VRAM AT ANY TIME:\n",
+    "  import torch\n",
+    "  print(torch.cuda.memory_summary())\n",
+    "\n",
+    "=================================================================\n",
+    "\"\"\"\n",
+    "print(TROUBLESHOOTING)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "SC (GPU-Fixed)",
+   "language": "python",
+   "name": "softcomp"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.20"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}