notebooks/analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ruff: noqa\n",
    "%reload_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "# Standard imports\n",
    "import os\n",
    "import json\n",
    "\n",
    "# External imports\n",
    "import hydra\n",
    "import rootutils\n",
    "import pandas as pd\n",
    "from matplotlib import pyplot as plt\n",
    "import seaborn as sns\n",
    "from wandb.sdk.wandb_run import Run\n",
    "import wandb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reinitialize hydra on every run\n",
    "hydra.core.global_hydra.GlobalHydra.instance().clear()\n",
    "h = hydra.initialize(config_path=\"../conf\", job_name=\"eda\", version_base=None)\n",
    "\n",
    "# Setup root environment\n",
    "root_path = rootutils.setup_root(\".\")\n",
    "rootutils.set_root(\n",
    "    path=root_path,\n",
    "    project_root_env_var=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Global paths\n",
    "ROOT_DIR = root_path\n",
    "ARTIFACT_DIR = os.path.join(ROOT_DIR, \"artifacts\")\n",
    "FIGURE_DIR = os.path.join(ROOT_DIR, \"report\", \"figures\")\n",
    "TABLE_DIR = os.path.join(ROOT_DIR, \"report\", \"tables\")\n",
    "\n",
    "# Global settings\n",
    "SAVE = False\n",
    "\n",
    "os.makedirs(FIGURE_DIR, exist_ok=True)\n",
    "os.makedirs(TABLE_DIR, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Global Labeling\n",
    "rename_dict = {\n",
    "    \"human\": \"Human\",\n",
    "    \"gpt3.5\": \"GPT-3.5\",\n",
    "    \"gpt4\": \"GPT-4\",\n",
    "    \"context1\": \"Context 1\",\n",
    "    \"context2\": \"Context 2\",\n",
    "    \"context3\": \"Context 3\",\n",
    "    \"zeroshot\": \"0-shot\",\n",
    "    \"oneshot\": \"1-shot\",\n",
    "    \"f1\": \"Macro F1\",\n",
    "    \"acc\": \"Acc\",\n",
    "    \"precision\": \"Precision\",\n",
    "    \"recall\": \"Recall\",\n",
    "    \"lpp\": \"Labels Per Page\",\n",
    "    \"Kids_and_Teens\": \"Kids & Teens\",\n",
    "}\n",
    "\n",
    "def rename(x):\n",
    "    return rename_dict.get(x, x)\n",
    "\n",
    "def get_labeler_name(name: str):\n",
    "    return \" + \".join([rename_dict.get(n, n) for n in name.split(\"-\")])\n",
    "\n",
    "def get_metric_name(name: str):\n",
    "    if \"/\" in name:\n",
    "        split, metric = name.split(\"/\")\n",
    "        return f\"{rename_dict.get(split, split)} {rename_dict.get(metric, metric)}\"\n",
    "    else:\n",
    "        return rename_dict.get(name, name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load categories\n",
    "with open(os.path.join(\"..\", \"data\", \"meta\", \"categories.json\"), \"r\") as f:\n",
    "    categories_and_desc = json.load(f)\n",
    "\n",
    "categories, categories_desc = zip(*categories_and_desc.items())\n",
    "idx2categories = dict(enumerate(categories))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Style and colors\n",
    "sns.set_style(\"whitegrid\")\n",
    "sns.set_palette(\"gist_stern\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✅ Loaded 625 runs from W&B (ml-project-2-mlp/homepage2vec)\n"
     ]
    }
   ],
   "source": [
    "# Initialise W&B\n",
    "WANDB_PROJECT = \"homepage2vec\"\n",
    "WANDB_ENTITY = \"ml-project-2-mlp\"\n",
    "\n",
    "# Initialize W&B API\n",
    "api = wandb.Api()\n",
    "\n",
    "# Get all runs\n",
    "runs = api.runs(f\"{WANDB_ENTITY}/{WANDB_PROJECT}\")\n",
    "print(f\"✅ Loaded {len(runs)} runs from W&B ({WANDB_ENTITY}/{WANDB_PROJECT})\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helpers\n",
    "\n",
    "---\n",
    "\n",
    "First, we define a series of helper functions which we use to extract the relevant information (configuration, hyperparameters, performance metrics, etc.) from the W&B runs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helpers\n",
    "def extract_config(run: Run) -> dict:\n",
    "    \"\"\"\n",
    "    Extracts the config from a run.\n",
    "    \"\"\"\n",
    "    data_attr = [\"name\"]\n",
    "    labeler_attr = [\"name\", \"model\", \"fewshot\", \"features\"]\n",
    "    train_data = {f\"train_data_{k}\":v for k,v  in run.config.get(\"train_data\", {}).items() if k in data_attr}\n",
    "    test_data = {f\"test_data_{k}\":v for k,v  in run.config.get(\"test_data\", {}).items() if k in data_attr}\n",
    "    train_labeler = {f\"train_labeler_{k}\":v for k,v  in run.config.get(\"train_labeler\", {}).items() if k in labeler_attr}\n",
    "    test_labeler = {f\"test_labeler_{k}\":v for k,v  in run.config.get(\"test_labeler\", {}).items() if k in labeler_attr}\n",
    "    train_ratio = run.config.get(\"train_datamodule\", {}).get(\"data_split\", [None])[0]\n",
    "    val_ratio, test_ratio = run.config.get(\"test_datamodule\", {}).get(\"data_split\", [None, None, None])[1:]\n",
    "\n",
    "    config = {\"id\": run.id, \"name\": run.name, \"finetune\": run.config[\"finetune\"], \"train_ratio\": train_ratio, \"val_ratio\": val_ratio, \"test_ratio\": test_ratio, **train_data, **test_data, **train_labeler, **test_labeler}\n",
    "\n",
    "    return config\n",
    "\n",
    "def extract_hparams(run: Run) -> dict:\n",
    "    \"\"\"\n",
    "    Extracts the hparams from a run.\n",
    "    \"\"\"\n",
    "    hparams = {\n",
    "        \"lr\": run.config.get(\"model\", {}).get(\"optimizer\", {}).get(\"lr\", None),\n",
    "        \"weight_decay\": run.config.get(\"model\", {}).get(\"optimizer\", {}).get(\"weight_decay\", None),\n",
    "        \"scheduler_factor\": run.config.get(\"model\", {}).get(\"scheduler\", {}).get(\"factor\", None),\n",
    "        \"batch_size\": run.config.get(\"train_datamodule\", {}).get(\"batch_size\", None),\n",
    "    }\n",
    "    return hparams\n",
    "\n",
    "def extract_summary(run: Run, exclude:list[str] = [\"test/cm\", \"test/report\"]) -> dict:\n",
    "    \"\"\"\n",
    "    Extracts the summary from a run.\n",
    "    \"\"\"\n",
    "    summary = {k:v for k, v in run.summary.items() if not k.startswith(\"_\") and k not in exclude}\n",
    "    return summary\n",
    "\n",
    "def runs_to_df(runs: list[Run]) -> pd.DataFrame:\n",
    "    \"\"\"\n",
    "    Convert a list of W&B runs to a dataframe.\n",
    "    \"\"\"\n",
    "    # Extract information from runs\n",
    "    rows = []\n",
    "    for run in runs[::-1]:\n",
    "        config = extract_config(run)\n",
    "        hparams = extract_hparams(run)\n",
    "        summary = extract_summary(run)\n",
    "        rows.append({**config, **hparams, **summary})\n",
    "\n",
    "    # Add multi-index\n",
    "    columns = list(config.keys()) + list(hparams.keys()) + list(summary.keys())\n",
    "    config_tuples = [(\"config\", k) for k in config.keys()]\n",
    "    hparams_tuples = [(\"hparams\", k) for k in hparams.keys()]\n",
    "    summary_tuples = [(\"summary\", k) for k in summary.keys()]\n",
    "\n",
    "    # Create dataframe\n",
    "    run_df = pd.DataFrame(rows, columns=columns)\n",
    "    run_df.columns = pd.MultiIndex.from_tuples(\n",
    "        config_tuples + hparams_tuples + summary_tuples,\n",
    "    )\n",
    "    run_df.set_index((\"config\", \"id\"), inplace=True)\n",
    "\n",
    "    return run_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def best_runs(df_runs: pd.DataFrame, split: str=\"val\", metric: str=\"f1\") -> pd.DataFrame:\n",
    "    \"\"\"\n",
    "    Get the best runs based on the validation metric for \n",
    "    each unique combination of data, labeler - specified \n",
    "    in the run name.\n",
    "\n",
    "    Args:\n",
    "        df_runs (pd.DataFrame): Dataframe of runs.\n",
    "        metric (str): Metric to sort on.\n",
    "\n",
    "    Returns:\n",
    "        pd.DataFrame: Dataframe of best runs.\n",
    "    \"\"\"\n",
    "    experiment_cols = [(\"config\", \"train_labeler_name\"), (\"config\", \"finetune\")]\n",
    "    unique_exps = df_runs[experiment_cols].drop_duplicates()\n",
    "    best_runs = []\n",
    "    for unique_exp in unique_exps.values:\n",
    "        is_unique_exp = (df_runs[experiment_cols] == unique_exp).all(axis=1)\n",
    "        best_exp_run = df_runs[is_unique_exp].sort_values((\"summary\", f\"{split}/{metric}\"), ascending=False).iloc[0]\n",
    "        best_runs.append(best_exp_run)\n",
    "\n",
    "    return pd.DataFrame(best_runs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_test_cm(run: Run) -> pd.DataFrame:\n",
    "    \"\"\"\n",
    "    Extracts the test confusion matrix from a run.\n",
    "    \"\"\"\n",
    "    test_cm = json.loads(run.summary.get(\"test/cm\", None))\n",
    "    if test_cm is None:\n",
    "        return None\n",
    "    test_cm = pd.DataFrame.from_dict(test_cm)\n",
    "    test_cm[\"category\"].replace(idx2categories, inplace=True)\n",
    "    test_cm.set_index(\"category\", inplace=True)\n",
    "    return test_cm\n",
    "\n",
    "def get_test_report(run: Run) -> pd.DataFrame:\n",
    "    \"\"\"\n",
    "    Extracts the test report from a run.\n",
    "    \"\"\"\n",
    "    test_report = json.loads(run.summary.get(\"test/report\", None))\n",
    "    if test_report is None:\n",
    "        return None\n",
    "    test_report = pd.DataFrame.from_dict(test_report)\n",
    "    mapper_ = {str(idx): category for idx, category in idx2categories.items()}\n",
    "    test_report[\"category\"] = test_report[\"category\"].map(lambda x: mapper_.get(x, x))\n",
    "    return test_report\n",
    "\n",
    "def get_test_targets(run: Run) -> pd.DataFrame:\n",
    "    \"\"\"\n",
    "    Extracts the test predictions from a run.\n",
    "    \"\"\"\n",
    "    test_targets = json.loads(run.summary.get(\"test/targets\"))\n",
    "    return pd.DataFrame(test_targets, columns=categories)\n",
    "\n",
    "def get_test_preds(run: Run) -> pd.DataFrame:\n",
    "    \"\"\"\n",
    "    Extracts the test predictions from a run.\n",
    "    \"\"\"\n",
    "    test_preds = json.loads(run.summary.get(\"test/preds\"))\n",
    "    return pd.DataFrame(test_preds, columns=categories)\n",
    "\n",
    "def get_test_probs(run: Run) -> pd.DataFrame:\n",
    "    \"\"\"\n",
    "    Extracts the test probabilities from a run.\n",
    "    \"\"\"\n",
    "    test_probs = json.loads(run.summary.get(\"test/probs\"))\n",
    "    return pd.DataFrame(test_probs, columns=categories)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_test_reports_df(runs: list[Run]) -> pd.DataFrame:\n",
    "    test_reports_df = pd.DataFrame()\n",
    "    for run in runs:\n",
    "        run_config = extract_config(run)\n",
    "        test_report = get_test_report(run)\n",
    "\n",
    "        for k, v in run_config.items():\n",
    "            test_report[k] = v\n",
    "\n",
    "        # Concatenate\n",
    "        test_reports_df = pd.concat([test_reports_df, test_report])\n",
    "\n",
    "    return test_reports_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results \n",
    "\n",
    "---\n",
    "\n",
    "In this section we are loading all the runs in the group of runs that fine-tuned on `curlie-gpt3.5-10k` and `curlie-gpt4-10k`, respectively. We aim to analyse and visualise the general performance of the models in comparison to the original Homepage2Vec model. Finally, we analyse the hyperparameter grid.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✅ Loaded 180 runs from W&B (ml-project-2-mlp/homepage2vec - exp2-3)\n"
     ]
    }
   ],
   "source": [
    "# Filter runs for Experiment 2\n",
    "GROUP = \"exp2-3\"\n",
    "\n",
    "runs = [run for run in runs if run.group == GROUP and run.state == \"finished\"]\n",
    "\n",
    "print(f\"✅ Loaded {len(runs)} runs from W&B ({WANDB_ENTITY}/{WANDB_PROJECT} - {GROUP})\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>lr</th>\n",
       "      <th>weight_decay</th>\n",
       "      <th>scheduler_factor</th>\n",
       "      <th>batch_size</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>fnvzgxir</th>\n",
       "      <td>0.000016</td>\n",
       "      <td>0.064037</td>\n",
       "      <td>0.376673</td>\n",
       "      <td>64</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>syqivch6</th>\n",
       "      <td>0.001535</td>\n",
       "      <td>0.000252</td>\n",
       "      <td>0.460896</td>\n",
       "      <td>64</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>81xcxk0e</th>\n",
       "      <td>0.000100</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>32</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                lr  weight_decay  scheduler_factor  batch_size\n",
       "fnvzgxir  0.000016      0.064037          0.376673          64\n",
       "syqivch6  0.001535      0.000252          0.460896          64\n",
       "81xcxk0e  0.000100      0.000000          0.100000          32"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convert to dataframe\n",
    "runs_df = runs_to_df(runs)\n",
    "\n",
    "# Get best runs by validation macro F1\n",
    "best_runs_df = best_runs(runs_df, split=\"val\", metric=\"f1_best\")\n",
    "\n",
    "# Show best runs sorted by test macro F1\n",
    "best_runs_df.sort_values((\"summary\", \"test/f1\"), ascending=False).hparams"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finetuning Results Table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "❌ Not saving table. If you want to save it, set SAVE=True\n"
     ]
    }
   ],
   "source": [
    "# Save copy of best runs dataframe\n",
    "df = best_runs_df.copy()\n",
    "\n",
    "index = [x.config[\"train_labeler_name\"] if x.config[\"finetune\"] else \"Pretrained\" for _, x in df.iterrows()]\n",
    "index = [get_labeler_name(x) for x in index]\n",
    "df = df.summary[[\"test/precision\", \"test/recall\", \"test/f1\", \"test/lpp\"]]\n",
    "\n",
    "df = df.set_index(pd.Index(index))\n",
    "\n",
    "cols = {\"test/precision\": \"Pr.\", \"test/recall\": \"Re.\", \"test/f1\": \"M.-F1\", \"test/lpp\": \"LPP\"}\n",
    "df = df[cols.keys()].rename(columns=cols)\n",
    "\n",
    "df[\"Pr.\"] = df[\"Pr.\"] * 100\n",
    "df[\"Re.\"] = df[\"Re.\"] * 100\n",
    "df[\"M.-F1\"] = df[\"M.-F1\"] * 100\n",
    "\n",
    "# Save the dataframe to a latex table\n",
    "position = \"!ht\"\n",
    "save_path = os.path.join(TABLE_DIR, \"finetune-results.tex\")\n",
    "latex = df.to_latex(\n",
    "    caption=\"TODO\", \n",
    "    label=\"tab:finetune-results\",\n",
    "    escape=True,\n",
    "    position=position,\n",
    "    multirow=True,\n",
    "    float_format=\"%.2f\",\n",
    "    multicolumn=True,\n",
    "    multicolumn_format=\"c\",\n",
    ")\n",
    "latex = latex.replace(\"\\\\begin{table}\" + f\"[{position}]\", \"\\\\begin{table}\" + f\"[{position}]\" + \"\\n\\\\centering\")\n",
    "latex = latex.replace(\"[t]\", \"[c]\")\n",
    "\n",
    "# Save table if specified\n",
    "if SAVE:\n",
    "    with open(save_path, \"w\") as f:\n",
    "        f.write(latex)\n",
    "    print(f\"✅ Saved table to {save_path}\")\n",
    "else:\n",
    "    print(f\"❌ Not saving table. If you want to save it, set SAVE=True\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finetuning Classwise F1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got 1 pretrained run(s) and 2 finetuned run(s) for exp2-3\n"
     ]
    }
   ],
   "source": [
    "# Extract best runs\n",
    "pretrained_runs = best_runs_df[best_runs_df[(\"config\", \"finetune\")] == False]\n",
    "finetuned_runs = best_runs_df[best_runs_df[(\"config\", \"finetune\")] == True]\n",
    "\n",
    "pretrained_run_ids = pretrained_runs.index.values\n",
    "finetuned_run_ids = finetuned_runs.index.values\n",
    "\n",
    "pretrained_runs = [run for run in runs if run.id in pretrained_run_ids]\n",
    "finetuned_runs = [run for run in runs if run.id in finetuned_run_ids]\n",
    "\n",
    "print(f\"Got {len(pretrained_runs)} pretrained run(s) and {len(finetuned_runs)} finetuned run(s) for {GROUP}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get best runs\n",
    "pretrained_run = pretrained_runs[0]\n",
    "gpt3_5_run = finetuned_runs[0]\n",
    "gpt4_run = finetuned_runs[1]\n",
    "\n",
    "pretrained_cms = get_test_cm(pretrained_run)\n",
    "gpt3_5_cms = get_test_cm(gpt3_5_run)\n",
    "gpt4_cms = get_test_cm(gpt4_run)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✅ Saved figure to /Users/jonas-mika/epfl/coursework/projects/ml-project-2-mlp/report/figures/finetune-results.pdf\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualise the macro F1\n",
    "pretrained_report = get_test_report(pretrained_run)\n",
    "gpt3_5_report = get_test_report(gpt3_5_run)\n",
    "gpt4_report = get_test_report(gpt4_run)\n",
    "\n",
    "pretrained_report[\"model\"] = \"Pretrained\"\n",
    "gpt3_5_report[\"model\"] = \"GPT-3.5\"\n",
    "gpt4_report[\"model\"] = \"GPT-4\"\n",
    "\n",
    "test_reports = pd.concat([pretrained_report, gpt3_5_report, gpt4_report])\n",
    "\n",
    "test_reports = test_reports[test_reports[\"category\"].isin(categories)]\n",
    "test_reports[\"category\"] = test_reports[\"category\"].map(lambda x: rename(x))\n",
    "test_reports[\"f1-score\"] = test_reports[\"f1-score\"] * 100\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(16, 4))\n",
    "fig.tight_layout(pad=3.0)\n",
    "sns.barplot(\n",
    "    data=test_reports,\n",
    "    x=\"category\",\n",
    "    y=\"f1-score\",\n",
    "    hue=\"model\",\n",
    "    ax=ax\n",
    ")\n",
    "ax.set_xlabel(\"\")\n",
    "ax.set_ylabel(\"F1 (%)\", fontsize=14)\n",
    "ax.set_xticks(ax.get_xticks())\n",
    "ax.set_xticklabels(ax.get_xticklabels(), rotation=30, horizontalalignment='right', fontsize=14)\n",
    "ax.get_legend().set_title(\"\")\n",
    "\n",
    "# Add values to bars\n",
    "for p in ax.patches:\n",
    "    height = p.get_height()\n",
    "    if height == 0:\n",
    "        continue\n",
    "    ax.text(p.get_x()+p.get_width()/2.,\n",
    "            height + 1,\n",
    "            f\"{height:.0f}\",\n",
    "            ha=\"center\", fontsize=12)\n",
    "\n",
    "ax.set_ylim(0, 70)\n",
    "\n",
    "# Save figure\n",
    "path = os.path.join(FIGURE_DIR, \"finetune-results.pdf\")\n",
    "fig.savefig(path, bbox_inches=\"tight\")\n",
    "print(f\"✅ Saved figure to {path}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hyperparameter Grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create new dataframe with hyperparameters and test/f1\n",
    "grid_df = runs_df[\"hparams\"].copy()\n",
    "grid_df[\"test/f1\"] = runs_df[\"summary\"][\"test/f1\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Macro F1')"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x500 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Hyperparameters\n",
    "fig, axs = plt.subplots(ncols=4, figsize=(20, 5))\n",
    "params = [\"lr\", \"weight_decay\", \"scheduler_factor\", \"batch_size\"]\n",
    "\n",
    "for ax, x in zip(axs, params):\n",
    "    sns.histplot(\n",
    "        data=grid_df,\n",
    "        x=x,\n",
    "        y=\"test/f1\",\n",
    "        ax=ax\n",
    "    )\n",
    "    ax.set_xticks(ax.get_xticks())\n",
    "    ax.set_xticklabels([rename_dict.get(t.get_text(), t.get_text()) for t in ax.get_xticklabels()])\n",
    "    ax.set_xlabel(x.capitalize(), fontsize=14)\n",
    "    ax.set_ylabel(\"\")\n",
    "\n",
    "axs[0].set_ylabel(\"Macro F1\", fontsize=14)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ml-project-2-mlp-rx2AOdW0-py3.10",
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}