{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-16T01:33:40.641864Z",
     "start_time": "2025-07-16T01:33:35.023421Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/miniconda3/envs/prob/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "os.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\n",
    "\n",
    "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
    "import torch, numpy as np\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from scipy.stats import pearsonr, entropy\n",
    "from sklearn.metrics.pairwise import rbf_kernel\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"2,3,4,5,6,7\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-16T01:33:49.879531Z",
     "start_time": "2025-07-16T01:33:40.667686Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "`torch_dtype` is deprecated! Use `dtype` instead!\n",
      "The following generation flags are not valid and may be ignored: ['output_attentions', 'output_hidden_states']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "LlamaForCausalLM(\n",
       "  (model): LlamaModel(\n",
       "    (embed_tokens): Embedding(128256, 2048)\n",
       "    (layers): ModuleList(\n",
       "      (0-15): 16 x LlamaDecoderLayer(\n",
       "        (self_attn): LlamaAttention(\n",
       "          (q_proj): Linear(in_features=2048, out_features=2048, bias=False)\n",
       "          (k_proj): Linear(in_features=2048, out_features=512, bias=False)\n",
       "          (v_proj): Linear(in_features=2048, out_features=512, bias=False)\n",
       "          (o_proj): Linear(in_features=2048, out_features=2048, bias=False)\n",
       "        )\n",
       "        (mlp): LlamaMLP(\n",
       "          (gate_proj): Linear(in_features=2048, out_features=8192, bias=False)\n",
       "          (up_proj): Linear(in_features=2048, out_features=8192, bias=False)\n",
       "          (down_proj): Linear(in_features=8192, out_features=2048, bias=False)\n",
       "          (act_fn): SiLU()\n",
       "        )\n",
       "        (input_layernorm): LlamaRMSNorm((2048,), eps=1e-05)\n",
       "        (post_attention_layernorm): LlamaRMSNorm((2048,), eps=1e-05)\n",
       "      )\n",
       "    )\n",
       "    (norm): LlamaRMSNorm((2048,), eps=1e-05)\n",
       "    (rotary_emb): LlamaRotaryEmbedding()\n",
       "  )\n",
       "  (lm_head): Linear(in_features=2048, out_features=128256, bias=False)\n",
       ")"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load model\n",
    "\n",
    "torch.mps.empty_cache() if torch.backends.mps.is_available() else None\n",
    "if torch.cuda.is_available():\n",
    "    device = torch.device(\"cuda\")\n",
    "elif torch.backends.mps.is_available():\n",
    "    device = torch.device(\"mps\")\n",
    "else:\n",
    "    device = torch.device(\"cpu\")\n",
    "\n",
    "# model_name = \"Qwen/Qwen3-1.7B\"\n",
    "model_name = \"meta-llama/Llama-3.2-1B-Instruct\"\n",
    "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
    "if tokenizer.pad_token is None:\n",
    "        tokenizer.pad_token = tokenizer.eos_token\n",
    "model = AutoModelForCausalLM.from_pretrained(\n",
    "    model_name,\n",
    "    output_hidden_states=True,\n",
    "    output_attentions=True,\n",
    "    torch_dtype=torch.float16,\n",
    "    device_map=\"auto\",\n",
    "    attn_implementation=\"eager\",  # Set this during model initialization\n",
    ")\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-21T03:03:03.367458Z",
     "start_time": "2025-07-21T03:03:03.322758Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "230\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Counter({5: 46, 4: 46, 3: 46, 2: 46, 1: 46})"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load dataset\n",
    "\n",
    "import json\n",
    "\n",
    "class Sample:\n",
    "    def __init__(self, prompt, label):\n",
    "        self.prompt = prompt\n",
    "#         self.response = response\n",
    "        self.label = label  # 1=high, 0=low\n",
    "\n",
    "dataset = []\n",
    "# Load the pre-processed good/bad samples from your new file\n",
    "with open('Meta-Llama-3-8B-Instruct_gsm8k_roscoe5dim_probing.json', 'r') as f:\n",
    "    all_data = json.load(f)\n",
    "#     for dim in ['semantic_consistency', 'logicality', 'informativeness', 'fluency', 'factuality']:\n",
    "    for sample in all_data['informativeness']:      # You can change the dimension here, from 5 dimensions above\n",
    "        dataset.append(Sample(prompt=sample['eval_prompt'], label=sample['score']))\n",
    "\n",
    "print(len(dataset))\n",
    "labels = np.array([ex.label for ex in dataset])\n",
    "\n",
    "from collections import Counter\n",
    "Counter([sample.label for sample in dataset])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### extract features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-21T03:03:46.101511Z",
     "start_time": "2025-07-21T03:03:46.089639Z"
    }
   },
   "outputs": [],
   "source": [
    "from tqdm import tqdm\n",
    "\n",
    "def extract_batch_reps(batch: list[Sample]):\n",
    "    \"\"\"Returns dict of arrays: reps[layer]['mean'|'last'|'min'|'max'|'concat'], attn_entropy[layer][head]\"\"\"\n",
    "    inputs = tokenizer(\n",
    "        [ex.prompt for ex in batch],\n",
    "        return_tensors=\"pt\",\n",
    "        padding=True,\n",
    "        truncation=True,\n",
    "    ).to(model.device)\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        out = model(\n",
    "            **inputs,\n",
    "            output_hidden_states=True,\n",
    "            output_attentions=True,\n",
    "        )\n",
    "\n",
    "    hidden = out.hidden_states             # tuple of (B, S, H) per layer\n",
    "    attentions = out.attentions            # tuple of (B, heads, S, S) per layer\n",
    "\n",
    "    reps = {}\n",
    "    attn_entropy = {}\n",
    "    \n",
    "    # ignore the first embedding layer in hidden layers\n",
    "    for layer_idx, h in enumerate(hidden[1:]):\n",
    "        # 1) mean-pooled\n",
    "        mean_pooled = h.mean(dim=1).cpu().detach().numpy()       # (B, H)\n",
    "        \n",
    "        # 2) last-token (EOS) pooled\n",
    "        seq_lens = (inputs.attention_mask.sum(dim=1) - 1).cpu()\n",
    "        last_tokens = torch.stack([\n",
    "            h[i, seq_lens[i], :]\n",
    "            for i in range(h.size(0))\n",
    "        ]).cpu().detach().numpy()                                # (B, H)\n",
    "        \n",
    "        # 3) min-pooled\n",
    "        min_pooled = h.min(dim=1)[0].cpu().detach().numpy()     # (B, H)\n",
    "        \n",
    "        # 4) max-pooled\n",
    "        max_pooled = h.max(dim=1)[0].cpu().detach().numpy()     # (B, H)\n",
    "        \n",
    "        # 5) concatenation of min, max, mean\n",
    "        concat_pooled = np.concatenate([min_pooled, max_pooled, mean_pooled], axis=1)  # (B, 3*H)\n",
    "        \n",
    "        reps[layer_idx] = {\n",
    "            \"mean\": mean_pooled, \n",
    "            \"last\": last_tokens,\n",
    "            \"min\": min_pooled,\n",
    "            \"max\": max_pooled,\n",
    "            \"concat\": concat_pooled\n",
    "        }\n",
    "        \n",
    "        # Attention head entropy per example\n",
    "        # average entropy across source tokens for each head\n",
    "        A = attentions[layer_idx]      # (B, heads, S, S)\n",
    "        # compute entropy over S distribution for each head and each example, then mean\n",
    "        # Only compute entropy for non-zero attention weights\n",
    "        mask = A > 0\n",
    "        log_A = torch.where(mask, torch.log(A), torch.zeros_like(A))\n",
    "        ent = - (A * log_A).sum(dim=-1).mean(dim=-1)\n",
    "        # ent = - (A * torch.log(A + 1e-12)).sum(dim=-1).mean(dim=-1)  # (B, heads)\n",
    "        attn_entropy[layer_idx] = ent.cpu().detach().numpy()   # (B, heads)\n",
    "    \n",
    "    return reps, attn_entropy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-21T03:12:28.485074Z",
     "start_time": "2025-07-21T03:05:01.680242Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 230/230 [00:08<00:00, 27.15it/s]\n"
     ]
    }
   ],
   "source": [
    "# Run in batches, cache to disk or memory to avoid recompute\n",
    "all_reps, all_attn = {}, {}\n",
    "batch_size = 1\n",
    "for i in tqdm(range(0, len(dataset), batch_size)):\n",
    "    batch = dataset[i : i + batch_size]\n",
    "    reps, ent = extract_batch_reps(batch)\n",
    "    for l in reps:\n",
    "        if l not in all_reps: \n",
    "            all_reps[l] = {\"mean\": [], \"last\": [], \"min\": [], \"max\": [], \"concat\": []}\n",
    "        for pool_method in [\"mean\", \"last\", \"min\", \"max\", \"concat\"]:\n",
    "            all_reps[l][pool_method].append(reps[l][pool_method])\n",
    "        all_attn.setdefault(l, []).append(ent[l])\n",
    "\n",
    "# Stack per layer/pool\n",
    "for l in all_reps:\n",
    "    all_reps[l][\"mean\"] = np.vstack(all_reps[l][\"mean\"])\n",
    "    all_reps[l][\"last\"] = np.vstack(all_reps[l][\"last\"])\n",
    "    all_reps[l][\"min\"] = np.vstack(all_reps[l][\"min\"])\n",
    "    all_reps[l][\"max\"] = np.vstack(all_reps[l][\"max\"])\n",
    "    all_reps[l][\"concat\"] = np.vstack(all_reps[l][\"concat\"])  # (N, 3*H)\n",
    "    all_attn[l] = np.vstack(all_attn[l])  # shape (N, heads)\n",
    "\n",
    "labels = np.array([ex.label for ex in dataset])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### save all_reps and all_attn first, then load them (optional)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-16T01:34:32.747081Z",
     "start_time": "2025-07-16T01:34:32.676773Z"
    }
   },
   "outputs": [],
   "source": [
    "# Save all_reps\n",
    "np.savez('gsm8k_prob_reps.npz', **{f\"{l}_{k}\": v for l, d in all_reps.items() for k, v in d.items()})\n",
    "\n",
    "# Save all_attn\n",
    "np.savez('gsm8k_prob_attn.npz', **{f\"{l}_attn\": v for l, v in all_attn.items()})\n",
    "\n",
    "# Load all_reps\n",
    "loaded_reps = np.load('gsm8k_prob_reps.npz')\n",
    "all_reps = {}\n",
    "for key in loaded_reps:\n",
    "    l, kind = key.split('_')\n",
    "    l = int(l)\n",
    "    if l not in all_reps:\n",
    "        all_reps[l] = {}\n",
    "    all_reps[l][kind] = loaded_reps[key]\n",
    "\n",
    "# Load all_attn\n",
    "loaded_attn = np.load('gsm8k_prob_attn.npz')\n",
    "all_attn = {int(k.split('_')[0]): loaded_attn[k] for k in loaded_attn}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### layer probing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-18T06:29:48.935067Z",
     "start_time": "2025-07-18T06:21:58.892944Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing 16 layers...\n",
      "Layer 0...\n",
      "Layer 1...\n",
      "Layer 2...\n",
      "Layer 3...\n",
      "Layer 4...\n",
      "Layer 5...\n",
      "Layer 6...\n",
      "Layer 7...\n",
      "Layer 8...\n",
      "Layer 9...\n",
      "Layer 10...\n",
      "Layer 11...\n",
      "Layer 12...\n",
      "Layer 13...\n",
      "Layer 14...\n",
      "Layer 15...\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x1000 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top performing layer-feature combinations by binary acc:\n",
      "================================================================================\n",
      "Rank Layer  Pool   Feature    Binary Acc   Multi Acc    Spearman r  \n",
      "--------------------------------------------------------------------------------\n",
      "1    2      mean   pca        0.748±0.017 0.400±0.051 -0.280\n",
      "2    11     mean   pca        0.713±0.052 0.391±0.050 -0.291\n",
      "3    0      mean   pca        0.713±0.025 0.357±0.065 -0.297\n",
      "4    12     mean   pca        0.709±0.033 0.404±0.045 -0.295\n",
      "5    7      mean   pca        0.704±0.045 0.365±0.052 -0.283\n",
      "Top performing layer-feature combinations by multi-class acc:\n",
      "================================================================================\n",
      "Rank Layer  Pool   Feature    Binary Acc   Multi Acc    Spearman r  \n",
      "--------------------------------------------------------------------------------\n",
      "1    12     last   pca        0.657±0.046 0.461±0.029 -0.302\n",
      "2    9      mean   attention  0.617±0.026 0.448±0.062 0.258\n",
      "3    9      last   attention  0.617±0.026 0.448±0.062 0.258\n",
      "4    10     mean   attention  0.643±0.075 0.439±0.035 0.265\n",
      "5    10     last   attention  0.643±0.075 0.439±0.035 0.265\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import cross_val_score, StratifiedKFold\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.metrics import classification_report, accuracy_score\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.impute import SimpleImputer\n",
    "from scipy.stats import spearmanr, pearsonr\n",
    "import matplotlib.pyplot as plt\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "def safe_entropy(X):\n",
    "    \"\"\"Compute entropy safely, handling NaN and infinite values\"\"\"\n",
    "    # Clip extreme values\n",
    "    X_clipped = np.clip(X, -50, 50)  # Prevent overflow in exp\n",
    "    \n",
    "    # Stable softmax\n",
    "    X_shifted = X_clipped - np.max(X_clipped, axis=1, keepdims=True)\n",
    "    e_x = np.exp(X_shifted)\n",
    "    probs = e_x / (e_x.sum(axis=1, keepdims=True) + 1e-12)\n",
    "    \n",
    "    # Compute entropy\n",
    "    log_probs = np.log(probs + 1e-12)\n",
    "    entropies = -np.sum(probs * log_probs, axis=1)\n",
    "    \n",
    "    # Handle any remaining NaN/inf values\n",
    "    entropies = np.nan_to_num(entropies, nan=0.0, posinf=0.0, neginf=0.0)\n",
    "    \n",
    "    return entropies.reshape(-1, 1)\n",
    "\n",
    "def clean_features(X):\n",
    "    \"\"\"Clean feature matrix by handling NaN and infinite values\"\"\"\n",
    "    # Replace NaN and infinite values\n",
    "    X_clean = np.nan_to_num(X, nan=0.0, posinf=1e6, neginf=-1e6)\n",
    "    \n",
    "    # Remove constant features (they cause issues with scaling)\n",
    "    feature_vars = np.var(X_clean, axis=0)\n",
    "    non_constant_mask = feature_vars > 1e-12\n",
    "    \n",
    "    if np.sum(non_constant_mask) == 0:\n",
    "        # All features are constant, return a single feature of zeros\n",
    "        return np.zeros((X_clean.shape[0], 1))\n",
    "    \n",
    "    X_clean = X_clean[:, non_constant_mask]\n",
    "    \n",
    "    return X_clean\n",
    "\n",
    "def improved_layer_analysis(all_reps, all_attn, labels):\n",
    "    \"\"\"\n",
    "    Better approach for layer selection based on actual classification performance\n",
    "    \"\"\"\n",
    "    results = []\n",
    "    \n",
    "    # Convert labels to classification problem (you can adjust this)\n",
    "    # Option 1: Binary (high vs low quality)\n",
    "    binary_labels = (labels >= 4).astype(int)  # 4,5 = high quality\n",
    "    \n",
    "    # Option 2: Multi-class (keep original 2,3,4,5)\n",
    "    multiclass_labels = labels\n",
    "    \n",
    "    print(f\"Processing {len(all_reps)} layers...\")\n",
    "    \n",
    "    for l in all_reps:\n",
    "        print(f\"Layer {l}...\")\n",
    "        for pool_type in [\"mean\", \"last\"]:\n",
    "            X = all_reps[l][pool_type]\n",
    "            \n",
    "            # Skip if X is empty or has issues\n",
    "            if X.shape[0] == 0 or X.shape[1] == 0:\n",
    "                continue\n",
    "            \n",
    "            # Feature engineering\n",
    "            features = {}\n",
    "            \n",
    "            try:\n",
    "                # 1. Raw representations (select top components)\n",
    "                X_clean = clean_features(X)\n",
    "                if X_clean.shape[1] > 0:\n",
    "                    n_components = min(50, X_clean.shape[1], X_clean.shape[0] - 1)\n",
    "                    if n_components > 0:\n",
    "                        pca = PCA(n_components=n_components)\n",
    "                        X_pca = pca.fit_transform(X_clean)\n",
    "                        features['pca'] = clean_features(X_pca)\n",
    "                \n",
    "                # 2. Statistical features\n",
    "                norms = np.linalg.norm(X, axis=1).reshape(-1, 1)\n",
    "                variances = X.var(axis=1).reshape(-1, 1)\n",
    "                entropies = safe_entropy(X)\n",
    "                \n",
    "                stats_features = np.hstack([norms, variances, entropies])\n",
    "                features['stats'] = clean_features(stats_features)\n",
    "                \n",
    "                # 3. Attention features\n",
    "                if l in all_attn:\n",
    "                    attn_data = all_attn[l]\n",
    "                    attn_mean = attn_data.mean(axis=1).reshape(-1, 1)\n",
    "                    attn_std = attn_data.std(axis=1).reshape(-1, 1)\n",
    "                    attn_max = attn_data.max(axis=1).reshape(-1, 1)\n",
    "                    \n",
    "                    attn_features = np.hstack([attn_mean, attn_std, attn_max])\n",
    "                    features['attention'] = clean_features(attn_features)\n",
    "                \n",
    "            except Exception as e:\n",
    "                print(f\"Error processing layer {l}, pool {pool_type}: {e}\")\n",
    "                continue\n",
    "            \n",
    "            # Test different feature combinations\n",
    "            for feature_name, X_feat in features.items():\n",
    "                if X_feat.shape[1] == 0:\n",
    "                    continue\n",
    "                    \n",
    "                try:\n",
    "                    # Use imputer and scaler pipeline\n",
    "                    imputer = SimpleImputer(strategy='median')\n",
    "                    scaler = StandardScaler()\n",
    "                    \n",
    "                    X_imputed = imputer.fit_transform(X_feat)\n",
    "                    X_scaled = scaler.fit_transform(X_imputed)\n",
    "                    \n",
    "                    # Binary classification\n",
    "                    clf_binary = LogisticRegression(random_state=42, max_iter=1000)\n",
    "                    cv_scores_binary = cross_val_score(\n",
    "                        clf_binary, X_scaled, binary_labels, \n",
    "                        cv=StratifiedKFold(n_splits=5, shuffle=True, random_state=42),\n",
    "                        scoring='accuracy'\n",
    "                    )\n",
    "                    \n",
    "                    # Multi-class classification\n",
    "                    clf_multi = LogisticRegression(random_state=42, max_iter=1000)\n",
    "                    cv_scores_multi = cross_val_score(\n",
    "                        clf_multi, X_scaled, multiclass_labels,\n",
    "                        cv=StratifiedKFold(n_splits=5, shuffle=True, random_state=42),\n",
    "                        scoring='accuracy'\n",
    "                    )\n",
    "                    \n",
    "                    # Correlation analysis\n",
    "                    if X_feat.shape[1] == 1:\n",
    "                        feat_1d = X_imputed.flatten()\n",
    "                        # Check for constant features\n",
    "                        if np.std(feat_1d) > 1e-12:\n",
    "                            corr_pearson, p_pearson = pearsonr(feat_1d, labels)\n",
    "                            corr_spearman, p_spearman = spearmanr(feat_1d, labels)\n",
    "                        else:\n",
    "                            corr_pearson, p_pearson = 0.0, 1.0\n",
    "                            corr_spearman, p_spearman = 0.0, 1.0\n",
    "                    else:\n",
    "                        # For multi-dimensional features, use first PC\n",
    "                        if X_imputed.shape[1] > 1:\n",
    "                            pc1 = PCA(n_components=1).fit_transform(X_imputed).flatten()\n",
    "                            if np.std(pc1) > 1e-12:\n",
    "                                corr_pearson, p_pearson = pearsonr(pc1, labels)\n",
    "                                corr_spearman, p_spearman = spearmanr(pc1, labels)\n",
    "                            else:\n",
    "                                corr_pearson, p_pearson = 0.0, 1.0\n",
    "                                corr_spearman, p_spearman = 0.0, 1.0\n",
    "                        else:\n",
    "                            corr_pearson, p_pearson = 0.0, 1.0\n",
    "                            corr_spearman, p_spearman = 0.0, 1.0\n",
    "                    \n",
    "                    results.append({\n",
    "                        'layer': l,\n",
    "                        'pool_type': pool_type,\n",
    "                        'feature_type': feature_name,\n",
    "                        'binary_acc_mean': cv_scores_binary.mean(),\n",
    "                        'binary_acc_std': cv_scores_binary.std(),\n",
    "                        'multi_acc_mean': cv_scores_multi.mean(),\n",
    "                        'multi_acc_std': cv_scores_multi.std(),\n",
    "                        'pearson_r': corr_pearson,\n",
    "                        'pearson_p': p_pearson,\n",
    "                        'spearman_r': corr_spearman,\n",
    "                        'spearman_p': p_spearman,\n",
    "                        'n_features': X_feat.shape[1]\n",
    "                    })\n",
    "                \n",
    "                except Exception as e:\n",
    "                    print(f\"Error with layer {l}, pool {pool_type}, feature {feature_name}: {e}\")\n",
    "                    continue\n",
    "    \n",
    "    return results\n",
    "\n",
    "def analyze_layer_progression(results):\n",
    "    \"\"\"\n",
    "    Analyze how probing performance changes across layers\n",
    "    \"\"\"\n",
    "    # Group by layer and feature type\n",
    "    layer_analysis = {}\n",
    "    \n",
    "    for result in results:\n",
    "        layer = result['layer']\n",
    "        if layer not in layer_analysis:\n",
    "            layer_analysis[layer] = []\n",
    "        layer_analysis[layer].append(result)\n",
    "    \n",
    "    # Plot layer progression\n",
    "    fig, axes = plt.subplots(2, 2, figsize=(15, 10))\n",
    "    \n",
    "    layers = sorted(layer_analysis.keys())\n",
    "    \n",
    "    # Binary classification accuracy\n",
    "    binary_means = []\n",
    "    binary_stds = []\n",
    "    for layer in layers:\n",
    "        best_result = max(layer_analysis[layer], key=lambda x: x['binary_acc_mean'])\n",
    "        binary_means.append(best_result['binary_acc_mean'])\n",
    "        binary_stds.append(best_result['binary_acc_std'])\n",
    "    \n",
    "    axes[0,0].errorbar(layers, binary_means, yerr=binary_stds, marker='o')\n",
    "    axes[0,0].set_title('Binary Classification Accuracy by Layer')\n",
    "    axes[0,0].set_xlabel('Layer')\n",
    "    axes[0,0].set_ylabel('Accuracy')\n",
    "    axes[0,0].grid(True)\n",
    "    \n",
    "    # Multi-class accuracy\n",
    "    multi_means = []\n",
    "    multi_stds = []\n",
    "    for layer in layers:\n",
    "        best_result = max(layer_analysis[layer], key=lambda x: x['multi_acc_mean'])\n",
    "        multi_means.append(best_result['multi_acc_mean'])\n",
    "        multi_stds.append(best_result['multi_acc_std'])\n",
    "    \n",
    "    axes[0,1].errorbar(layers, multi_means, yerr=multi_stds, marker='o', color='orange')\n",
    "    axes[0,1].set_title('Multi-class Classification Accuracy by Layer')\n",
    "    axes[0,1].set_xlabel('Layer')\n",
    "    axes[0,1].set_ylabel('Accuracy')\n",
    "    axes[0,1].grid(True)\n",
    "    \n",
    "    # Correlation analysis\n",
    "    pearson_corrs = []\n",
    "    spearman_corrs = []\n",
    "    for layer in layers:\n",
    "        best_pearson = max(layer_analysis[layer], key=lambda x: abs(x['pearson_r']))\n",
    "        best_spearman = max(layer_analysis[layer], key=lambda x: abs(x['spearman_r']))\n",
    "        pearson_corrs.append(best_pearson['pearson_r'])\n",
    "        spearman_corrs.append(best_spearman['spearman_r'])\n",
    "    \n",
    "    axes[1,0].plot(layers, pearson_corrs, marker='o', label='Pearson', color='green')\n",
    "    axes[1,0].plot(layers, spearman_corrs, marker='s', label='Spearman', color='red')\n",
    "    axes[1,0].set_title('Correlation by Layer')\n",
    "    axes[1,0].set_xlabel('Layer')\n",
    "    axes[1,0].set_ylabel('Correlation')\n",
    "    axes[1,0].legend()\n",
    "    axes[1,0].grid(True)\n",
    "    \n",
    "    # Feature type comparison\n",
    "    feature_types = ['pca', 'stats', 'attention']\n",
    "    feature_performance = {ft: [] for ft in feature_types}\n",
    "    \n",
    "    for layer in layers:\n",
    "        for ft in feature_types:\n",
    "            ft_results = [r for r in layer_analysis[layer] if r['feature_type'] == ft]\n",
    "            if ft_results:\n",
    "                best_ft = max(ft_results, key=lambda x: x['binary_acc_mean'])\n",
    "                feature_performance[ft].append(best_ft['binary_acc_mean'])\n",
    "            else:\n",
    "                feature_performance[ft].append(0)\n",
    "    \n",
    "    for ft in feature_types:\n",
    "        axes[1,1].plot(layers, feature_performance[ft], marker='o', label=ft)\n",
    "    \n",
    "    axes[1,1].set_title('Feature Type Performance by Layer')\n",
    "    axes[1,1].set_xlabel('Layer')\n",
    "    axes[1,1].set_ylabel('Binary Classification Accuracy')\n",
    "    axes[1,1].legend()\n",
    "    axes[1,1].grid(True)\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    \n",
    "    return layer_analysis\n",
    "\n",
    "def select_best_layers(results, top_k=5):\n",
    "    \"\"\"\n",
    "    Select the best layers based on classification performance\n",
    "    \"\"\"\n",
    "    # Sort by binary classification accuracy (you can change this criterion)\n",
    "    sorted_results = sorted(results, key=lambda x: x['binary_acc_mean'], reverse=True)\n",
    "    print(\"Top performing layer-feature combinations by binary acc:\")\n",
    "    print(\"=\" * 80)\n",
    "    print(f\"{'Rank':<4} {'Layer':<6} {'Pool':<6} {'Feature':<10} {'Binary Acc':<12} {'Multi Acc':<12} {'Spearman r':<12}\")\n",
    "    print(\"-\" * 80)\n",
    "    for i, result in enumerate(sorted_results[:top_k]):\n",
    "        print(f\"{i+1:<4} {result['layer']:<6} {result['pool_type']:<6} {result['feature_type']:<10} \"\n",
    "              f\"{result['binary_acc_mean']:.3f}±{result['binary_acc_std']:.3f} \"\n",
    "              f\"{result['multi_acc_mean']:.3f}±{result['multi_acc_std']:.3f} \"\n",
    "              f\"{result['spearman_r']:.3f}\")\n",
    "\n",
    "\n",
    "    sorted_results = sorted(results, key=lambda x: x['multi_acc_mean'], reverse=True)\n",
    "    print(\"Top performing layer-feature combinations by multi-class acc:\")\n",
    "    print(\"=\" * 80)\n",
    "    print(f\"{'Rank':<4} {'Layer':<6} {'Pool':<6} {'Feature':<10} {'Binary Acc':<12} {'Multi Acc':<12} {'Spearman r':<12}\")\n",
    "    print(\"-\" * 80)\n",
    "    for i, result in enumerate(sorted_results[:top_k]):\n",
    "        print(f\"{i+1:<4} {result['layer']:<6} {result['pool_type']:<6} {result['feature_type']:<10} \"\n",
    "              f\"{result['binary_acc_mean']:.3f}±{result['binary_acc_std']:.3f} \"\n",
    "              f\"{result['multi_acc_mean']:.3f}±{result['multi_acc_std']:.3f} \"\n",
    "              f\"{result['spearman_r']:.3f}\")\n",
    "    \n",
    "    return sorted_results[:top_k]\n",
    "\n",
    "# Example usage:\n",
    "# First, let's diagnose your original data\n",
    "def diagnose_data_issues(all_reps, all_attn, labels):\n",
    "    \"\"\"Diagnose NaN and infinite values in your data\"\"\"\n",
    "    print(\"Data Diagnostics:\")\n",
    "    print(\"=\" * 50)\n",
    "    \n",
    "    # Check labels\n",
    "    print(f\"Labels: {len(labels)} samples\")\n",
    "    print(f\"  NaN values: {np.sum(np.isnan(labels))}\")\n",
    "    print(f\"  Infinite values: {np.sum(np.isinf(labels))}\")\n",
    "    print(f\"  Unique values: {np.unique(labels)}\")\n",
    "    \n",
    "    # Check representations\n",
    "    total_nan_reps = 0\n",
    "    total_inf_reps = 0\n",
    "    \n",
    "    for l in all_reps:\n",
    "        for pool_type in [\"mean\", \"last\"]:\n",
    "            X = all_reps[l][pool_type]\n",
    "            nan_count = np.sum(np.isnan(X))\n",
    "            inf_count = np.sum(np.isinf(X))\n",
    "            \n",
    "            if nan_count > 0 or inf_count > 0:\n",
    "                print(f\"Layer {l}-{pool_type}: {nan_count} NaN, {inf_count} Inf values\")\n",
    "            \n",
    "            total_nan_reps += nan_count\n",
    "            total_inf_reps += inf_count\n",
    "    \n",
    "    print(f\"Total representation issues: {total_nan_reps} NaN, {total_inf_reps} Inf\")\n",
    "    \n",
    "    # Check attention\n",
    "    total_nan_attn = 0\n",
    "    total_inf_attn = 0\n",
    "    \n",
    "    for l in all_attn:\n",
    "        A = all_attn[l]\n",
    "        nan_count = np.sum(np.isnan(A))\n",
    "        inf_count = np.sum(np.isinf(A))\n",
    "        \n",
    "        if nan_count > 0 or inf_count > 0:\n",
    "            print(f\"Attention layer {l}: {nan_count} NaN, {inf_count} Inf values\")\n",
    "        \n",
    "        total_nan_attn += nan_count\n",
    "        total_inf_attn += inf_count\n",
    "    \n",
    "    print(f\"Total attention issues: {total_nan_attn} NaN, {total_inf_attn} Inf\")\n",
    "    \n",
    "    return {\n",
    "        'labels_nan': np.sum(np.isnan(labels)),\n",
    "        'reps_nan': total_nan_reps,\n",
    "        'reps_inf': total_inf_reps,\n",
    "        'attn_nan': total_nan_attn,\n",
    "        'attn_inf': total_inf_attn\n",
    "    }\n",
    "\n",
    "# Run this first to see what's causing the issues:\n",
    "# issues = diagnose_data_issues(all_reps, all_attn, labels)\n",
    "\n",
    "# Then run the improved analysis:\n",
    "results = improved_layer_analysis(all_reps, all_attn, labels)\n",
    "layer_analysis = analyze_layer_progression(results)\n",
    "best_layers = select_best_layers(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### build probing classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-17T10:14:18.960776Z",
     "start_time": "2025-07-17T10:14:18.956059Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_indices(split_samples):\n",
    "    return [prompt2idx[s.prompt] for s in split_samples]\n",
    "\n",
    "def featurize_by_indices(indices, layers, pool=\"mean\", use_attn=False):\n",
    "    \"\"\"Extract features for specific indices with support for multiple pooling strategies:\n",
    "    - 'mean': mean pooling across sequence length\n",
    "    - 'last': last token pooling\n",
    "    - 'min': min pooling across sequence length\n",
    "    - 'max': max pooling across sequence length\n",
    "    - 'concat': concatenation of min, max, and mean pooling (3x dimensionality)\n",
    "    \"\"\"\n",
    "    target_layers = range(len(all_reps)) if layers == 'all' else layers\n",
    "    \n",
    "    # Extract hidden features with the specified pooling strategy\n",
    "    hidden_feats = np.hstack([all_reps[l][pool][indices] for l in target_layers])\n",
    "    \n",
    "    if use_attn:\n",
    "        attn_feats = [all_attn[l][indices] for l in target_layers]  # each: (n_samples, n_heads)\n",
    "        attn_feats = np.hstack(attn_feats)  # shape: (n_samples, n_layers * n_heads)\n",
    "        # return attn_feats\n",
    "        return np.hstack([hidden_feats, attn_feats])\n",
    "    return hidden_feats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-16T01:35:22.965180Z",
     "start_time": "2025-07-16T01:35:22.305157Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.metrics import classification_report, roc_auc_score\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from scipy.stats import somersd\n",
    "\n",
    "def train_clf(X_train, y_train, clf=\"lr\"):\n",
    "    if clf == 'lr':\n",
    "        pipe = Pipeline([\n",
    "            (\"scaler\", StandardScaler()),\n",
    "            (\"clf\", LogisticRegression(\n",
    "                max_iter=2000,\n",
    "                class_weight=\"balanced\",\n",
    "                # multi_class=\"multinomial\",\n",
    "                solver=\"lbfgs\"  # supports multinomial\n",
    "            ))\n",
    "        ])\n",
    "        param_grid = {\n",
    "            \"clf__C\": [0.001, 0.01, 0.1, 1],\n",
    "            \"clf__penalty\": [\"l2\"],\n",
    "        }\n",
    "\n",
    "    elif clf == 'rf':\n",
    "        pipe = Pipeline([\n",
    "            (\"scaler\", StandardScaler()),\n",
    "            (\"clf\", RandomForestClassifier(class_weight=\"balanced\", random_state=42))\n",
    "        ])\n",
    "        param_grid = {\n",
    "            \"clf__n_estimators\": [100, 300, 500],\n",
    "            \"clf__max_depth\": [None, 10, 20],\n",
    "            \"clf__min_samples_leaf\": [1, 2, 5],\n",
    "        }\n",
    "\n",
    "    elif clf == 'mlp':\n",
    "        pipe = Pipeline([\n",
    "            (\"scaler\", StandardScaler()),\n",
    "            (\"clf\", MLPClassifier(\n",
    "                hidden_layer_sizes=(256, 128),\n",
    "                activation=\"relu\",\n",
    "                alpha=1e-4,\n",
    "                learning_rate_init=1e-3,\n",
    "                max_iter=1000,\n",
    "                early_stopping=True,\n",
    "                random_state=42\n",
    "            ))\n",
    "        ])\n",
    "        param_grid = {\n",
    "            \"clf__alpha\": [1e-4, 1e-3, 1e-2],\n",
    "            \"clf__learning_rate_init\": [1e-4, 1e-3, 1e-2],\n",
    "            \"clf__hidden_layer_sizes\": [(200, 100), (100,), (200, 100, 50)],\n",
    "        }\n",
    "    elif clf == 'linear_svm':\n",
    "        pipe = Pipeline([\n",
    "            (\"scaler\", StandardScaler()),\n",
    "            (\"clf\", SVC(\n",
    "                kernel=\"linear\",\n",
    "                class_weight=\"balanced\",\n",
    "                random_state=42,\n",
    "                probability=True  # Enable probability estimates for ROC-AUC\n",
    "            ))\n",
    "        ])\n",
    "        param_grid = {\n",
    "            \"clf__C\": [0.001, 0.01, 0.1, 1, 10, 100],\n",
    "        }\n",
    "\n",
    "    elif clf == 'nonlinear_svm':\n",
    "        pipe = Pipeline([\n",
    "            (\"scaler\", StandardScaler()),\n",
    "            (\"clf\", SVC(\n",
    "                kernel=\"rbf\",\n",
    "                class_weight=\"balanced\",\n",
    "                random_state=42,\n",
    "                probability=True  # Enable probability estimates for ROC-AUC\n",
    "            ))\n",
    "        ])\n",
    "        param_grid = {\n",
    "            \"clf__C\": [0.001, 0.01, 0.1, 1, 10, 100],\n",
    "            \"clf__gamma\": [\"scale\", \"auto\", 0.001, 0.01, 0.1, 1],\n",
    "        }\n",
    "\n",
    "    search = GridSearchCV(\n",
    "        pipe,\n",
    "        param_grid,\n",
    "        cv=5,\n",
    "        scoring=\"f1_macro\",\n",
    "        n_jobs=-1,\n",
    "        verbose=1,\n",
    "    )\n",
    "    search.fit(X_train, y_train)\n",
    "    print(f\"{clf.upper()} best params:\", search.best_params_)\n",
    "    return search\n",
    "\n",
    "def test_clf(X_test, y_test, search):\n",
    "    y_pred = search.predict(X_test)\n",
    "    y_prob = search.predict_proba(X_test)\n",
    "    print(classification_report(y_test, y_pred, digits=4))\n",
    "#     print(somersd([(sample-1)/4 for sample in y_test], [(sample-1)/4 for sample in y_pred]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "from datetime import datetime\n",
    "\n",
    "def save_model_pickle(search, base_model, dimension, classification, layers, pool=\"mean\", use_attn=False, clf_name=\"lr\", clf_path=\"model.pkl\"):\n",
    "    \"\"\"\n",
    "    Save the trained GridSearchCV pipeline + metadata in a single pickle file.\n",
    "    \"\"\"\n",
    "    metadata = {\n",
    "        \"llm\": base_model,\n",
    "        \"dimension\": dimension,\n",
    "        \"classification\": classification,   # binary or multi\n",
    "        \"layers\": layers,\n",
    "        \"pool\": pool,\n",
    "        \"use_attn\": use_attn,\n",
    "        \"clf_name\": clf_name,\n",
    "        \"best_params\": search.best_params_,\n",
    "        \"best_score\": search.best_score_,\n",
    "        \"timestamp\": datetime.now().isoformat()\n",
    "    }\n",
    "\n",
    "    package = {\n",
    "        \"model\": search,\n",
    "        \"metadata\": metadata\n",
    "    }\n",
    "\n",
    "    with open(clf_path, \"wb\") as f:\n",
    "        pickle.dump(package, f)\n",
    "    print(f\"Model + metadata saved to {clf_path}\")\n",
    "\n",
    "\n",
    "def load_model_pickle(clf_path=\"model.pkl\"):\n",
    "    \"\"\"\n",
    "    Load back the model and metadata from pickle.\n",
    "    \"\"\"\n",
    "    with open(clf_path, \"rb\") as f:\n",
    "        package = pickle.load(f)\n",
    "    clf = package[\"model\"]\n",
    "    metadata = package[\"metadata\"]\n",
    "    print(\"Loaded metadata:\", metadata)\n",
    "    return clf, metadata\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### build the classification dataset (multiclass or binary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-16T01:35:28.505799Z",
     "start_time": "2025-07-16T01:35:28.484026Z"
    }
   },
   "outputs": [],
   "source": [
    "# multiclass classification dataset (score=1-5)\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "clf_dataset = []\n",
    "\n",
    "clf_dataset = dataset\n",
    "train, test = train_test_split(clf_dataset, test_size=0.20, stratify=[s.label for s in clf_dataset], random_state=731)\n",
    "# Map from prompt to index in dataset\n",
    "prompt2idx = {s.prompt: i for i, s in enumerate(clf_dataset)}\n",
    "\n",
    "train_indices = get_indices(train)\n",
    "test_indices  = get_indices(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# binay classification dataset (score=0/1)\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "clf_dataset = []\n",
    "\n",
    "with open('Meta-Llama-3-8B-Instruct_gsm8k_roscoe5dim_probing.json', 'r') as f:\n",
    "    # for dim in ['semantic_consistency', 'logicality', 'informativeness', 'fluency', 'factuality']:\n",
    "    for sample in json.load(f)['factuality']:   # You can change the dimension here, from 5 dimensions above\n",
    "        clf_dataset.append(Sample(prompt=sample['eval_prompt'], label=1 if sample['score']>3 else 0))\n",
    "\n",
    "train, test = train_test_split(clf_dataset, test_size=0.20, stratify=[s.label for s in clf_dataset], random_state=731)\n",
    "# Map from prompt to index in dataset\n",
    "prompt2idx = {s.prompt: i for i, s in enumerate(clf_dataset)}\n",
    "\n",
    "train_indices = get_indices(train)\n",
    "test_indices  = get_indices(test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### find the layer and pooling for best performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current layer:  28\n",
      "Fitting 5 folds for each of 6 candidates, totalling 30 fits\n",
      "LINEAR_SVM best params: {'clf__C': 0.001}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1     0.4000    0.5882    0.4762        17\n",
      "           2     0.4667    0.4118    0.4375        17\n",
      "           3     0.2857    0.2353    0.2581        17\n",
      "           4     0.6250    0.5882    0.6061        17\n",
      "           5     0.7333    0.6471    0.6875        17\n",
      "\n",
      "    accuracy                         0.4941        85\n",
      "   macro avg     0.5021    0.4941    0.4931        85\n",
      "weighted avg     0.5021    0.4941    0.4931        85\n",
      "\n",
      "Fitting 5 folds for each of 4 candidates, totalling 20 fits\n",
      "LR best params: {'clf__C': 0.001, 'clf__penalty': 'l2'}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1     0.3750    0.5294    0.4390        17\n",
      "           2     0.4286    0.3529    0.3871        17\n",
      "           3     0.2667    0.2353    0.2500        17\n",
      "           4     0.6250    0.5882    0.6061        17\n",
      "           5     0.6875    0.6471    0.6667        17\n",
      "\n",
      "    accuracy                         0.4706        85\n",
      "   macro avg     0.4765    0.4706    0.4698        85\n",
      "weighted avg     0.4765    0.4706    0.4698        85\n",
      "\n",
      "Current layer:  36\n",
      "Fitting 5 folds for each of 6 candidates, totalling 30 fits\n",
      "LINEAR_SVM best params: {'clf__C': 0.01}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1     0.4074    0.6471    0.5000        17\n",
      "           2     0.3889    0.4118    0.4000        17\n",
      "           3     0.3333    0.2353    0.2759        17\n",
      "           4     0.5714    0.4706    0.5161        17\n",
      "           5     0.6429    0.5294    0.5806        17\n",
      "\n",
      "    accuracy                         0.4588        85\n",
      "   macro avg     0.4688    0.4588    0.4545        85\n",
      "weighted avg     0.4688    0.4588    0.4545        85\n",
      "\n",
      "Fitting 5 folds for each of 4 candidates, totalling 20 fits\n",
      "LR best params: {'clf__C': 0.001, 'clf__penalty': 'l2'}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1     0.4167    0.5882    0.4878        17\n",
      "           2     0.4444    0.4706    0.4571        17\n",
      "           3     0.4000    0.2353    0.2963        17\n",
      "           4     0.5882    0.5882    0.5882        17\n",
      "           5     0.6250    0.5882    0.6061        17\n",
      "\n",
      "    accuracy                         0.4941        85\n",
      "   macro avg     0.4949    0.4941    0.4871        85\n",
      "weighted avg     0.4949    0.4941    0.4871        85\n",
      "\n",
      "Current layer:  30\n",
      "Fitting 5 folds for each of 6 candidates, totalling 30 fits\n",
      "LINEAR_SVM best params: {'clf__C': 0.001}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1     0.4583    0.6471    0.5366        17\n",
      "           2     0.5000    0.4706    0.4848        17\n",
      "           3     0.4000    0.3529    0.3750        17\n",
      "           4     0.6250    0.5882    0.6061        17\n",
      "           5     0.7143    0.5882    0.6452        17\n",
      "\n",
      "    accuracy                         0.5294        85\n",
      "   macro avg     0.5395    0.5294    0.5295        85\n",
      "weighted avg     0.5395    0.5294    0.5295        85\n",
      "\n",
      "Fitting 5 folds for each of 4 candidates, totalling 20 fits\n",
      "LR best params: {'clf__C': 0.001, 'clf__penalty': 'l2'}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1     0.5238    0.6471    0.5789        17\n",
      "           2     0.4706    0.4706    0.4706        17\n",
      "           3     0.3571    0.2941    0.3226        17\n",
      "           4     0.5556    0.5882    0.5714        17\n",
      "           5     0.6667    0.5882    0.6250        17\n",
      "\n",
      "    accuracy                         0.5176        85\n",
      "   macro avg     0.5148    0.5176    0.5137        85\n",
      "weighted avg     0.5148    0.5176    0.5137        85\n",
      "\n",
      "Current layer:  32\n",
      "Fitting 5 folds for each of 6 candidates, totalling 30 fits\n",
      "LINEAR_SVM best params: {'clf__C': 0.01}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1     0.4074    0.6471    0.5000        17\n",
      "           2     0.4706    0.4706    0.4706        17\n",
      "           3     0.2308    0.1765    0.2000        17\n",
      "           4     0.5714    0.4706    0.5161        17\n",
      "           5     0.7143    0.5882    0.6452        17\n",
      "\n",
      "    accuracy                         0.4706        85\n",
      "   macro avg     0.4789    0.4706    0.4664        85\n",
      "weighted avg     0.4789    0.4706    0.4664        85\n",
      "\n",
      "Fitting 5 folds for each of 4 candidates, totalling 20 fits\n",
      "LR best params: {'clf__C': 0.001, 'clf__penalty': 'l2'}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1     0.4348    0.5882    0.5000        17\n",
      "           2     0.4706    0.4706    0.4706        17\n",
      "           3     0.3333    0.2353    0.2759        17\n",
      "           4     0.5556    0.5882    0.5714        17\n",
      "           5     0.6000    0.5294    0.5625        17\n",
      "\n",
      "    accuracy                         0.4824        85\n",
      "   macro avg     0.4789    0.4824    0.4761        85\n",
      "weighted avg     0.4789    0.4824    0.4761        85\n",
      "\n",
      "Current layer:  35\n",
      "Fitting 5 folds for each of 6 candidates, totalling 30 fits\n",
      "LINEAR_SVM best params: {'clf__C': 0.001}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1     0.4231    0.6471    0.5116        17\n",
      "           2     0.4667    0.4118    0.4375        17\n",
      "           3     0.3750    0.3529    0.3636        17\n",
      "           4     0.6923    0.5294    0.6000        17\n",
      "           5     0.6667    0.5882    0.6250        17\n",
      "\n",
      "    accuracy                         0.5059        85\n",
      "   macro avg     0.5247    0.5059    0.5076        85\n",
      "weighted avg     0.5247    0.5059    0.5076        85\n",
      "\n",
      "Fitting 5 folds for each of 4 candidates, totalling 20 fits\n",
      "LR best params: {'clf__C': 0.001, 'clf__penalty': 'l2'}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1     0.4167    0.5882    0.4878        17\n",
      "           2     0.4706    0.4706    0.4706        17\n",
      "           3     0.3636    0.2353    0.2857        17\n",
      "           4     0.5882    0.5882    0.5882        17\n",
      "           5     0.6250    0.5882    0.6061        17\n",
      "\n",
      "    accuracy                         0.4941        85\n",
      "   macro avg     0.4928    0.4941    0.4877        85\n",
      "weighted avg     0.4928    0.4941    0.4877        85\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# try multiple layers and pooling methods\n",
    "\n",
    "for layer in [28,36,30,32,35]:\n",
    "    print(\"Current layer: \", layer)\n",
    "    X_train = featurize_by_indices(train_indices, layers=[layer], pool=\"last\", use_attn=False)\n",
    "    y_train = np.array([s.label for s in train])\n",
    "\n",
    "    X_test = featurize_by_indices(test_indices, layers=[layer], pool=\"last\", use_attn=False)\n",
    "    y_test = np.array([s.label for s in test])\n",
    "\n",
    "    cur_search = train_clf(X_train, y_train, \"linear_svm\")\n",
    "    test_clf(X_test, y_test, cur_search)\n",
    "\n",
    "    cur_search = train_clf(X_train, y_train, \"lr\")\n",
    "    test_clf(X_test, y_test, cur_search)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 4 candidates, totalling 20 fits\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR best params: {'clf__C': 0.001, 'clf__penalty': 'l2'}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1     0.5625    0.5294    0.5455        17\n",
      "           2     0.3333    0.3529    0.3429        17\n",
      "           3     0.4118    0.4118    0.4118        17\n",
      "           4     0.5714    0.4706    0.5161        17\n",
      "           5     0.5000    0.5882    0.5405        17\n",
      "\n",
      "    accuracy                         0.4706        85\n",
      "   macro avg     0.4758    0.4706    0.4713        85\n",
      "weighted avg     0.4758    0.4706    0.4713        85\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# try single layer and pooling method\n",
    "\n",
    "X_train = featurize_by_indices(train_indices, layers=[16], pool=\"mean\", use_attn=False)\n",
    "y_train = np.array([s.label for s in train])\n",
    "\n",
    "X_test = featurize_by_indices(test_indices, layers=[16], pool=\"mean\", use_attn=False)\n",
    "y_test = np.array([s.label for s in test])\n",
    "\n",
    "cur_search = train_clf(X_train, y_train, \"lr\")\n",
    "test_clf(X_test, y_test, cur_search)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### save the best classifier for future use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model + metadata saved to gsm8k_multi_clfs/factuality.pkl\n",
      "Loaded metadata: {'llm': 'Qwen/Qwen3-1.7B', 'dimension': 'factuality', 'classification': 'multi', 'layers': [14, 18], 'pool': 'mean', 'use_attn': False, 'clf_name': 'lr', 'best_params': {'clf__C': 0.001, 'clf__penalty': 'l2'}, 'best_score': np.float64(0.40533360189963064), 'timestamp': '2025-09-04T10:59:16.798647'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'llm': 'Qwen/Qwen3-1.7B',\n",
       " 'dimension': 'factuality',\n",
       " 'classification': 'multi',\n",
       " 'layers': [14, 18],\n",
       " 'pool': 'mean',\n",
       " 'use_attn': False,\n",
       " 'clf_name': 'lr',\n",
       " 'best_params': {'clf__C': 0.001, 'clf__penalty': 'l2'},\n",
       " 'best_score': np.float64(0.40533360189963064),\n",
       " 'timestamp': '2025-09-04T10:59:16.798647'}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "save_model_pickle(cur_search, \"Qwen/Qwen3-1.7B\", \"factuality\", \"multi\", layers=[14,18], pool=\"mean\", use_attn=False, clf_name=\"lr\", clf_path=\"gsm8k_multi_clfs/factuality.pkl\")\n",
    "clf, metadata = load_model_pickle(\"gsm8k_multi_clfs/factuality.pkl\")\n",
    "metadata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model + metadata saved to gsm8k_binary_clfs/factuality.pkl\n",
      "Loaded metadata: {'llm': 'Qwen/Qwen3-1.7B', 'dimension': 'factuality', 'classification': 'binary', 'layers': [16], 'pool': 'mean', 'use_attn': False, 'clf_name': 'lr', 'best_params': {'clf__C': 0.001, 'clf__penalty': 'l2'}, 'best_score': np.float64(0.7617982276129589), 'timestamp': '2025-09-04T11:00:21.438216'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'llm': 'Qwen/Qwen3-1.7B',\n",
       " 'dimension': 'factuality',\n",
       " 'classification': 'binary',\n",
       " 'layers': [16],\n",
       " 'pool': 'mean',\n",
       " 'use_attn': False,\n",
       " 'clf_name': 'lr',\n",
       " 'best_params': {'clf__C': 0.001, 'clf__penalty': 'l2'},\n",
       " 'best_score': np.float64(0.7617982276129589),\n",
       " 'timestamp': '2025-09-04T11:00:21.438216'}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "save_model_pickle(cur_search, \"Qwen/Qwen3-1.7B\", \"factuality\", \"binary\", layers=[16], pool=\"mean\", use_attn=False, clf_name=\"lr\", clf_path=\"gsm8k_binary_clfs/factuality.pkl\")\n",
    "clf, metadata = load_model_pickle(\"gsm8k_binary_clfs/factuality.pkl\")\n",
    "metadata"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Roberta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
      "Detected kernel version 5.4.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training RoBERTa classifier...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      \n",
       "      <progress value='20' max='20' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      [20/20 01:01, Epoch 10/10]\n",
       "    </div>\n",
       "    <table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       " <tr style=\"text-align: left;\">\n",
       "      <th>Epoch</th>\n",
       "      <th>Training Loss</th>\n",
       "      <th>Validation Loss</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.602745</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.602831</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>1.615400</td>\n",
       "      <td>1.602941</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1.615400</td>\n",
       "      <td>1.603091</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>1.629600</td>\n",
       "      <td>1.603232</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>1.629600</td>\n",
       "      <td>1.603425</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>1.629600</td>\n",
       "      <td>1.603977</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>1.611900</td>\n",
       "      <td>1.604656</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>1.611900</td>\n",
       "      <td>1.605502</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>1.625900</td>\n",
       "      <td>1.606578</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table><p>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "Trainer.tokenizer is now deprecated. You should use `Trainer.processing_class = processing_class` instead.\n",
      "Trainer.tokenizer is now deprecated. You should use Trainer.processing_class instead.\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RoBERTa Direct Classification Results for semantic_consistency:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.0000    0.0000    0.0000         7\n",
      "           1     0.0000    0.0000    0.0000         6\n",
      "           2     0.0000    0.0000    0.0000         7\n",
      "           3     0.2059    1.0000    0.3415         7\n",
      "           4     0.0000    0.0000    0.0000         7\n",
      "\n",
      "    accuracy                         0.2059        34\n",
      "   macro avg     0.0412    0.2000    0.0683        34\n",
      "weighted avg     0.0424    0.2059    0.0703        34\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
      "Detected kernel version 5.4.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training RoBERTa classifier...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      \n",
       "      <progress value='10' max='10' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      [10/10 00:45, Epoch 10/10]\n",
       "    </div>\n",
       "    <table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       " <tr style=\"text-align: left;\">\n",
       "      <th>Epoch</th>\n",
       "      <th>Training Loss</th>\n",
       "      <th>Validation Loss</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.605640</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.605623</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.605631</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.605639</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>1.614500</td>\n",
       "      <td>1.605603</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>1.614500</td>\n",
       "      <td>1.605537</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>1.614500</td>\n",
       "      <td>1.605585</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>1.614500</td>\n",
       "      <td>1.605568</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>1.614500</td>\n",
       "      <td>1.605479</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>1.620400</td>\n",
       "      <td>1.604744</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table><p>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "Trainer.tokenizer is now deprecated. You should use `Trainer.processing_class = processing_class` instead.\n",
      "Trainer.tokenizer is now deprecated. You should use Trainer.processing_class instead.\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RoBERTa Direct Classification Results for logicality:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.0000    0.0000    0.0000         5\n",
      "           1     0.0000    0.0000    0.0000         5\n",
      "           2     0.0000    0.0000    0.0000         5\n",
      "           3     0.2308    1.0000    0.3750         6\n",
      "           4     0.0000    0.0000    0.0000         5\n",
      "\n",
      "    accuracy                         0.2308        26\n",
      "   macro avg     0.0462    0.2000    0.0750        26\n",
      "weighted avg     0.0533    0.2308    0.0865        26\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
      "Detected kernel version 5.4.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training RoBERTa classifier...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      \n",
       "      <progress value='20' max='20' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      [20/20 01:03, Epoch 10/10]\n",
       "    </div>\n",
       "    <table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       " <tr style=\"text-align: left;\">\n",
       "      <th>Epoch</th>\n",
       "      <th>Training Loss</th>\n",
       "      <th>Validation Loss</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.627818</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.627166</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>1.616900</td>\n",
       "      <td>1.626056</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1.616900</td>\n",
       "      <td>1.624582</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>1.619600</td>\n",
       "      <td>1.622863</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>1.619600</td>\n",
       "      <td>1.621093</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>1.619600</td>\n",
       "      <td>1.618503</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>1.616300</td>\n",
       "      <td>1.615599</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>1.616300</td>\n",
       "      <td>1.612799</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>1.610100</td>\n",
       "      <td>1.609327</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table><p>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "Trainer.tokenizer is now deprecated. You should use `Trainer.processing_class = processing_class` instead.\n",
      "Trainer.tokenizer is now deprecated. You should use Trainer.processing_class instead.\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RoBERTa Direct Classification Results for informativeness:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.0000    0.0000    0.0000         9\n",
      "           1     0.0000    0.0000    0.0000         9\n",
      "           2     0.0000    0.0000    0.0000         9\n",
      "           3     0.0000    0.0000    0.0000        10\n",
      "           4     0.1957    1.0000    0.3273         9\n",
      "\n",
      "    accuracy                         0.1957        46\n",
      "   macro avg     0.0391    0.2000    0.0655        46\n",
      "weighted avg     0.0383    0.1957    0.0640        46\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
      "Detected kernel version 5.4.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training RoBERTa classifier...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      \n",
       "      <progress value='10' max='10' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      [10/10 00:48, Epoch 10/10]\n",
       "    </div>\n",
       "    <table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       " <tr style=\"text-align: left;\">\n",
       "      <th>Epoch</th>\n",
       "      <th>Training Loss</th>\n",
       "      <th>Validation Loss</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.622752</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.622600</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.622294</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.621831</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>1.615700</td>\n",
       "      <td>1.621216</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>1.615700</td>\n",
       "      <td>1.620315</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>1.615700</td>\n",
       "      <td>1.619361</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>1.615700</td>\n",
       "      <td>1.618293</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>1.615700</td>\n",
       "      <td>1.617138</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>1.609000</td>\n",
       "      <td>1.615821</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table><p>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "Trainer.tokenizer is now deprecated. You should use `Trainer.processing_class = processing_class` instead.\n",
      "Trainer.tokenizer is now deprecated. You should use Trainer.processing_class instead.\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RoBERTa Direct Classification Results for fluency:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.0000    0.0000    0.0000         4\n",
      "           1     0.0000    0.0000    0.0000         3\n",
      "           2     0.0000    0.0000    0.0000         3\n",
      "           3     0.2353    1.0000    0.3810         4\n",
      "           4     0.0000    0.0000    0.0000         3\n",
      "\n",
      "    accuracy                         0.2353        17\n",
      "   macro avg     0.0471    0.2000    0.0762        17\n",
      "weighted avg     0.0554    0.2353    0.0896        17\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
      "Detected kernel version 5.4.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training RoBERTa classifier...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      \n",
       "      <progress value='30' max='30' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      [30/30 01:34, Epoch 10/10]\n",
       "    </div>\n",
       "    <table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       " <tr style=\"text-align: left;\">\n",
       "      <th>Epoch</th>\n",
       "      <th>Training Loss</th>\n",
       "      <th>Validation Loss</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.611909</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>1.607200</td>\n",
       "      <td>1.611670</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>1.607200</td>\n",
       "      <td>1.611142</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1.619400</td>\n",
       "      <td>1.610364</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>1.618200</td>\n",
       "      <td>1.609784</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>1.618200</td>\n",
       "      <td>1.608386</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>1.613100</td>\n",
       "      <td>1.607853</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>1.613100</td>\n",
       "      <td>1.607738</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>1.607700</td>\n",
       "      <td>1.607028</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>1.613000</td>\n",
       "      <td>1.606100</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table><p>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "Trainer.tokenizer is now deprecated. You should use `Trainer.processing_class = processing_class` instead.\n",
      "Trainer.tokenizer is now deprecated. You should use Trainer.processing_class instead.\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RoBERTa Direct Classification Results for factuality:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.0000    0.0000    0.0000        17\n",
      "           1     0.0000    0.0000    0.0000        17\n",
      "           2     0.0000    0.0000    0.0000        17\n",
      "           3     0.0000    0.0000    0.0000        17\n",
      "           4     0.2024    1.0000    0.3366        17\n",
      "\n",
      "    accuracy                         0.2000        85\n",
      "   macro avg     0.0405    0.2000    0.0673        85\n",
      "weighted avg     0.0405    0.2000    0.0673        85\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "from transformers import (\n",
    "    AutoTokenizer, \n",
    "    AutoModelForSequenceClassification, \n",
    "    TrainingArguments, \n",
    "    Trainer,\n",
    "    AutoModelForCausalLM\n",
    ")\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import classification_report, accuracy_score\n",
    "import json\n",
    "from torch.utils.data import Dataset\n",
    "\n",
    "# Device setup\n",
    "torch.mps.empty_cache() if torch.backends.mps.is_available() else None\n",
    "\n",
    "class ClassificationDataset(Dataset):\n",
    "    def __init__(self, texts, labels, tokenizer, max_length=512):\n",
    "        self.texts = texts\n",
    "        self.labels = labels\n",
    "        self.tokenizer = tokenizer\n",
    "        self.max_length = max_length\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.texts)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        text = str(self.texts[idx])\n",
    "        label = self.labels[idx]\n",
    "\n",
    "        encoding = self.tokenizer(\n",
    "            text,\n",
    "            truncation=True,\n",
    "            padding='max_length',\n",
    "            max_length=self.max_length,\n",
    "            return_tensors='pt'\n",
    "        )\n",
    "\n",
    "        return {\n",
    "            'input_ids': encoding['input_ids'].flatten(),\n",
    "            'attention_mask': encoding['attention_mask'].flatten(),\n",
    "            'labels': torch.tensor(label, dtype=torch.long)\n",
    "        }\n",
    "\n",
    "def train_roberta_classifier(train_texts, train_labels, val_texts, val_labels, num_labels, dim):\n",
    "    \"\"\"\n",
    "    Train RoBERTa as a direct classifier for your task\n",
    "    \"\"\"\n",
    "    # Initialize model and tokenizer\n",
    "    model_name = \"roberta-base\"\n",
    "    tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
    "    model = AutoModelForSequenceClassification.from_pretrained(\n",
    "        model_name, \n",
    "        num_labels=num_labels\n",
    "    )\n",
    "    \n",
    "    # Create datasets\n",
    "    train_dataset = ClassificationDataset(train_texts, train_labels, tokenizer)\n",
    "    val_dataset = ClassificationDataset(val_texts, val_labels, tokenizer)\n",
    "    \n",
    "    # Training arguments\n",
    "    training_args = TrainingArguments(\n",
    "        output_dir=f'checkpoints/roberta_classifier/{dim}',\n",
    "        num_train_epochs=10,\n",
    "        per_device_train_batch_size=16,\n",
    "        per_device_eval_batch_size=16,\n",
    "        warmup_steps=100,\n",
    "        weight_decay=0.01,\n",
    "        logging_dir='./logs',\n",
    "        logging_steps=5,\n",
    "        eval_strategy=\"epoch\",\n",
    "        save_strategy=\"epoch\",\n",
    "        load_best_model_at_end=True,\n",
    "        save_total_limit=2,\n",
    "        metric_for_best_model=\"eval_loss\",\n",
    "        greater_is_better=False,\n",
    "        report_to=None\n",
    "    )\n",
    "    \n",
    "    # Initialize trainer\n",
    "    trainer = Trainer(\n",
    "        model=model,\n",
    "        args=training_args,\n",
    "        train_dataset=train_dataset,\n",
    "        eval_dataset=val_dataset,\n",
    "    )\n",
    "    \n",
    "    # Train the model\n",
    "    print(\"Training RoBERTa classifier...\")\n",
    "    trainer.train()\n",
    "    trainer.tokenizer = tokenizer\n",
    "    \n",
    "    return trainer\n",
    "\n",
    "def evaluate_roberta_classifier(trainer, test_texts, test_labels, tokenizer, dim):\n",
    "    \"\"\"\n",
    "    Evaluate the trained RoBERTa classifier\n",
    "    \"\"\"\n",
    "    test_dataset = ClassificationDataset(test_texts, test_labels, tokenizer)\n",
    "    \n",
    "    # Get predictions\n",
    "    predictions = trainer.predict(test_dataset)\n",
    "    pred_labels = np.argmax(predictions.predictions, axis=1)\n",
    "    \n",
    "    # Calculate metrics\n",
    "    accuracy = accuracy_score(test_labels, pred_labels)\n",
    "    \n",
    "    print(f\"RoBERTa Direct Classification Results for {dim}:\")\n",
    "    # print(f\"Accuracy: {accuracy:.4f}\")\n",
    "    print(classification_report(test_labels, pred_labels, digits=4))\n",
    "\n",
    "\n",
    "# Simplified version if you want to quickly test RoBERTa\n",
    "def quick_roberta_baseline(dim):\n",
    "    \"\"\"\n",
    "    Quick version to test RoBERTa on your exact data\n",
    "    \"\"\"\n",
    "    # Load your data\n",
    "    clf_dataset = []\n",
    "    with open('Meta-Llama-3-8B-Instruct_gsm8k_roscoe5dim_probing.json', 'r') as f:\n",
    "        for sample in json.load(f)[dim]:\n",
    "            clf_dataset.append({\n",
    "                'text': sample['eval_prompt'], \n",
    "                # 'label': 1 if sample['score']>3 else 0  # binary class\n",
    "                'label': sample['score'] - 1  # Convert to 0-indexed\n",
    "            })\n",
    "    \n",
    "    # Split data\n",
    "    train_test_split_data = train_test_split(\n",
    "        [item['text'] for item in clf_dataset],\n",
    "        [item['label'] for item in clf_dataset],\n",
    "        test_size=0.20,\n",
    "        stratify=[item['label'] for item in clf_dataset],\n",
    "        random_state=42\n",
    "    )\n",
    "    \n",
    "    train_texts, test_texts, train_labels, test_labels = train_test_split_data\n",
    "    \n",
    "    # Further split for validation\n",
    "    train_texts, val_texts, train_labels, val_labels = train_test_split(\n",
    "        train_texts, train_labels, test_size=0.2, stratify=train_labels, random_state=42\n",
    "    )\n",
    "    \n",
    "    num_labels = len(set(train_labels))\n",
    "    \n",
    "    # Train and evaluate\n",
    "    trainer = train_roberta_classifier(train_texts, train_labels, val_texts, val_labels, num_labels, dim)\n",
    "    results = evaluate_roberta_classifier(trainer, test_texts, test_labels, trainer.tokenizer, dim)\n",
    "    \n",
    "    return results\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    for dim in ['semantic_consistency', 'logicality', 'informativeness', 'fluency', 'factuality']:\n",
    "        quick_roberta_baseline(dim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "prob",
   "language": "python",
   "name": "python3"
  },
  "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.18"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}