global.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from io import StringIO\n",
    "from tqdm import tqdm\n",
    "from pathlib import Path\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy import stats\n",
    "\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "from torch.optim import AdamW\n",
    "from torch.utils.data import Dataset, DataLoader, random_split\n",
    "\n",
    "torch.set_default_dtype(torch.float64)\n",
    "# torch.manual_seed(42)\n",
    "device = \"cpu\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from erisk import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from google.colab import drive\n",
    "# drive.mount('/content/drive')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install --upgrade pandas transformers -q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !unzip datasets.zip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyReg(nn.Module):\n",
    "    def __init__(self, input_size):\n",
    "        super().__init__()\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(input_size, 1),\n",
    "            nn.ReLU(),\n",
    "            # nn.LogSoftmax(),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.layers(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EarlyStopping:\n",
    "    def __init__(self, tolerance=5, min_delta=.001, max_beta=.1):\n",
    "\n",
    "        self.tolerance = tolerance\n",
    "        self.min_delta = min_delta\n",
    "        self.max_beta = max_beta\n",
    "\n",
    "        self.counter = 0\n",
    "        self.early_stop = False\n",
    "\n",
    "    def __call__(self, val_losses, train_loss=None):\n",
    "\n",
    "        if len(val_losses) < 2:\n",
    "            return\n",
    "\n",
    "        curr, prev = val_losses[-1], val_losses[-2]\n",
    "        is_delta = (\n",
    "            (prev - curr) < self.min_delta\n",
    "        )\n",
    "        is_beta = (\n",
    "            (curr - train_loss) > self.max_beta\n",
    "        )\n",
    "\n",
    "        if is_beta or is_delta:\n",
    "            self.counter += 1\n",
    "\n",
    "        if self.counter >= self.tolerance:\n",
    "            self.early_stop = True\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyTrainer:\n",
    "    def __init__(self, dataset, input_size, batch_size=32) -> None:\n",
    "        self.train_losses = list()\n",
    "        self.val_losses = list()\n",
    "        self.batch_size = batch_size\n",
    "        self.load_data(dataset)\n",
    "\n",
    "        self.model = MyReg(input_size=input_size)\n",
    "        # self.lossf = nn.CrossEntropyLoss()\n",
    "        self.lossf = nn.L1Loss()\n",
    "        self.optif = AdamW(\n",
    "            self.model.parameters(),\n",
    "            lr=1e-3,\n",
    "        )\n",
    "        # self.optif = torch.optim.SGD(\n",
    "        #     self.model.parameters(),\n",
    "        #     lr=1e-3,\n",
    "        #     momentum=0.9,\n",
    "        # )\n",
    "\n",
    "    def load_data(self, dataset):\n",
    "        train_dt, val_dt, test_dt = random_split(dataset, [0.6, 0.2, 0.2])\n",
    "        self._train_dl = DataLoader(\n",
    "            train_dt,\n",
    "            batch_size=self.batch_size,\n",
    "            shuffle=True,\n",
    "        )\n",
    "\n",
    "        self._val_dl = DataLoader(val_dt, shuffle=True)\n",
    "        self._test_dl = DataLoader(test_dt, shuffle=True)\n",
    "\n",
    "    def _train_one(self):\n",
    "        epoch_loss = 0.0\n",
    "        for _, data in enumerate(self._train_dl):\n",
    "            inputs, targets = data\n",
    "            outputs = self.model(inputs)\n",
    "\n",
    "            self.optif.zero_grad()\n",
    "            batch_loss = self.lossf(outputs[:, 0], targets)\n",
    "            batch_loss.backward()\n",
    "            self.optif.step()\n",
    "\n",
    "            epoch_loss += batch_loss.item()\n",
    "        return epoch_loss / len(self._train_dl)\n",
    "\n",
    "    def _val_one(self):\n",
    "        epoch_loss = 0.0\n",
    "        for _, data in enumerate(self._val_dl):\n",
    "            inputs, target = data\n",
    "            outputs = self.model(inputs)\n",
    "\n",
    "            loss = self.lossf(outputs[:, 0], target)\n",
    "            epoch_loss += loss.item()\n",
    "        return epoch_loss / len(self._val_dl)\n",
    "\n",
    "    def fit(self, epochs=1, early_stopping=None):\n",
    "        for epoch in range(epochs):\n",
    "            t_loss = self._train_one()\n",
    "            self.train_losses.append(t_loss)\n",
    "\n",
    "            self.model.eval()\n",
    "\n",
    "            v_loss = self._val_one()\n",
    "            self.val_losses.append(v_loss)\n",
    "            print(f\"validation loss {v_loss:.3f} at epoch {epoch}\")\n",
    "\n",
    "            # early stopping\n",
    "            if early_stopping is not None:\n",
    "                early_stopping(self.val_losses, t_loss)\n",
    "                if early_stopping.early_stop:\n",
    "                    print(f\"early stopping...\")\n",
    "                    break\n",
    "\n",
    "    def gasp(self):\n",
    "        return [(self.model(inputs).item(), target.item()) for inputs, target in self._test_dl]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loading and mergin dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_text = \"\"\n",
    "\n",
    "for filename in sorted([\"ds\", \"ts_hs\", \"ts_ht\"]):\n",
    "    with open(\n",
    "        Path(\"datasets\", \"task_0\", f\"{filename}.tsv\"), \"rt\", encoding=\"utf8\"\n",
    "    ) as f:\n",
    "        data_text += f.read()\n",
    "\n",
    "df = pd.read_csv(StringIO(data_text), sep=\"\\t\")\n",
    "df = df.drop_duplicates().reset_index(names=\"old_idx\").reset_index(names=\"new_idx\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.label = df.label.astype(int)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### lex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import liwc\n",
    "to_liwc, categories = liwc.load_token_parser('dic/LIWC2007_English080730.dic')\n",
    "K = len(categories)\n",
    "\n",
    "kat_lookup = dict(zip(categories, range(K)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LexDataset(Dataset):\n",
    "    def __init__(self, df, x_col=\"pp_text\", y_col=\"label\"):\n",
    "        self.df = df\n",
    "        self.x_col = x_col\n",
    "        self.y_col = y_col\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.df)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        counter = {k: 0 for k in categories}\n",
    "        for word in self.df.loc[idx, self.x_col].split():\n",
    "            for k in list(to_liwc(word)):\n",
    "                counter[k] += 1\n",
    "        X = (\n",
    "            np.array([counter[k] for k in categories]) / sum(counter.values())\n",
    "            if sum(counter.values())\n",
    "            else np.zeros(K)\n",
    "        )\n",
    "        # y = np.zeros(2)\n",
    "        # y[self.df.loc[idx, self.y_col]] = 1\n",
    "        y = self.df.loc[idx, self.y_col]\n",
    "\n",
    "        return X, y\n",
    "\n",
    "    def __iter__(self):\n",
    "        self.a = 0\n",
    "        return self\n",
    "\n",
    "    def __next__(self):\n",
    "        if self.a < len(self):\n",
    "            value = self[self.a]\n",
    "            self.a += 1\n",
    "            return value\n",
    "        else:\n",
    "            raise StopIteration\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds_lex = LexDataset(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_lex, y_lex = zip(*ds_lex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "validation loss 0.473 at epoch 0\n",
      "validation loss 0.468 at epoch 1\n",
      "validation loss 0.463 at epoch 2\n",
      "validation loss 0.458 at epoch 3\n",
      "validation loss 0.453 at epoch 4\n",
      "validation loss 0.448 at epoch 5\n",
      "validation loss 0.443 at epoch 6\n",
      "validation loss 0.438 at epoch 7\n",
      "validation loss 0.433 at epoch 8\n",
      "validation loss 0.428 at epoch 9\n",
      "validation loss 0.424 at epoch 10\n",
      "validation loss 0.419 at epoch 11\n",
      "validation loss 0.415 at epoch 12\n",
      "validation loss 0.412 at epoch 13\n",
      "validation loss 0.408 at epoch 14\n",
      "validation loss 0.406 at epoch 15\n",
      "validation loss 0.403 at epoch 16\n",
      "validation loss 0.401 at epoch 17\n",
      "validation loss 0.399 at epoch 18\n",
      "validation loss 0.397 at epoch 19\n",
      "validation loss 0.396 at epoch 20\n",
      "validation loss 0.394 at epoch 21\n",
      "validation loss 0.393 at epoch 22\n",
      "validation loss 0.392 at epoch 23\n",
      "validation loss 0.391 at epoch 24\n",
      "validation loss 0.390 at epoch 25\n",
      "validation loss 0.389 at epoch 26\n",
      "validation loss 0.388 at epoch 27\n",
      "validation loss 0.387 at epoch 28\n",
      "validation loss 0.386 at epoch 29\n",
      "validation loss 0.385 at epoch 30\n",
      "validation loss 0.385 at epoch 31\n",
      "validation loss 0.384 at epoch 32\n",
      "validation loss 0.383 at epoch 33\n",
      "validation loss 0.383 at epoch 34\n",
      "validation loss 0.382 at epoch 35\n",
      "validation loss 0.382 at epoch 36\n",
      "validation loss 0.381 at epoch 37\n",
      "validation loss 0.380 at epoch 38\n",
      "validation loss 0.380 at epoch 39\n",
      "validation loss 0.380 at epoch 40\n",
      "validation loss 0.379 at epoch 41\n",
      "validation loss 0.379 at epoch 42\n",
      "validation loss 0.378 at epoch 43\n",
      "validation loss 0.378 at epoch 44\n",
      "validation loss 0.377 at epoch 45\n",
      "validation loss 0.377 at epoch 46\n",
      "validation loss 0.377 at epoch 47\n",
      "validation loss 0.377 at epoch 48\n",
      "validation loss 0.376 at epoch 49\n",
      "validation loss 0.376 at epoch 50\n",
      "validation loss 0.376 at epoch 51\n",
      "validation loss 0.376 at epoch 52\n",
      "validation loss 0.375 at epoch 53\n",
      "validation loss 0.375 at epoch 54\n",
      "validation loss 0.375 at epoch 55\n",
      "validation loss 0.375 at epoch 56\n",
      "validation loss 0.375 at epoch 57\n",
      "validation loss 0.374 at epoch 58\n",
      "validation loss 0.374 at epoch 59\n",
      "validation loss 0.374 at epoch 60\n",
      "validation loss 0.374 at epoch 61\n",
      "validation loss 0.374 at epoch 62\n",
      "validation loss 0.374 at epoch 63\n",
      "validation loss 0.374 at epoch 64\n",
      "validation loss 0.373 at epoch 65\n",
      "validation loss 0.373 at epoch 66\n",
      "validation loss 0.373 at epoch 67\n",
      "validation loss 0.373 at epoch 68\n",
      "validation loss 0.373 at epoch 69\n",
      "validation loss 0.373 at epoch 70\n",
      "validation loss 0.373 at epoch 71\n",
      "validation loss 0.373 at epoch 72\n",
      "validation loss 0.373 at epoch 73\n",
      "validation loss 0.373 at epoch 74\n",
      "validation loss 0.373 at epoch 75\n",
      "validation loss 0.372 at epoch 76\n",
      "validation loss 0.372 at epoch 77\n",
      "validation loss 0.372 at epoch 78\n",
      "validation loss 0.372 at epoch 79\n",
      "validation loss 0.372 at epoch 80\n",
      "validation loss 0.372 at epoch 81\n",
      "validation loss 0.372 at epoch 82\n",
      "validation loss 0.372 at epoch 83\n",
      "validation loss 0.372 at epoch 84\n",
      "validation loss 0.372 at epoch 85\n",
      "validation loss 0.372 at epoch 86\n",
      "validation loss 0.372 at epoch 87\n",
      "validation loss 0.372 at epoch 88\n",
      "validation loss 0.372 at epoch 89\n",
      "validation loss 0.372 at epoch 90\n",
      "validation loss 0.372 at epoch 91\n",
      "validation loss 0.371 at epoch 92\n",
      "validation loss 0.372 at epoch 93\n",
      "early stopping...\n"
     ]
    }
   ],
   "source": [
    "trainer = MyTrainer(ds_lex, 64)\n",
    "trainer.fit(\n",
    "    epochs=100,\n",
    "    early_stopping=EarlyStopping(\n",
    "        tolerance=4,\n",
    "        min_delta=0.0,\n",
    "        max_beta=0.1,\n",
    "    ),\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot: >"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.lineplot(trainer.train_losses)\n",
    "sns.lineplot(trainer.val_losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "xi_weights = trainer.model.layers[0].weight[0].detach().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_hat, y_true = list(zip(*trainer.gasp()))\n",
    "y_hat = [1 if e>0.5 else 0 for e in y_hat]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1: 0.72\n",
      "Precision: 0.71\n",
      "Recall: 0.73\n",
      "Accuracy: 0.72\n"
     ]
    }
   ],
   "source": [
    "metrics(y_hat, y_true)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### born lex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from bornrule import BornClassifier\n",
    "from collections import defaultdict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    X_lex,\n",
    "    y_lex,\n",
    "    test_size=0.2,\n",
    "    random_state=42,\n",
    "    stratify=y_lex,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "amplitude = 0.5 #amplitude\n",
    "balance = 1 #balance\n",
    "entropy = 1 #entropy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {color: black;background-color: white;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>BornClassifier(b=1, h=1)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">BornClassifier</label><div class=\"sk-toggleable__content\"><pre>BornClassifier(b=1, h=1)</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "BornClassifier(b=1, h=1)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "born = BornClassifier(a=amplitude, b=balance, h=entropy)\n",
    "born.fit(X=X_train, y=y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1: 0.63\n",
      "Precision: 0.65\n",
      "Recall: 0.62\n",
      "Accuracy: 0.65\n"
     ]
    }
   ],
   "source": [
    "y_hat = born.predict(X_test)\n",
    "metrics(y_hat, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "born.classes_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "weights = born.explain()[:,1]\n",
    "scores = sorted(list(zip(categories, weights)), key = lambda x : x[-1], reverse=True)\n",
    "kwscores = defaultdict(float, scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('i', 0.012541492481592243),\n",
       " ('work', 0.011617812255721238),\n",
       " ('assent', 0.007522012568021944),\n",
       " ('sad', 0.007463258446255146),\n",
       " ('health', 0.006889467324162289),\n",
       " ('leisure', 0.0057710508860062786),\n",
       " ('ppron', 0.00560310530425819),\n",
       " ('money', 0.005426777055746855),\n",
       " ('posemo', 0.005207359259779314),\n",
       " ('negemo', 0.005121484877754135),\n",
       " ('feel', 0.004527219872281263),\n",
       " ('space', 0.003819259460512905),\n",
       " ('anx', 0.0036360851519248033),\n",
       " ('inhib', 0.0032653448548397124),\n",
       " ('achieve', 0.0031674857972681988)]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scores[:15]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### RoBERTa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = torch.tensor(df.label).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from transformers import (\n",
    "    AutoTokenizer,\n",
    "    AutoModelForSequenceClassification,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "tokenizer_hf = AutoTokenizer.from_pretrained(\"ShreyaR/finetuned-roberta-depression\")\n",
    "model = AutoModelForSequenceClassification.from_pretrained(\"ranieri-unimi/test-trainer\").to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "TH = tokenizer_hf.batch_encode_plus(\n",
    "    df.pp_text.to_list(),\n",
    "    return_tensors=\"pt\",\n",
    "    padding=True,\n",
    "    truncation=True,\n",
    ").to(device)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# X = None\n",
    "# with torch.no_grad():\n",
    "#     for i in tqdm(range(0, len(y), BATCH_SIZE)):\n",
    "#         input_ids = TH.input_ids[i : i + BATCH_SIZE, :]\n",
    "#         result = model(input_ids, output_hidden_states=True)\n",
    "#         cls_batch = result.hidden_states[-1][:, 0, :]\n",
    "#         try:\n",
    "#             X = torch.cat((X, cls_batch))\n",
    "#         except:\n",
    "#             X = cls_batch\n",
    "# torch.save(X, \"stash/X.cls.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = torch.load(\"stash/X.cls.pt\").to(device)\n",
    "X = [e for e in X]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RobDataset(Dataset):\n",
    "    def __init__(self, X_list, y_list):\n",
    "        self.X_list = X_list\n",
    "        self.y_list = y_list\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.y_list)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return self.X_list[idx], self.y_list[idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds_rob = RobDataset(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "validation loss 0.477 at epoch 0\n",
      "validation loss 0.457 at epoch 1\n",
      "validation loss 0.429 at epoch 2\n",
      "validation loss 0.419 at epoch 3\n",
      "validation loss 0.414 at epoch 4\n",
      "validation loss 0.400 at epoch 5\n",
      "validation loss 0.398 at epoch 6\n",
      "validation loss 0.412 at epoch 7\n",
      "validation loss 0.403 at epoch 8\n",
      "validation loss 0.419 at epoch 9\n",
      "validation loss 0.399 at epoch 10\n",
      "validation loss 0.392 at epoch 11\n",
      "validation loss 0.390 at epoch 12\n",
      "validation loss 0.411 at epoch 13\n",
      "validation loss 0.392 at epoch 14\n",
      "validation loss 0.403 at epoch 15\n",
      "validation loss 0.396 at epoch 16\n",
      "validation loss 0.390 at epoch 17\n",
      "validation loss 0.426 at epoch 18\n",
      "validation loss 0.388 at epoch 19\n",
      "validation loss 0.390 at epoch 20\n",
      "validation loss 0.405 at epoch 21\n",
      "validation loss 0.387 at epoch 22\n",
      "validation loss 0.391 at epoch 23\n",
      "early stopping...\n"
     ]
    }
   ],
   "source": [
    "trainer = MyTrainer(ds_rob, 768)\n",
    "trainer.fit(\n",
    "    epochs=100,\n",
    "    early_stopping=EarlyStopping(\n",
    "        tolerance=8,\n",
    "        min_delta=0.0,\n",
    "        max_beta=0.12,\n",
    "    ),\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot: >"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.lineplot(trainer.train_losses)\n",
    "sns.lineplot(trainer.val_losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "wo_weights = trainer.model.layers[0].weight[0].detach().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_hat, y_true = list(zip(*trainer.gasp()))\n",
    "y_hat = [1 if e>0.5 else 0 for e in y_hat]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1: 0.51\n",
      "Precision: 0.81\n",
      "Recall: 0.38\n",
      "Accuracy: 0.66\n"
     ]
    }
   ],
   "source": [
    "metrics(y_hat, y_true)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### reg match"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import ElasticNet, Ridge, LinearRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_lex = np.array([ds_lex[i][0] for i in range(len(ds_lex))])\n",
    "x_sem = np.array([ds_rob[i][0].numpy() for i in range(len(ds_rob))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-3.73287740e-03  1.35999002e-01 -2.91835908e-03 ...  3.28571175e-01\n",
      "  -1.75643968e-02 -1.77180860e-01]\n",
      " [ 1.40839331e-02  1.98991041e-02 -5.33868533e-03 ...  7.77323627e-02\n",
      "   1.48232016e-02 -3.59815514e-02]\n",
      " [ 1.12688929e-02  1.12363939e-02 -6.46624173e-03 ...  6.32734323e-02\n",
      "   1.04695655e-02 -2.47157306e-02]\n",
      " ...\n",
      " [ 5.53938214e-03 -2.58408594e-02  4.48185549e-03 ... -6.87063416e-02\n",
      "   5.38023242e-03  3.57190829e-02]\n",
      " [-5.54531361e-04 -1.43057164e-04  6.00416107e-04 ... -2.27772934e-03\n",
      "  -2.65877164e-04  8.90534845e-04]\n",
      " [ 1.07157045e-04  1.97275698e-04 -1.04539935e-04 ...  4.27690927e-05\n",
      "   3.14536807e-05  1.10099397e-04]]\n"
     ]
    }
   ],
   "source": [
    "ridge_reg = Ridge(alpha=0.05)\n",
    "ridge_reg.fit(x_sem, y_lex)\n",
    "\n",
    "print(ridge_reg.coef_)\n",
    "# print(ridge_reg.intercept_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "P = ridge_reg.coef_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rescale(v, method):\n",
    "    a = np.array(v)\n",
    "    match method.lower():\n",
    "        case \"prob\":\n",
    "            a = (a - a.min()) / (a.max() - a.min())\n",
    "        case \"softmax\":\n",
    "            a = np.exp(a) / sum(np.exp(a))\n",
    "        case \"std\":\n",
    "            a = (a - a.mean()) / (a.std())\n",
    "        case \"relu\":\n",
    "            a = np.maximum(0, a)\n",
    "        case _:\n",
    "            print(f'\"{rescale}\" is ignored because is not a supported rescale method')\n",
    "    return a\n",
    "\n",
    "def md_rescale(A, method):\n",
    "    return np.array([rescale(a, method) for a in A])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_coeff(M, category):\n",
    "    i = categories.index(category)\n",
    "    ax = sns.heatmap(\n",
    "        (M[i]//1e-11).reshape((32, 24)),\n",
    "        # cmap=sns.color_palette(\"vlag\", as_cmap=True),\n",
    "    )\n",
    "    ax.set(\n",
    "        xticklabels=[],\n",
    "        yticklabels=[],\n",
    "        title=category.upper(),\n",
    "    )\n",
    "    ax.tick_params(bottom=False, left=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot_coeff(md_rescale(P.T, \"relu\").T, \"posemo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "error_term = np.dot(P, wo_weights) - xi_weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(64,)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(P, wo_weights).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot: ylabel='Count'>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.histplot(error_term, kde=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "lx_error_term = np.dot(P.T, xi_weights) - wo_weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot: ylabel='Count'>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.histplot(lx_error_term, kde=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(ShapiroResult(statistic=0.9825556874275208, pvalue=0.5011416673660278),\n",
       " ShapiroResult(statistic=0.9984548687934875, pvalue=0.7426096200942993))"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats.shapiro(error_term), stats.shapiro(lx_error_term)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ttest_indResult(statistic=-0.03653531343315709, pvalue=0.970913341186219)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats.ttest_ind(np.dot(P, wo_weights), xi_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ttest_indResult(statistic=-0.40008524634614123, pvalue=0.689149435206789)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats.ttest_ind(np.dot(P.T, xi_weights), wo_weights)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "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.9"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "3a03f457ba8100ed956a9dead337cf895f8e146c4ebc145127222e1f06f191e5"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}