{
 "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\"] = \"1,2,3\""
   ]
  },
  {
   "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",
      "Loading checkpoint shards: 100%|██████████| 2/2 [00:00<00:00,  3.22it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Qwen3ForCausalLM(\n",
       "  (model): Qwen3Model(\n",
       "    (embed_tokens): Embedding(151936, 2048)\n",
       "    (layers): ModuleList(\n",
       "      (0-27): 28 x Qwen3DecoderLayer(\n",
       "        (self_attn): Qwen3Attention(\n",
       "          (q_proj): Linear(in_features=2048, out_features=2048, bias=False)\n",
       "          (k_proj): Linear(in_features=2048, out_features=1024, bias=False)\n",
       "          (v_proj): Linear(in_features=2048, out_features=1024, bias=False)\n",
       "          (o_proj): Linear(in_features=2048, out_features=2048, bias=False)\n",
       "          (q_norm): Qwen3RMSNorm((128,), eps=1e-06)\n",
       "          (k_norm): Qwen3RMSNorm((128,), eps=1e-06)\n",
       "        )\n",
       "        (mlp): Qwen3MLP(\n",
       "          (gate_proj): Linear(in_features=2048, out_features=6144, bias=False)\n",
       "          (up_proj): Linear(in_features=2048, out_features=6144, bias=False)\n",
       "          (down_proj): Linear(in_features=6144, out_features=2048, bias=False)\n",
       "          (act_fn): SiLU()\n",
       "        )\n",
       "        (input_layernorm): Qwen3RMSNorm((2048,), eps=1e-06)\n",
       "        (post_attention_layernorm): Qwen3RMSNorm((2048,), eps=1e-06)\n",
       "      )\n",
       "    )\n",
       "    (norm): Qwen3RMSNorm((2048,), eps=1e-06)\n",
       "    (rotary_emb): Qwen3RotaryEmbedding()\n",
       "  )\n",
       "  (lm_head): Linear(in_features=2048, out_features=151936, 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",
    "model_name = \"Qwen/Qwen3-1.7B\"\n",
    "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
    "if tokenizer.pad_token is None:\n",
    "        tokenizer.pad_token = tokenizer.eos_token\n",
    "\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": [
      "170\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Counter({2: 34, 4: 34, 3: 34, 5: 34, 1: 34})"
      ]
     },
     "execution_count": 16,
     "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_math_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['factuality']:       # 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%|██████████| 170/170 [00:14<00:00, 11.71it/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('math_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('math_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": 18,
   "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 28 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",
      "Layer 16...\n",
      "Layer 17...\n",
      "Layer 18...\n",
      "Layer 19...\n",
      "Layer 20...\n",
      "Layer 21...\n",
      "Layer 22...\n",
      "Layer 23...\n",
      "Layer 24...\n",
      "Layer 25...\n",
      "Layer 26...\n",
      "Layer 27...\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    14     mean   pca        0.800±0.054 0.365±0.061 0.372\n",
      "2    15     mean   pca        0.800±0.051 0.347±0.075 0.380\n",
      "3    16     mean   pca        0.800±0.054 0.300±0.047 0.384\n",
      "4    19     mean   pca        0.800±0.063 0.365±0.061 0.371\n",
      "5    13     mean   pca        0.782±0.061 0.341±0.030 0.370\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    27     mean   pca        0.735±0.059 0.394±0.044 -0.290\n",
      "2    25     mean   pca        0.741±0.092 0.388±0.047 -0.350\n",
      "3    22     mean   pca        0.729±0.043 0.382±0.077 0.350\n",
      "4    24     mean   pca        0.747±0.063 0.382±0.059 0.347\n",
      "5    26     mean   attention  0.612±0.047 0.382±0.049 -0.290\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_math_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": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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",
      "           0     0.7619    0.8000    0.7805        20\n",
      "           1     0.6923    0.6429    0.6667        14\n",
      "\n",
      "    accuracy                         0.7353        34\n",
      "   macro avg     0.7271    0.7214    0.7236        34\n",
      "weighted avg     0.7332    0.7353    0.7336        34\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",
      "           0     0.7500    0.7500    0.7500        20\n",
      "           1     0.6429    0.6429    0.6429        14\n",
      "\n",
      "    accuracy                         0.7059        34\n",
      "   macro avg     0.6964    0.6964    0.6964        34\n",
      "weighted avg     0.7059    0.7059    0.7059        34\n",
      "\n",
      "Current layer:  26\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",
      "           0     0.7273    0.8000    0.7619        20\n",
      "           1     0.6667    0.5714    0.6154        14\n",
      "\n",
      "    accuracy                         0.7059        34\n",
      "   macro avg     0.6970    0.6857    0.6886        34\n",
      "weighted avg     0.7023    0.7059    0.7016        34\n",
      "\n",
      "Fitting 5 folds for each of 4 candidates, totalling 20 fits\n",
      "LR best params: {'clf__C': 0.1, 'clf__penalty': 'l2'}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.7619    0.8000    0.7805        20\n",
      "           1     0.6923    0.6429    0.6667        14\n",
      "\n",
      "    accuracy                         0.7353        34\n",
      "   macro avg     0.7271    0.7214    0.7236        34\n",
      "weighted avg     0.7332    0.7353    0.7336        34\n",
      "\n",
      "Current layer:  31\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",
      "           0     0.7619    0.8000    0.7805        20\n",
      "           1     0.6923    0.6429    0.6667        14\n",
      "\n",
      "    accuracy                         0.7353        34\n",
      "   macro avg     0.7271    0.7214    0.7236        34\n",
      "weighted avg     0.7332    0.7353    0.7336        34\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",
      "           0     0.7500    0.7500    0.7500        20\n",
      "           1     0.6429    0.6429    0.6429        14\n",
      "\n",
      "    accuracy                         0.7059        34\n",
      "   macro avg     0.6964    0.6964    0.6964        34\n",
      "weighted avg     0.7059    0.7059    0.7059        34\n",
      "\n",
      "Current layer:  38\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",
      "           0     0.7727    0.8500    0.8095        20\n",
      "           1     0.7500    0.6429    0.6923        14\n",
      "\n",
      "    accuracy                         0.7647        34\n",
      "   macro avg     0.7614    0.7464    0.7509        34\n",
      "weighted avg     0.7634    0.7647    0.7613        34\n",
      "\n",
      "Fitting 5 folds for each of 4 candidates, totalling 20 fits\n",
      "LR best params: {'clf__C': 0.01, 'clf__penalty': 'l2'}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.7619    0.8000    0.7805        20\n",
      "           1     0.6923    0.6429    0.6667        14\n",
      "\n",
      "    accuracy                         0.7353        34\n",
      "   macro avg     0.7271    0.7214    0.7236        34\n",
      "weighted avg     0.7332    0.7353    0.7336        34\n",
      "\n",
      "Current layer:  24\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",
      "           0     0.7083    0.8500    0.7727        20\n",
      "           1     0.7000    0.5000    0.5833        14\n",
      "\n",
      "    accuracy                         0.7059        34\n",
      "   macro avg     0.7042    0.6750    0.6780        34\n",
      "weighted avg     0.7049    0.7059    0.6947        34\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",
      "           0     0.7727    0.8500    0.8095        20\n",
      "           1     0.7500    0.6429    0.6923        14\n",
      "\n",
      "    accuracy                         0.7647        34\n",
      "   macro avg     0.7614    0.7464    0.7509        34\n",
      "weighted avg     0.7634    0.7647    0.7613        34\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for layer in [30,26,31,38,24]:\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": "markdown",
   "metadata": {},
   "source": [
    "#### save the best classifier for future use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model + metadata saved to math_multi_clfs/logicality.pkl\n",
      "Loaded metadata: {'llm': 'Qwen/Qwen3-1.7B', 'dimension': 'logicality', 'classification': 'multi', 'layers': [26, 27], 'pool': 'last', 'use_attn': False, 'clf_name': 'linear_svm', 'best_params': {'clf__C': 0.001}, 'best_score': np.float64(0.5551046681489854), 'timestamp': '2025-09-06T22:21:45.153936'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'llm': 'Qwen/Qwen3-1.7B',\n",
       " 'dimension': 'logicality',\n",
       " 'classification': 'multi',\n",
       " 'layers': [26, 27],\n",
       " 'pool': 'last',\n",
       " 'use_attn': False,\n",
       " 'clf_name': 'linear_svm',\n",
       " 'best_params': {'clf__C': 0.001},\n",
       " 'best_score': np.float64(0.5551046681489854),\n",
       " 'timestamp': '2025-09-06T22:21:45.153936'}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "save_model_pickle(cur_search, \"Qwen/Qwen3-1.7B\", \"logicality\", \"multi\", layers=[26,27], pool=\"last\", use_attn=False, clf_name=\"linear_svm\", clf_path=\"math_multi_clfs/logicality.pkl\")\n",
    "clf, metadata = load_model_pickle(\"math_multi_clfs/logicality.pkl\")\n",
    "metadata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model + metadata saved to math_binary_clfs/factuality.pkl\n",
      "Loaded metadata: {'llm': 'Qwen/Qwen3-1.7B', 'dimension': 'factuality', 'classification': 'binary', 'layers': [15], 'pool': 'mean', 'use_attn': False, 'clf_name': 'lr', 'best_params': {'clf__C': 0.1, 'clf__penalty': 'l2'}, 'best_score': np.float64(0.8556211421199873), 'timestamp': '2025-09-04T20:11:26.841961'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'llm': 'Qwen/Qwen3-1.7B',\n",
       " 'dimension': 'factuality',\n",
       " 'classification': 'binary',\n",
       " 'layers': [15],\n",
       " 'pool': 'mean',\n",
       " 'use_attn': False,\n",
       " 'clf_name': 'lr',\n",
       " 'best_params': {'clf__C': 0.1, 'clf__penalty': 'l2'},\n",
       " 'best_score': np.float64(0.8556211421199873),\n",
       " 'timestamp': '2025-09-04T20:11:26.841961'}"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "save_model_pickle(cur_search, \"Qwen/Qwen3-1.7B\", \"factuality\", \"binary\", layers=[15], pool=\"mean\", use_attn=False, clf_name=\"lr\", clf_path=\"math_binary_clfs/factuality.pkl\")\n",
    "clf, metadata = load_model_pickle(\"math_binary_clfs/factuality.pkl\")\n",
    "metadata"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Roberta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/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",
      "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": [
      "[2025-08-26 02:53:10,386] [INFO] [real_accelerator.py:219:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n",
      "Warning: The cache directory for DeepSpeed Triton autotune, /home/zhangyong203/.triton/autotune, appears to be on an NFS system. While this is generally acceptable, if you experience slowdowns or hanging when DeepSpeed exits, it is recommended to set the TRITON_CACHE_DIR environment variable to a non-NFS path.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/compiler_compat/ld: cannot find -laio: No such file or directory\n",
      "collect2: error: ld returned 1 exit status\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/compiler_compat/ld: cannot find -lcufile: No such file or directory\n",
      "collect2: error: ld returned 1 exit status\n",
      "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mzhuochun\u001b[0m (\u001b[33mzhuochun-university-of-pittsburgh\u001b[0m) to \u001b[32mhttps://api.wandb.ai\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training RoBERTa classifier...\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "Tracking run with wandb version 0.21.0"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "Run data is saved locally in <code>/home/zhangyong203/eval_probing/wandb/run-20250826_025311-gthclgz7</code>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "Syncing run <strong><a href='https://wandb.ai/zhuochun-university-of-pittsburgh/huggingface/runs/gthclgz7' target=\"_blank\">restful-waterfall-113</a></strong> to <a href='https://wandb.ai/zhuochun-university-of-pittsburgh/huggingface' target=\"_blank\">Weights & Biases</a> (<a href='https://wandb.me/developer-guide' target=\"_blank\">docs</a>)<br>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       " View project at <a href='https://wandb.ai/zhuochun-university-of-pittsburgh/huggingface' target=\"_blank\">https://wandb.ai/zhuochun-university-of-pittsburgh/huggingface</a>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       " View run at <a href='https://wandb.ai/zhuochun-university-of-pittsburgh/huggingface/runs/gthclgz7' target=\"_blank\">https://wandb.ai/zhuochun-university-of-pittsburgh/huggingface/runs/gthclgz7</a>"
      ],
      "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"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      \n",
       "      <progress value='40' max='40' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      [40/40 01:39, 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.610928</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>1.610600</td>\n",
       "      <td>1.610168</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>1.615400</td>\n",
       "      <td>1.609136</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1.608000</td>\n",
       "      <td>1.607437</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>1.620500</td>\n",
       "      <td>1.605318</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>1.620500</td>\n",
       "      <td>1.602301</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>1.605200</td>\n",
       "      <td>1.595293</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>1.608300</td>\n",
       "      <td>1.582224</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>1.592700</td>\n",
       "      <td>1.545626</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>1.568200</td>\n",
       "      <td>1.501565</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.2899    0.8333    0.4301        24\n",
      "           1     0.0000    0.0000    0.0000        24\n",
      "           2     0.2222    0.0833    0.1212        24\n",
      "           3     0.0000    0.0000    0.0000        25\n",
      "           4     0.4390    0.7500    0.5538        24\n",
      "\n",
      "    accuracy                         0.3306       121\n",
      "   macro avg     0.1902    0.3333    0.2210       121\n",
      "weighted avg     0.1886    0.3306    0.2192       121\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:27, 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.611871</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>1.616600</td>\n",
       "      <td>1.611329</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>1.616600</td>\n",
       "      <td>1.610387</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1.624500</td>\n",
       "      <td>1.609175</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>1.603400</td>\n",
       "      <td>1.608017</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>1.603400</td>\n",
       "      <td>1.606394</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>1.602600</td>\n",
       "      <td>1.603546</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>1.602600</td>\n",
       "      <td>1.599833</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>1.601600</td>\n",
       "      <td>1.594279</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>1.593900</td>\n",
       "      <td>1.583364</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.4857    0.8500    0.6182        20\n",
      "           1     0.2500    0.6842    0.3662        19\n",
      "           2     0.0000    0.0000    0.0000        20\n",
      "           3     0.0000    0.0000    0.0000        20\n",
      "           4     0.4545    0.2632    0.3333        19\n",
      "\n",
      "    accuracy                         0.3571        98\n",
      "   macro avg     0.2381    0.3595    0.2635        98\n",
      "weighted avg     0.2357    0.3571    0.2618        98\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:18, 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.616724</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.616432</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>1.618100</td>\n",
       "      <td>1.615998</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1.618100</td>\n",
       "      <td>1.615524</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>1.615100</td>\n",
       "      <td>1.614739</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>1.615100</td>\n",
       "      <td>1.613563</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>1.615100</td>\n",
       "      <td>1.612356</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>1.613600</td>\n",
       "      <td>1.611133</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>1.613600</td>\n",
       "      <td>1.609640</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>1.605500</td>\n",
       "      <td>1.608153</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        15\n",
      "           1     0.0000    0.0000    0.0000        15\n",
      "           2     0.0000    0.0000    0.0000        15\n",
      "           3     0.1918    0.9333    0.3182        15\n",
      "           4     0.5000    0.0667    0.1176        15\n",
      "\n",
      "    accuracy                         0.2000        75\n",
      "   macro avg     0.1384    0.2000    0.0872        75\n",
      "weighted avg     0.1384    0.2000    0.0872        75\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:54, 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.600483</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.600487</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.600438</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.600438</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>1.612900</td>\n",
       "      <td>1.600410</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>1.612900</td>\n",
       "      <td>1.600367</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>1.612900</td>\n",
       "      <td>1.600342</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>1.612900</td>\n",
       "      <td>1.599963</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>1.612900</td>\n",
       "      <td>1.599905</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>1.614500</td>\n",
       "      <td>1.599849</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         6\n",
      "           1     0.0000    0.0000    0.0000         5\n",
      "           2     0.0000    0.0000    0.0000         5\n",
      "           3     0.2222    1.0000    0.3636         6\n",
      "           4     0.0000    0.0000    0.0000         5\n",
      "\n",
      "    accuracy                         0.2222        27\n",
      "   macro avg     0.0444    0.2000    0.0727        27\n",
      "weighted avg     0.0494    0.2222    0.0808        27\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:55, 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.607676</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.607648</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.607604</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>No log</td>\n",
       "      <td>1.607520</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>1.619600</td>\n",
       "      <td>1.607404</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>1.619600</td>\n",
       "      <td>1.607291</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>1.619600</td>\n",
       "      <td>1.607185</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>1.619600</td>\n",
       "      <td>1.607052</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>1.619600</td>\n",
       "      <td>1.606945</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>1.623400</td>\n",
       "      <td>1.606806</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         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": [
      "/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",
    "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",
    "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_math_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)"
   ]
  }
 ],
 "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
}