From 8b25a62d6e3bb75d2a5ece16491aebb346728efe Mon Sep 17 00:00:00 2001
From: gbg141 <guille_gbg@hotmail.com>
Date: Tue, 4 Jun 2024 01:00:53 +0200
Subject: [PATCH] Cleaning

---
 .gitignore                                    |    2 +
 notebooks/__init__.py                         |    1 -
 notebooks/cornel_dataset.ipynb                |  432 --
 notebooks/curvature.ipynb                     |  624 --
 notebooks/curvature_results.ipynb             | 1789 -----
 notebooks/data.ipynb                          | 1594 ----
 .../SimplicialCliqueLifting.ipynb             |  263 -
 notebooks/play.ipynb                          |  281 -
 notebooks/result_processing.ipynb             | 6737 -----------------
 notebooks/test_cellular_lifting_dev.ipynb     |  123 -
 notebooks/test_feature_lifting_dev.ipynb      |  358 -
 notebooks/test_hypergraph_lifting_dev.ipynb   |  224 -
 notebooks/test_simplicialclique_dev.ipynb     | 1982 -----
 13 files changed, 2 insertions(+), 14408 deletions(-)
 delete mode 100755 notebooks/__init__.py
 delete mode 100644 notebooks/cornel_dataset.ipynb
 delete mode 100755 notebooks/curvature.ipynb
 delete mode 100644 notebooks/curvature_results.ipynb
 delete mode 100755 notebooks/data.ipynb
 delete mode 100644 notebooks/graph2simplicial/SimplicialCliqueLifting.ipynb
 delete mode 100644 notebooks/play.ipynb
 delete mode 100644 notebooks/result_processing.ipynb
 delete mode 100644 notebooks/test_cellular_lifting_dev.ipynb
 delete mode 100644 notebooks/test_feature_lifting_dev.ipynb
 delete mode 100644 notebooks/test_hypergraph_lifting_dev.ipynb
 delete mode 100644 notebooks/test_simplicialclique_dev.ipynb

diff --git a/.gitignore b/.gitignore
index 294ee3e5..d02635e2 100755
--- a/.gitignore
+++ b/.gitignore
@@ -80,6 +80,8 @@ target/
 
 # Jupyter Notebook
 .ipynb_checkpoints
+notebooks/
+notebooks/*
 
 # IPython
 profile_default/
diff --git a/notebooks/__init__.py b/notebooks/__init__.py
deleted file mode 100755
index 3bede618..00000000
--- a/notebooks/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Empty file to make the notebooks folder a package."""
diff --git a/notebooks/cornel_dataset.ipynb b/notebooks/cornel_dataset.ipynb
deleted file mode 100644
index e79ffde5..00000000
--- a/notebooks/cornel_dataset.ipynb
+++ /dev/null
@@ -1,432 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import sys\n",
-    "\n",
-    "# Add manually root '/home/lev/projects/TopoBenchmarkX'\n",
-    "root_path = \"/home/lev/projects/TopoBenchmarkX\"\n",
-    "if root_path not in sys.path:\n",
-    "    sys.path.append(root_path)\n",
-    "\n",
-    "import os.path as osp\n",
-    "from collections.abc import Callable\n",
-    "\n",
-    "from torch_geometric.data import Data, InMemoryDataset\n",
-    "from torch_geometric.io import fs\n",
-    "\n",
-    "from topobenchmarkx.data.load.download_utils import download_file_from_drive\n",
-    "\n",
-    "\n",
-    "class CornelDataset(InMemoryDataset):\n",
-    "    r\"\"\" \"\"\"\n",
-    "\n",
-    "    URLS = {\n",
-    "        # 'contact-high-school': 'https://drive.google.com/open?id=1VA2P62awVYgluOIh1W4NZQQgkQCBk-Eu',\n",
-    "        \"US-county-demos\": \"https://drive.google.com/file/d/1FNF_LbByhYNICPNdT6tMaJI9FxuSvvLK/view?usp=sharing\",\n",
-    "    }\n",
-    "\n",
-    "    FILE_FORMAT = {\n",
-    "        # 'contact-high-school': 'tar.gz',\n",
-    "        \"US-county-demos\": \"zip\",\n",
-    "    }\n",
-    "\n",
-    "    RAW_FILE_NAMES = {}\n",
-    "\n",
-    "    def __init__(\n",
-    "        self,\n",
-    "        root: str,\n",
-    "        name: str,\n",
-    "        parameters: dict = None,\n",
-    "        transform: Callable | None = None,\n",
-    "        pre_transform: Callable | None = None,\n",
-    "        pre_filter: Callable | None = None,\n",
-    "        force_reload: bool = True,\n",
-    "        use_node_attr: bool = False,\n",
-    "        use_edge_attr: bool = False,\n",
-    "    ) -> None:\n",
-    "        self.name = name.replace(\"_\", \"-\")\n",
-    "\n",
-    "        super().__init__(\n",
-    "            root, transform, pre_transform, pre_filter, force_reload=force_reload\n",
-    "        )\n",
-    "\n",
-    "        # Step 3:Load the processed data\n",
-    "        # After the data has been downloaded from source\n",
-    "        # Then preprocessed to obtain x,y and saved into processed folder\n",
-    "        # We can now load the processed data from processed folder\n",
-    "\n",
-    "        # Load the processed data\n",
-    "        data, _, _ = fs.torch_load(self.processed_paths[0])\n",
-    "\n",
-    "        # Map the loaded data into\n",
-    "        data = Data.from_dict(data)\n",
-    "\n",
-    "        # Step 5: Create the splits and upload desired fold\n",
-    "\n",
-    "        # split_idx = random_splitting(data.y, parameters=self.parameters)\n",
-    "\n",
-    "        # Assign data object to self.data, to make it be prodessed by Dataset class\n",
-    "        self.data = data\n",
-    "\n",
-    "    @property\n",
-    "    def raw_dir(self) -> str:\n",
-    "        return osp.join(self.root, self.name, \"raw\")\n",
-    "\n",
-    "    @property\n",
-    "    def processed_dir(self) -> str:\n",
-    "        return osp.join(self.root, self.name, \"processed\")\n",
-    "\n",
-    "    @property\n",
-    "    def raw_file_names(self) -> list[str]:\n",
-    "        names = [\"\", \"_2012\"]\n",
-    "        return [f\"{self.name}_{name}.txt\" for name in names]\n",
-    "\n",
-    "    @property\n",
-    "    def processed_file_names(self) -> str:\n",
-    "        return \"data.pt\"\n",
-    "\n",
-    "    def download(self) -> None:\n",
-    "        \"\"\"\n",
-    "        Downloads the dataset from the specified URL and saves it to the raw directory.\n",
-    "\n",
-    "        Raises:\n",
-    "            FileNotFoundError: If the dataset URL is not found.\n",
-    "        \"\"\"\n",
-    "\n",
-    "        # Step 1: Download data from the source\n",
-    "        self.url = self.URLS[self.name]\n",
-    "        self.file_format = self.FILE_FORMAT[self.name]\n",
-    "\n",
-    "        download_file_from_drive(\n",
-    "            file_link=self.url,\n",
-    "            path_to_save=self.raw_dir,\n",
-    "            dataset_name=self.name,\n",
-    "            file_format=self.file_format,\n",
-    "        )\n",
-    "\n",
-    "        # Extract the downloaded file if it is compressed\n",
-    "        fs.cp(\n",
-    "            f\"{self.raw_dir}/{self.name}.{self.file_format}\", self.raw_dir, extract=True\n",
-    "        )\n",
-    "\n",
-    "        # Move the etracted files to the datasets/domain/dataset_name/raw/ directory\n",
-    "        for filename in fs.ls(osp.join(self.raw_dir, self.name)):\n",
-    "            fs.mv(filename, osp.join(self.raw_dir, osp.basename(filename)))\n",
-    "        fs.rm(osp.join(self.raw_dir, self.name))\n",
-    "\n",
-    "        # Delete also f'{self.raw_dir}/{self.name}.{self.file_format}'\n",
-    "        fs.rm(f\"{self.raw_dir}/{self.name}.{self.file_format}\")\n",
-    "\n",
-    "    def process(self) -> None:\n",
-    "        \"\"\"\n",
-    "        Process the data for the dataset.\n",
-    "\n",
-    "        This method loads the US county demographics data, applies any pre-processing transformations if specified,\n",
-    "        and saves the processed data to the appropriate location.\n",
-    "\n",
-    "        Returns:\n",
-    "            None\n",
-    "        \"\"\"\n",
-    "        data = load_us_county_demos(self.raw_dir, self.name)\n",
-    "\n",
-    "        data = data if self.pre_transform is None else self.pre_transform(data)\n",
-    "        self.save([data], self.processed_paths[0])\n",
-    "\n",
-    "    def __repr__(self) -> str:\n",
-    "        return f\"{self.name}({len(self)})\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "import torch\n",
-    "import torch_geometric\n",
-    "\n",
-    "\n",
-    "def load_us_county_demos(path, dataset_name, year=2012):\n",
-    "    edges_df = pd.read_csv(f\"{path}/county_graph.csv\")\n",
-    "    stat = pd.read_csv(f\"{path}/county_stats_{year}.csv\", encoding=\"ISO-8859-1\")\n",
-    "\n",
-    "    keep_cols = [\n",
-    "        \"FIPS\",\n",
-    "        \"DEM\",\n",
-    "        \"GOP\",\n",
-    "        \"MedianIncome\",\n",
-    "        \"MigraRate\",\n",
-    "        \"BirthRate\",\n",
-    "        \"DeathRate\",\n",
-    "        \"BachelorRate\",\n",
-    "        \"UnemploymentRate\",\n",
-    "    ]\n",
-    "    # Drop rows with missing values\n",
-    "    stat = stat[keep_cols].dropna()\n",
-    "\n",
-    "    # Delete edges that are not present in stat df\n",
-    "    unique_fips = stat[\"FIPS\"].unique()\n",
-    "\n",
-    "    src_ = edges_df[\"SRC\"].apply(lambda x: x in unique_fips)\n",
-    "    dst_ = edges_df[\"DST\"].apply(lambda x: x in unique_fips)\n",
-    "\n",
-    "    edges_df = edges_df[src_ & dst_]\n",
-    "\n",
-    "    # Remove rows from stat df where edges_df['SRC'] or edges_df['DST'] are not present\n",
-    "    stat = stat[stat[\"FIPS\"].isin(edges_df[\"SRC\"]) & stat[\"FIPS\"].isin(edges_df[\"DST\"])]\n",
-    "    stat = stat.reset_index(drop=True)\n",
-    "\n",
-    "    # Remove rows where SRC == DST\n",
-    "    edges_df = edges_df[edges_df[\"SRC\"] != edges_df[\"DST\"]]\n",
-    "\n",
-    "    # Get torch_geometric edge_index format\n",
-    "    edge_index = torch.tensor(\n",
-    "        np.stack([edges_df[\"SRC\"].to_numpy(), edges_df[\"DST\"].to_numpy()])\n",
-    "    )\n",
-    "\n",
-    "    # Make edge_index undirected\n",
-    "    edge_index = torch_geometric.utils.to_undirected(edge_index)\n",
-    "\n",
-    "    # Convert edge_index back to pandas DataFrame\n",
-    "    edges_df = pd.DataFrame(edge_index.numpy().T, columns=[\"SRC\", \"DST\"])\n",
-    "\n",
-    "    del edge_index\n",
-    "\n",
-    "    # Map stat['FIPS'].unique() to [0, ..., num_nodes]\n",
-    "    fips_map = {fips: i for i, fips in enumerate(stat[\"FIPS\"].unique())}\n",
-    "    stat[\"FIPS\"] = stat[\"FIPS\"].map(fips_map)\n",
-    "\n",
-    "    # Map edges_df['SRC'] and edges_df['DST'] to [0, ..., num_nodes]\n",
-    "    edges_df[\"SRC\"] = edges_df[\"SRC\"].map(fips_map)\n",
-    "    edges_df[\"DST\"] = edges_df[\"DST\"].map(fips_map)\n",
-    "\n",
-    "    # Get torch_geometric edge_index format\n",
-    "    edge_index = torch.tensor(\n",
-    "        np.stack([edges_df[\"SRC\"].to_numpy(), edges_df[\"DST\"].to_numpy()])\n",
-    "    )\n",
-    "\n",
-    "    # Remove isolated nodes (Note: this function maps the nodes to [0, ..., num_nodes] automatically)\n",
-    "    edge_index, _, mask = torch_geometric.utils.remove_isolated_nodes(edge_index)\n",
-    "\n",
-    "    # Conver mask to index\n",
-    "    index = np.arange(mask.size(0))[mask]\n",
-    "    stat = stat.iloc[index]\n",
-    "    stat = stat.reset_index(drop=True)\n",
-    "\n",
-    "    # Get new values for FIPS from current index\n",
-    "    # To understand why please print stat.iloc[[516, 517, 518, 519, 520]] for 2012 year\n",
-    "    # Basically the FIPS values has been shifted\n",
-    "    stat[\"FIPS\"] = stat.reset_index()[\"index\"]\n",
-    "\n",
-    "    # Create Election variable\n",
-    "    stat[\"Election\"] = (stat[\"DEM\"] - stat[\"GOP\"]) / (stat[\"DEM\"] + stat[\"GOP\"])\n",
-    "\n",
-    "    # Drop DEM and GOP columns and FIPS\n",
-    "    stat = stat.drop(columns=[\"DEM\", \"GOP\", \"FIPS\"])\n",
-    "\n",
-    "    # Prediction col\n",
-    "    y_col = \"Election\"  # TODO: Define through config file\n",
-    "    x_col = list(set(stat.columns).difference(set([y_col])))\n",
-    "\n",
-    "    stat[\"MedianIncome\"] = (\n",
-    "        stat[\"MedianIncome\"]\n",
-    "        .apply(lambda x: x.replace(\",\", \"\"))\n",
-    "        .to_numpy()\n",
-    "        .astype(float)\n",
-    "    )\n",
-    "\n",
-    "    x = stat[x_col].to_numpy()\n",
-    "    y = stat[y_col].to_numpy()\n",
-    "\n",
-    "    data = torch_geometric.data.Data(x=x, y=y, edge_index=edge_index)\n",
-    "\n",
-    "    return data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Download complete.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Processing...\n",
-      "Done!\n"
-     ]
-    }
-   ],
-   "source": [
-    "a = CornelDataset(\n",
-    "    root=\"/home/lev/projects/TopoBenchmarkX/datasets/graph\", name=\"US-county-demos\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "parameters = {\n",
-    "    \"data_seed\": 0,\n",
-    "    \"data_split_dir\": \"/home/lev/projects/TopoBenchmarkX/datasets/data_splits/US-county-demos\",\n",
-    "    \"train_prop\": 0.5,\n",
-    "}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(3107, 6)"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a[0].x.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "AttributeError",
-     "evalue": "'dict' object has no attribute 'k'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[35], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m a \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mk\u001b[39m\u001b[38;5;124m'\u001b[39m:\u001b[38;5;241m1\u001b[39m}\n\u001b[0;32m----> 2\u001b[0m a\u001b[38;5;241m.\u001b[39mk\n",
-      "\u001b[0;31mAttributeError\u001b[0m: 'dict' object has no attribute 'k'"
-     ]
-    }
-   ],
-   "source": [
-    "a = {\"k\": 1}\n",
-    "a.k"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "stat = pd.read_csv(\n",
-    "    \"/home/lev/projects/TopoBenchmarkX/datasets/graph/US-county-demos-2012/raw/US-county-demos/county_stats_2016.csv\",\n",
-    "    encoding=\"ISO-8859-1\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Index(['FIPS', 'County', 'DEM', 'GOP', 'MedianIncome', 'MigraRate',\n",
-       "       'BirthRate', 'DeathRate', 'BachelorRate', 'UnemploymentRate'],\n",
-       "      dtype='object')"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "stat.columns"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "('Election',\n",
-       " 'MedianIncome',\n",
-       " 'MigraRate',\n",
-       " 'BirthRate',\n",
-       " 'DeathRate',\n",
-       " 'BachelorRate',\n",
-       " 'UnemploymentRate')"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(\n",
-    "    \"Election\",\n",
-    "    \"MedianIncome\",\n",
-    "    \"MigraRate\",\n",
-    "    \"BirthRate\",\n",
-    "    \"DeathRate\",\n",
-    "    \"BachelorRate\",\n",
-    "    \"UnemploymentRate\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "topo",
-   "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.11.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/notebooks/curvature.ipynb b/notebooks/curvature.ipynb
deleted file mode 100755
index cf681793..00000000
--- a/notebooks/curvature.ipynb
+++ /dev/null
@@ -1,624 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/tmp/ipykernel_365887/17376187.py:37: UserWarning: \n",
-      "The version_base parameter is not specified.\n",
-      "Please specify a compatability version level, or None.\n",
-      "Will assume defaults for version 1.1\n",
-      "  initialize(config_path=\"../configs\", job_name=\"job\")\n"
-     ]
-    }
-   ],
-   "source": [
-    "import rootutils\n",
-    "\n",
-    "rootutils.setup_root(\"./\", indicator=\".project-root\", pythonpath=True)\n",
-    "\n",
-    "%load_ext autoreload\n",
-    "%autoreload 2\n",
-    "\n",
-    "import hydra\n",
-    "import torch\n",
-    "import torch_geometric\n",
-    "from hydra import compose, initialize\n",
-    "from omegaconf import OmegaConf\n",
-    "\n",
-    "from topobenchmarkx.dataloader_fullbatch import (\n",
-    "    TBXDataloader,\n",
-    ")\n",
-    "from topobenchmarkx.utils.config_resolvers import (\n",
-    "    get_default_transform,\n",
-    "    get_monitor_metric,\n",
-    "    get_monitor_mode,\n",
-    "    infer_in_channels,\n",
-    ")\n",
-    "\n",
-    "OmegaConf.register_new_resolver(\"get_default_transform\", get_default_transform)\n",
-    "OmegaConf.register_new_resolver(\"get_monitor_metric\", get_monitor_metric)\n",
-    "OmegaConf.register_new_resolver(\"get_monitor_mode\", get_monitor_mode)\n",
-    "OmegaConf.register_new_resolver(\"infer_in_channels\", infer_in_channels)\n",
-    "OmegaConf.register_new_resolver(\n",
-    "    \"parameter_multiplication\", lambda x, y: int(int(x) * int(y))\n",
-    ")\n",
-    "\n",
-    "initialize(config_path=\"../configs\", job_name=\"job\")\n",
-    "cfg = compose(config_name=\"run.yaml\", return_hydra_config=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "cfg.dataset.transforms.graph2simplicial_lifting.complex_dim = 3\n",
-    "cfg.dataset.transforms.graph2simplicial_lifting.signed = False"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "dict_keys(['graph2simplicial_lifting', 'data_manipulations', 'simplicial_curvature', 'keep_selected_fields'])"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "cfg.dataset.transforms.keys()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Processing...\n",
-      "/home/lev/miniconda3/envs/topo/lib/python3.11/site-packages/scipy/sparse/_index.py:145: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil_matrix is more efficient.\n",
-      "  self._set_arrayXarray(i, j, x)\n",
-      "Done!\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Instantiate and load dataset\n",
-    "dataset = hydra.utils.instantiate(cfg.dataset, _recursive_=False)\n",
-    "dataset = dataset.load()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "if cfg.dataset.parameters.task_level == \"node\":\n",
-    "    datamodule = TBXDataloader(dataset_train=dataset)\n",
-    "\n",
-    "elif cfg.dataset.parameters.task_level == \"graph\":\n",
-    "    datamodule = TBXDataloader(\n",
-    "        dataset_train=dataset[0],\n",
-    "        dataset_val=dataset[1],\n",
-    "        dataset_test=dataset[2],\n",
-    "        batch_size=cfg.dataset.parameters.batch_size,\n",
-    "    )\n",
-    "else:\n",
-    "    raise ValueError(\"Invalid task_level\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# data = next(iter(datamodule.train_dataloader()))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Data(0_cell_curvature=[122747, 1], 1_cell_curvature=[132753, 1], 2_cell_curvature=[186, 1])"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "if len(datamodule.train_dataloader()) > 1:\n",
-    "    data = torch_geometric.data.Data()\n",
-    "\n",
-    "    d = {\"0_cell_curvature\": [], \"1_cell_curvature\": [], \"2_cell_curvature\": []}\n",
-    "    for batch in datamodule.train_dataloader():\n",
-    "        d[\"0_cell_curvature\"].append(batch[\"0_cell_curvature\"])\n",
-    "        d[\"1_cell_curvature\"].append(batch[\"1_cell_curvature\"])\n",
-    "        d[\"2_cell_curvature\"].append(batch[\"2_cell_curvature\"])\n",
-    "\n",
-    "    for batch in datamodule.test_dataloader():\n",
-    "        d[\"0_cell_curvature\"].append(batch[\"0_cell_curvature\"])\n",
-    "        d[\"1_cell_curvature\"].append(batch[\"1_cell_curvature\"])\n",
-    "        d[\"2_cell_curvature\"].append(batch[\"2_cell_curvature\"])\n",
-    "\n",
-    "    for batch in datamodule.val_dataloader():\n",
-    "        d[\"0_cell_curvature\"].append(batch[\"0_cell_curvature\"])\n",
-    "        d[\"1_cell_curvature\"].append(batch[\"1_cell_curvature\"])\n",
-    "        d[\"2_cell_curvature\"].append(batch[\"2_cell_curvature\"])\n",
-    "\n",
-    "    data[\"0_cell_curvature\"] = torch.cat(d[\"0_cell_curvature\"], dim=0)\n",
-    "    data[\"1_cell_curvature\"] = torch.cat(d[\"1_cell_curvature\"], dim=0)\n",
-    "    data[\"2_cell_curvature\"] = torch.cat(d[\"2_cell_curvature\"], dim=0)\n",
-    "\n",
-    "\n",
-    "else:\n",
-    "    data = next(iter(datamodule.train_dataloader()))\n",
-    "\n",
-    "\n",
-    "data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['2_cell_curvature',\n",
-       " 'test_mask',\n",
-       " '0_cell_curvature',\n",
-       " 'x',\n",
-       " '1_cell_curvature',\n",
-       " 'shape',\n",
-       " 'val_mask',\n",
-       " 'batch',\n",
-       " 'ptr',\n",
-       " 'y',\n",
-       " 'train_mask',\n",
-       " 'edge_index']"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "next(iter(datamodule.train_dataloader())).keys()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1800x400 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np\n",
-    "\n",
-    "# Create subplots with one row and three columns\n",
-    "fig, axes = plt.subplots(1, 3, figsize=(18, 4))\n",
-    "\n",
-    "# Plot the histogram 0_cell_curvature and remove outliers\n",
-    "zero_cell_curvature = data[\"0_cell_curvature\"].numpy().flatten()\n",
-    "percentile = np.percentile(zero_cell_curvature, 5)\n",
-    "zero_cell_curvature = zero_cell_curvature[zero_cell_curvature > percentile]\n",
-    "axes[0].hist(zero_cell_curvature, bins=100)\n",
-    "axes[0].set_title(\"Histogram 0_cell_curvature\")\n",
-    "\n",
-    "# Plot the histogram 1_cell_curvature and remove outliers\n",
-    "one_cell_curvature = data[\"1_cell_curvature\"].numpy().flatten()\n",
-    "percentile = np.percentile(one_cell_curvature, 5)\n",
-    "one_cell_curvature = one_cell_curvature[one_cell_curvature > percentile]\n",
-    "axes[1].hist(one_cell_curvature, bins=100)\n",
-    "axes[1].set_title(\"Histogram 1_cell_curvature\")\n",
-    "\n",
-    "# Plot the histogram 2_cell_curvature and remove outliers\n",
-    "two_cell_curvature = data[\"2_cell_curvature\"].numpy().flatten()\n",
-    "percentile = np.percentile(two_cell_curvature, 5)\n",
-    "two_cell_curvature = two_cell_curvature[two_cell_curvature > percentile]\n",
-    "axes[2].hist(two_cell_curvature, bins=100)\n",
-    "axes[2].set_title(\"Histogram 2_cell_curvature\")\n",
-    "\n",
-    "# Show the plots\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "one_cell_curvature = data[\"1_cell_curvature\"].numpy().flatten()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.9442970822281167"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Correct plotting of manual graph"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 800x800 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import networkx as nx\n",
-    "from matplotlib.patches import Polygon\n",
-    "\n",
-    "# Define the vertices (just 7 vertices)\n",
-    "vertices = [i for i in range(9)]\n",
-    "\n",
-    "edges = []\n",
-    "for edge in abs(data.incidence_1.to_dense().T):\n",
-    "    edges.append(torch.where(edge == 1)[0].numpy())\n",
-    "edges = np.array(edges)\n",
-    "\n",
-    "# Define the tetrahedrons\n",
-    "tetrahedrons = [[0, 1, 2, 3], [0, 1, 2, 4]]\n",
-    "\n",
-    "# Create a graph\n",
-    "G = nx.Graph()\n",
-    "\n",
-    "# Add vertices\n",
-    "G.add_nodes_from(vertices)\n",
-    "\n",
-    "# Add edges\n",
-    "G.add_edges_from(edges)\n",
-    "# G.to_undirected()\n",
-    "\n",
-    "\n",
-    "# Find cliques\n",
-    "# cliques = list(nx.find_cliques(G))\n",
-    "# Get all triangles in the graph\n",
-    "cliques = list(nx.enumerate_all_cliques(G))\n",
-    "\n",
-    "# Filter triangles of order 3\n",
-    "cliques = [triangle for triangle in cliques if len(triangle) == 3]\n",
-    "\n",
-    "# Plot the graph with edge indices using other layout\n",
-    "pos = nx.spring_layout(G, seed=5)\n",
-    "\n",
-    "# Draw the graph with labels\n",
-    "nx.draw(\n",
-    "    G,\n",
-    "    pos,\n",
-    "    labels={i: f\"v_{i}\" for i in G.nodes()},\n",
-    "    node_size=500,\n",
-    "    node_color=\"skyblue\",\n",
-    "    font_size=12,\n",
-    ")\n",
-    "\n",
-    "# Draw edges with different color and thickness\n",
-    "nx.draw_networkx_edges(G, pos, edgelist=edges, edge_color=\"g\", width=2, alpha=0.5)\n",
-    "\n",
-    "# Add edge indices\n",
-    "for i, (u, v) in enumerate(edges):\n",
-    "    x = (pos[u][0] + pos[v][0]) / 2\n",
-    "    y = (pos[u][1] + pos[v][1]) / 2\n",
-    "    plt.text(x, y, f\"e_{i}\", fontsize=10, color=\"r\")\n",
-    "\n",
-    "# Color the faces (cliques)\n",
-    "face_color_map = {\n",
-    "    0: \"pink\",\n",
-    "    1: \"gray\",\n",
-    "    2: \"blue\",\n",
-    "    3: \"blue\",\n",
-    "    4: \"orange\",\n",
-    "    5: \"purple\",\n",
-    "    6: \"red\",\n",
-    "    7: \"brown\",\n",
-    "    8: \"black\",\n",
-    "    9: \"gray\",\n",
-    "}\n",
-    "\n",
-    "for i, clique in enumerate(cliques):\n",
-    "    # Get the face color:\n",
-    "    # Calculate to how many tetrahedrons cique belongs\n",
-    "    # Then assign the color to the face\n",
-    "    counter = 0\n",
-    "    for tetrahedron in tetrahedrons:\n",
-    "        from itertools import combinations\n",
-    "\n",
-    "        for comb in combinations(tetrahedron, 3):\n",
-    "            if set(clique) == set(comb):\n",
-    "                counter += 1\n",
-    "\n",
-    "    polygon = [pos[v] for v in clique]\n",
-    "    poly = Polygon(\n",
-    "        polygon,\n",
-    "        closed=True,\n",
-    "        facecolor=face_color_map[counter],\n",
-    "        edgecolor=\"pink\",\n",
-    "        alpha=0.3,\n",
-    "    )\n",
-    "    plt.gca().add_patch(poly)\n",
-    "\n",
-    "plt.title(\"Graph with cliques colored (9 vertices)\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Triangle: 0 Curvature: 4.0\n",
-      "Triangle: 1 Curvature: 3.0\n",
-      "Triangle: 2 Curvature: 3.0\n",
-      "Triangle: 3 Curvature: 1.0\n",
-      "Triangle: 4 Curvature: 2.0\n",
-      "Triangle: 5 Curvature: 0.0\n",
-      "Triangle: 6 Curvature: 2.0\n",
-      "Triangle: 7 Curvature: 3.0\n",
-      "Triangle: 8 Curvature: 0.0\n",
-      "Triangle: 9 Curvature: 2.0\n"
-     ]
-    }
-   ],
-   "source": [
-    "for i, frc in enumerate(data[\"2_cell_curvature\"].numpy().flatten()):\n",
-    "    print(\"Triangle:\", i, \"Curvature:\", frc)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# e_10 = {v_2,v_5} \\in R^{2, d}\n",
-    "# e_14 = {v_5,v_6}\n",
-    "# e_11 = {v_2,v_6}\n",
-    "\n",
-    "# t_1  = {v_2,v_5,v_6}\n",
-    "\n",
-    "\n",
-    "# 1. {e_11, e_14} = MHA({e_11, e_14}, {e_11, e_14})\n",
-    "# 2. e_10 = MHA(e_10, {e_11, e_14})\n",
-    "\n",
-    "\n",
-    "# Q=W_Q{e_11, e_14}\n",
-    "# K=W_K{e_11, e_14}\n",
-    "# V=W_V{e_11, e_14}\n",
-    "\n",
-    "# Att=  sigma (Q*K.T) / sqrt(d), \\in (2,2)\n",
-    "\n",
-    "# Att V = [[alpha1 * e_11 + alpha2 * e_14], [alpha3 * e_11 + alpha4 * e_14]]\n",
-    "\n",
-    "\n",
-    "# {[v_2, v_6], [v_5, v_6]} -- multiset\n",
-    "\n",
-    "\n",
-    "# ----------------------------------\n",
-    "# e_10 = W[v_2, v_5]\n",
-    "# e_14 = W[v_5, v_6]\n",
-    "# e_11 = W[v_2, v_6]\n",
-    "\n",
-    "# t_1  = W[v_2, v_5, v_6]\n",
-    "# ----------------------------------\n",
-    "# Precompute the edeg features from random walks\n",
-    "# e_10 = e_rw\n",
-    "\n",
-    "# e_10 = [1/2 v_2 + 1/2 v_5, e_rw]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "v_0 5.0\n",
-      "v_1 4.0\n",
-      "v_2 7.0\n",
-      "v_3 4.0\n",
-      "v_4 3.0\n",
-      "v_5 3.0\n",
-      "v_6 3.0\n",
-      "v_7 1.0\n",
-      "v_8 2.0\n"
-     ]
-    }
-   ],
-   "source": [
-    "for i, degree in enumerate(data[\"0_cell_degrees\"].numpy().flatten()):\n",
-    "    print(f\"v_{i}\", degree)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for i, degree in enumerate(data[\"1_cell_degrees\"].numpy().flatten()):\n",
-    "    print(f\"e_{i}\", degree)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "frc_(e_0) 4.0\n",
-      "frc_(e_1) 4.0\n",
-      "frc_(e_2) 1.0\n",
-      "frc_(e_3) 2.0\n",
-      "frc_(e_4) 0.0\n",
-      "frc_(e_5) 2.0\n",
-      "frc_(e_6) 2.0\n",
-      "frc_(e_7) 3.0\n",
-      "frc_(e_8) 2.0\n",
-      "frc_(e_9) 0.0\n",
-      "frc_(e_10) -3.0\n",
-      "frc_(e_11) 0.0\n",
-      "frc_(e_12) -2.0\n",
-      "frc_(e_13) 0.0\n",
-      "frc_(e_14) 1.0\n",
-      "frc_(e_15) 0.0\n"
-     ]
-    }
-   ],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.0"
-      ]
-     },
-     "execution_count": 69,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "data[\"0_cell_curvature\"].numpy().flatten()[7]"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "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.11.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/notebooks/curvature_results.ipynb b/notebooks/curvature_results.ipynb
deleted file mode 100644
index ea591cdc..00000000
--- a/notebooks/curvature_results.ipynb
+++ /dev/null
@@ -1,1789 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import ast\n",
-    "import glob\n",
-    "import warnings\n",
-    "from collections import defaultdict\n",
-    "from datetime import date\n",
-    "\n",
-    "import pandas as pd\n",
-    "import wandb\n",
-    "\n",
-    "today = date.today()\n",
-    "api = wandb.Api()\n",
-    "\n",
-    "# # Find all csv files in the current directory\n",
-    "csv_files = glob.glob(\"*.csv\")\n",
-    "# # Collect all the names of the csv files without the extension\n",
-    "csv_names = [csv_file[:-4] for csv_file in csv_files]\n",
-    "project_name = \"topobenchmark_22Apr2024\"  #'best_results_edhnn'\n",
-    "user = \"telyatnikov_sap\"\n",
-    "\n",
-    "if project_name not in csv_names:\n",
-    "    runs = api.runs(f\"{user}/{project_name}\")\n",
-    "\n",
-    "    summary_list, config_list, name_list = [], [], []\n",
-    "    for run in runs:\n",
-    "        # .summary contains the output keys/values for metrics like accuracy.\n",
-    "        #  We call ._json_dict to omit large files\n",
-    "        summary_list.append(run.summary._json_dict)\n",
-    "\n",
-    "        # .config contains the hyperparameters.\n",
-    "        #  We remove special values that start with _.\n",
-    "        config_list.append(\n",
-    "            {k: v for k, v in run.config.items() if not k.startswith(\"_\")}\n",
-    "        )\n",
-    "\n",
-    "        # .name is the human-readable name of the run.\n",
-    "        name_list.append(run.name)\n",
-    "\n",
-    "    runs_df = pd.DataFrame(\n",
-    "        {\"summary\": summary_list, \"config\": config_list, \"name\": name_list}\n",
-    "    )\n",
-    "\n",
-    "    runs_df.to_csv(f\"{project_name}.csv\")\n",
-    "else:\n",
-    "    runs_df = pd.read_csv(f\"{project_name}.csv\", index_col=0)\n",
-    "\n",
-    "    for row in runs_df.iloc:\n",
-    "        row[\"summary\"] = ast.literal_eval(row[\"summary\"])\n",
-    "        row[\"config\"] = ast.literal_eval(row[\"config\"])\n",
-    "\n",
-    "\n",
-    "for row in runs_df.iloc:\n",
-    "    row[\"summary\"].update(row[\"config\"])\n",
-    "\n",
-    "lst = [i[\"summary\"] for i in runs_df.iloc]\n",
-    "df = pd.DataFrame.from_dict(lst)\n",
-    "\n",
-    "df_init = df.copy()\n",
-    "\n",
-    "# Get average epoch run time\n",
-    "df[\"epoch_run_time\"] = df[\"_runtime\"] / df[\"epoch\"]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def normalize_column(df, column_to_normalize):\n",
-    "    # Use json_normalize to flatten the nested dictionaries into separate columns\n",
-    "    flattened_df = pd.json_normalize(df[column_to_normalize])\n",
-    "    # Rename columns to include 'nested_column' prefix\n",
-    "    flattened_df.columns = [\n",
-    "        f\"{column_to_normalize}.{col}\" for col in flattened_df.columns\n",
-    "    ]\n",
-    "    # Concatenate the flattened DataFrame with the original DataFrame\n",
-    "    result_df = pd.concat([df, flattened_df], axis=1)\n",
-    "    # Get new columns names\n",
-    "    new_columns = flattened_df.columns\n",
-    "    # Drop the original nested column if needed\n",
-    "    result_df.drop(column_to_normalize, axis=1, inplace=True)\n",
-    "    return result_df, new_columns\n",
-    "\n",
-    "\n",
-    "# Config columns to normalize\n",
-    "columns_to_normalize = [\"model\", \"dataset\", \"callbacks\"]\n",
-    "\n",
-    "# Keep track of config columns added\n",
-    "config_columns = []\n",
-    "for column in columns_to_normalize:\n",
-    "    df, columns = normalize_column(df, column)\n",
-    "    config_columns.extend(columns)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Remove columns that are not needed (we shouldn't vary them or their variation is not interesting)\n",
-    "remove_col = [\n",
-    "    \"dataset.transforms.data_manipulations.selected_fields\",\n",
-    "    \"callbacks.model_checkpoint.dirpath\",\n",
-    "    \"dataset.transforms.infere_knn_connectivity.args.k\",\n",
-    "    \"dataset.transforms.infere_knn_connectivity.args.loop\",\n",
-    "    \"dataset.transforms.infere_knn_connectivity.args.cosine\",\n",
-    "    \"dataset.transforms.infere_knn_connectivity._target_\",\n",
-    "    \"dataset.transforms.infere_knn_connectivity.transform_type\",\n",
-    "]\n",
-    "for col in remove_col:\n",
-    "    if col in df.columns:\n",
-    "        df = df.drop(col, axis=1)\n",
-    "\n",
-    "\n",
-    "# Ensure that removed columns are not present in config_columns\n",
-    "config_columns = [col for col in config_columns if col != remove_col]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/tmp/ipykernel_36951/1961035444.py:1: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
-      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
-      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
-      "\n",
-      "df[\"col\"][row_indexer] = value\n",
-      "\n",
-      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n",
-      "\n",
-      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
-      "\n",
-      "  df['dataset.transforms.infere_knn_connectivity.transform_name'][df['dataset.transforms.infere_knn_connectivity.transform_name']!='InfereKNNConnectivity'] = False\n",
-      "/tmp/ipykernel_36951/1961035444.py:1: SettingWithCopyWarning: \n",
-      "A value is trying to be set on a copy of a slice from a DataFrame\n",
-      "\n",
-      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
-      "  df['dataset.transforms.infere_knn_connectivity.transform_name'][df['dataset.transforms.infere_knn_connectivity.transform_name']!='InfereKNNConnectivity'] = False\n",
-      "/tmp/ipykernel_36951/1961035444.py:2: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
-      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
-      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
-      "\n",
-      "df[\"col\"][row_indexer] = value\n",
-      "\n",
-      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n",
-      "\n",
-      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
-      "\n",
-      "  df['dataset.transforms.infere_knn_connectivity.transform_name'][df['dataset.transforms.infere_knn_connectivity.transform_name']=='InfereKNNConnectivity'] = True\n",
-      "/tmp/ipykernel_36951/1961035444.py:2: SettingWithCopyWarning: \n",
-      "A value is trying to be set on a copy of a slice from a DataFrame\n",
-      "\n",
-      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
-      "  df['dataset.transforms.infere_knn_connectivity.transform_name'][df['dataset.transforms.infere_knn_connectivity.transform_name']=='InfereKNNConnectivity'] = True\n"
-     ]
-    }
-   ],
-   "source": [
-    "df[\"dataset.transforms.infere_knn_connectivity.transform_name\"][\n",
-    "    df[\"dataset.transforms.infere_knn_connectivity.transform_name\"]\n",
-    "    != \"InfereKNNConnectivity\"\n",
-    "] = False\n",
-    "df[\"dataset.transforms.infere_knn_connectivity.transform_name\"][\n",
-    "    df[\"dataset.transforms.infere_knn_connectivity.transform_name\"]\n",
-    "    == \"InfereKNNConnectivity\"\n",
-    "] = True\n",
-    "\n",
-    "df[\"Infere Connectivity\"] = df[\n",
-    "    \"dataset.transforms.infere_knn_connectivity.transform_name\"\n",
-    "]\n",
-    "df = df.drop(\"dataset.transforms.infere_knn_connectivity.transform_name\", axis=1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Number of rows with model.backbone._target_ = nan is 7\n",
-      "Number of rows with callbacks.early_stopping.monitor = nan is 0\n",
-      "Because of SCCN and CWN false runs there were 96 such runs on 13/03/24\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\n",
-    "    f\"Number of rows with model.backbone._target_ = nan is {sum(df['model.backbone._target_'].isna())}\"\n",
-    ")\n",
-    "# Drop na values if there are\n",
-    "df = df.dropna(subset=[\"model.backbone._target_\"])\n",
-    "# Reset index\n",
-    "df = df.reset_index(drop=True)\n",
-    "\n",
-    "# Drop rows that 'callbacks.early_stopping.monitor' isna\n",
-    "print(\n",
-    "    f\"Number of rows with callbacks.early_stopping.monitor = nan is {sum(df['callbacks.early_stopping.monitor'].isna())}\"\n",
-    ")\n",
-    "print(\"Because of SCCN and CWN false runs there were 96 such runs on 13/03/24\")\n",
-    "df = df.dropna(subset=[\"callbacks.early_stopping.monitor\"])\n",
-    "# Reset index\n",
-    "df = df.reset_index(drop=True)\n",
-    "\n",
-    "\n",
-    "# Get correct names for the models\n",
-    "df[\"model.backbone._target_\"] = df[\"model.backbone._target_\"].apply(\n",
-    "    lambda x: x.split(\".\")[-1]\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0       False\n",
-       "1       False\n",
-       "2       False\n",
-       "3       False\n",
-       "4       False\n",
-       "        ...  \n",
-       "4827    False\n",
-       "4828    False\n",
-       "4829    False\n",
-       "4830    False\n",
-       "4831    False\n",
-       "Name: Infere Connectivity, Length: 4832, dtype: object"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "df[\"Infere Connectivity\"]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.parameters.num_features, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.k, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.loop, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.cosine, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity._target_, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_name, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_type, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCN2 on MUTAG:\n",
-      "model.readout.in_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.backbone.in_channels_0: [64. 16.]\n",
-      "\n",
-      "model.backbone.in_channels_1: [64. 16.]\n",
-      "\n",
-      "model.backbone.in_channels_2: [64. 16.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 16.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [16. 32.]\n",
-      "\n",
-      "Infere Connectivity: [False True]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.parameters.num_features, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.k, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.loop, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.cosine, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity._target_, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_name, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_type, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GCN on MUTAG:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [64. 32.]\n",
-      "\n",
-      "Infere Connectivity: [True False]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.k, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.loop, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.cosine, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity._target_, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_name, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_type, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCN2 on NCI1:\n",
-      "model.readout.in_channels: [16. 64.]\n",
-      "\n",
-      "model.backbone.n_layers: [1. 2.]\n",
-      "\n",
-      "model.backbone.in_channels_0: [16. 64.]\n",
-      "\n",
-      "model.backbone.in_channels_1: [16. 64.]\n",
-      "\n",
-      "model.backbone.in_channels_2: [16. 64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.01  0.001]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [16. 64.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [16. 64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [3. 0. 5.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [ 32. 128.]\n",
-      "\n",
-      "Infere Connectivity: [True False]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.k, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.loop, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.cosine, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity._target_, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_name, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_type, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GCN on NCI1:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "Infere Connectivity: [False True]\n",
-      "\n",
-      "---------\n",
-      "---------\n",
-      "No results for SCN2 on REDDIT-BINARY\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.k, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.loop, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.cosine, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity._target_, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_name, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_type, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GCN on REDDIT-BINARY:\n",
-      "model.readout.in_channels: [128.  64. 256.]\n",
-      "\n",
-      "model.optimizer.lr: [0.01  0.001]\n",
-      "\n",
-      "model.backbone.dropout: [0.   0.5  0.25]\n",
-      "\n",
-      "model.backbone.num_layers: [1. 4. 3. 2.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [128.  64. 256.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [0. 5. 3.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "Infere Connectivity: [True False]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.k, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.loop, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.cosine, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity._target_, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_name, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_type, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCN2 on ZINC:\n",
-      "model.readout.in_channels: [16. 64.]\n",
-      "\n",
-      "model.backbone.n_layers: [1. 4. 2.]\n",
-      "\n",
-      "model.backbone.in_channels_0: [16. 64.]\n",
-      "\n",
-      "model.backbone.in_channels_1: [16. 64.]\n",
-      "\n",
-      "model.backbone.in_channels_2: [16. 64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.01  0.001]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [16. 64.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [16. 64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [0. 3.]\n",
-      "\n",
-      "Infere Connectivity: [True False]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.k, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.loop, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.cosine, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity._target_, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_name, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_type, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GCN on ZINC:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "Infere Connectivity: [True False]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.k, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.loop, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.cosine, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity._target_, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_name, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_type, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCN2 on PROTEINS:\n",
-      "model.readout.in_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.backbone.in_channels_0: [64. 16.]\n",
-      "\n",
-      "model.backbone.in_channels_1: [64. 16.]\n",
-      "\n",
-      "model.backbone.in_channels_2: [64. 16.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 16.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [ 32. 128.]\n",
-      "\n",
-      "Infere Connectivity: [True False]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.k, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.loop, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.cosine, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity._target_, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_name, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_type, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GCN on PROTEINS:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "Infere Connectivity: [True False]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.k, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.loop, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.cosine, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity._target_, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_name, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_type, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCN2 on PubMed:\n",
-      "model.readout.in_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.backbone.in_channels_0: [64. 32.]\n",
-      "\n",
-      "model.backbone.in_channels_1: [64. 32.]\n",
-      "\n",
-      "model.backbone.in_channels_2: [64. 32.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 32.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [3. 0. 5.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.k, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.loop, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.cosine, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity._target_, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_name, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_type, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GCN on PubMed:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.k, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.loop, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.cosine, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity._target_, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_name, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_type, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCN2 on Cora:\n",
-      "model.readout.in_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.backbone.in_channels_0: [64. 32.]\n",
-      "\n",
-      "model.backbone.in_channels_1: [64. 32.]\n",
-      "\n",
-      "model.backbone.in_channels_2: [64. 32.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 32.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "Infere Connectivity: [True False]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.k, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.loop, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.cosine, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity._target_, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_name, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_type, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GCN on Cora:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "Infere Connectivity: [True False]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.k, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.loop, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.cosine, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity._target_, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_name, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_type, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCN2 on citeseer:\n",
-      "model.readout.in_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.backbone.in_channels_0: [64. 32.]\n",
-      "\n",
-      "model.backbone.in_channels_1: [64. 32.]\n",
-      "\n",
-      "model.backbone.in_channels_2: [64. 32.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 32.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.k, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.loop, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.args.cosine, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity._target_, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_name, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.infere_knn_connectivity.transform_type, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GCN on citeseer:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "Infere Connectivity: [True False]\n",
-      "\n",
-      "---------\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Identify unique models in DataFrame\n",
-    "unique_models = df[\"model.backbone._target_\"].unique()\n",
-    "\n",
-    "# Identify unique datasets in DataFrame\n",
-    "unique_datasets = df[\"dataset.parameters.data_name\"].unique()\n",
-    "\n",
-    "\n",
-    "collected_results = defaultdict(dict)\n",
-    "collected_aggregated_results = defaultdict(dict)\n",
-    "collected_non_aggregated_results = defaultdict(dict)\n",
-    "# Got over each dataset and model and find the best result\n",
-    "for dataset in unique_datasets:\n",
-    "    for model in unique_models:\n",
-    "        # Get the subset of the DataFrame for the current dataset and model\n",
-    "        subset = df[\n",
-    "            (df[\"dataset.parameters.data_name\"] == dataset)\n",
-    "            & (df[\"model.backbone._target_\"] == model)\n",
-    "        ]\n",
-    "\n",
-    "        if subset.empty:\n",
-    "            print(\"---------\")\n",
-    "            print(f\"No results for {model} on {dataset}\")\n",
-    "            print(\"---------\")\n",
-    "            continue\n",
-    "        # Suppress all warnings\n",
-    "        warnings.filterwarnings(\"ignore\")\n",
-    "        subset[\"Model\"] = model\n",
-    "        warnings.filterwarnings(\"default\")\n",
-    "\n",
-    "        def get_metric(df):\n",
-    "            metric_ = df[\"callbacks.early_stopping.monitor\"].unique()\n",
-    "            assert len(metric_) == 1, \"There should be only one metric to optimize\"\n",
-    "            metric = metric_[0]\n",
-    "            return metric.split(\"/\")[-1]\n",
-    "\n",
-    "        # Cols to get statistics later\n",
-    "        performance_cols = [f\"val/{get_metric(subset)}\", f\"test/{get_metric(subset)}\"]\n",
-    "\n",
-    "        # Get the unique values for each config column\n",
-    "        unique_colums_values = {}\n",
-    "        for col in config_columns + [\"Infere Connectivity\"]:\n",
-    "            try:\n",
-    "                unique_colums_values[col] = subset[col].unique()\n",
-    "            except:\n",
-    "                print(f\"Attention the columns: {col}, has issues with unique values\")\n",
-    "\n",
-    "        # Keep only those keys that have more than one unique value\n",
-    "        unique_colums_values = {\n",
-    "            k: v for k, v in unique_colums_values.items() if len(v) > 1\n",
-    "        }\n",
-    "\n",
-    "        # Print the unique values for each config column\n",
-    "\n",
-    "        print(f\"Unique values for each config column for {model} on {dataset}:\")\n",
-    "        for col, unique in unique_colums_values.items():\n",
-    "            print(f\"{col}: {unique}\")\n",
-    "            print()\n",
-    "        print(\"---------\")\n",
-    "\n",
-    "        # Check if \"special colums\" are not in unique_colums_values\n",
-    "        # For example dataset.parameters.data_seed should not be in aggregation columns\n",
-    "        # If it is, then we should remove it from the list\n",
-    "        special_columns = [\"dataset.parameters.data_seed\"]\n",
-    "\n",
-    "        for col in special_columns:\n",
-    "            if col in unique_colums_values:\n",
-    "                unique_colums_values.pop(col)\n",
-    "\n",
-    "        # Obtain the aggregation columns\n",
-    "        aggregation_columns = [\"Model\"] + list(unique_colums_values.keys())\n",
-    "\n",
-    "        # Check if there if \"Infere Connectivity\" if not add it to aggregation columns\n",
-    "        if \"Infere Connectivity\" not in aggregation_columns:\n",
-    "            aggregation_columns.append(\"Infere Connectivity\")\n",
-    "\n",
-    "        collected_non_aggregated_results[dataset][model] = {\n",
-    "            \"df\": subset.copy(),\n",
-    "            \"aggregation_columns\": aggregation_columns,\n",
-    "            \"performance_cols\": performance_cols,\n",
-    "        }\n",
-    "\n",
-    "        # Aggregate the subset by the aggregation columns and get the best result for each group\n",
-    "        aggregated = subset.groupby(aggregation_columns).agg(\n",
-    "            {col: [\"mean\", \"std\"] for col in performance_cols}\n",
-    "        )\n",
-    "\n",
-    "        # Go from MultiIndex to Index\n",
-    "        aggregated = aggregated.reset_index()\n",
-    "\n",
-    "        assert (\n",
-    "            len(subset[\"callbacks.early_stopping.mode\"].unique()) == 1\n",
-    "        ), \"There should be only one mode for early stopping\"\n",
-    "        # Identify the mode of the early stopping mode\n",
-    "\n",
-    "        # Find best results with respect to the validation set\n",
-    "        if subset[\"callbacks.early_stopping.mode\"].unique()[0] == \"max\":\n",
-    "            ascending = False\n",
-    "            final_best_ = aggregated.sort_values(\n",
-    "                by=(f\"val/{get_metric(subset)}\", \"mean\"), ascending=ascending\n",
-    "            ).head(1)\n",
-    "            final_best_ = (final_best_ * 100).round(2)\n",
-    "        else:\n",
-    "            ascending = True\n",
-    "            final_best_ = aggregated.sort_values(\n",
-    "                by=(f\"val/{get_metric(subset)}\", \"mean\"), ascending=ascending\n",
-    "            ).head(1)\n",
-    "\n",
-    "        # Get the best with respect to test set\n",
-    "        collected_results[dataset][model] = {\n",
-    "            \"mean\": final_best_[(f\"test/{get_metric(subset)}\", \"mean\")].values[0],\n",
-    "            \"std\": final_best_[(f\"test/{get_metric(subset)}\", \"std\")].values[0],\n",
-    "        }\n",
-    "        collected_aggregated_results[dataset][model] = aggregated.sort_values(\n",
-    "            by=(f\"val/{get_metric(subset)}\", \"mean\"), ascending=ascending\n",
-    "        )\n",
-    "\n",
-    "    #  break\n",
-    "\n",
-    "    # break"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "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>epoch</th>\n",
-       "      <th>val/loss</th>\n",
-       "      <th>_timestamp</th>\n",
-       "      <th>train/loss</th>\n",
-       "      <th>val/accuracy</th>\n",
-       "      <th>trainer/global_step</th>\n",
-       "      <th>_step</th>\n",
-       "      <th>_wandb</th>\n",
-       "      <th>lr-Adam</th>\n",
-       "      <th>_runtime</th>\n",
-       "      <th>...</th>\n",
-       "      <th>callbacks.model_checkpoint.every_n_epochs</th>\n",
-       "      <th>callbacks.model_checkpoint.save_weights_only</th>\n",
-       "      <th>callbacks.model_checkpoint.every_n_train_steps</th>\n",
-       "      <th>callbacks.model_checkpoint.train_time_interval</th>\n",
-       "      <th>callbacks.model_checkpoint.auto_insert_metric_name</th>\n",
-       "      <th>callbacks.model_checkpoint.save_on_train_epoch_end</th>\n",
-       "      <th>callbacks.rich_progress_bar._target_</th>\n",
-       "      <th>callbacks.learning_rate_monitor._target_</th>\n",
-       "      <th>callbacks.learning_rate_monitor.logging_interval</th>\n",
-       "      <th>Infere Connectivity</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>95.0</td>\n",
-       "      <td>0.440755</td>\n",
-       "      <td>1.714498e+09</td>\n",
-       "      <td>0.344573</td>\n",
-       "      <td>0.829787</td>\n",
-       "      <td>570.0</td>\n",
-       "      <td>209.0</td>\n",
-       "      <td>{'runtime': 9}</td>\n",
-       "      <td>0.000731</td>\n",
-       "      <td>11.146549</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>False</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>130.0</td>\n",
-       "      <td>0.698719</td>\n",
-       "      <td>1.714498e+09</td>\n",
-       "      <td>0.250919</td>\n",
-       "      <td>0.765957</td>\n",
-       "      <td>780.0</td>\n",
-       "      <td>286.0</td>\n",
-       "      <td>{'runtime': 11}</td>\n",
-       "      <td>0.000631</td>\n",
-       "      <td>13.230936</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>False</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>100.0</td>\n",
-       "      <td>0.571365</td>\n",
-       "      <td>1.714498e+09</td>\n",
-       "      <td>0.332483</td>\n",
-       "      <td>0.659574</td>\n",
-       "      <td>600.0</td>\n",
-       "      <td>220.0</td>\n",
-       "      <td>{'runtime': 9}</td>\n",
-       "      <td>0.000717</td>\n",
-       "      <td>11.107776</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>False</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>130.0</td>\n",
-       "      <td>0.424564</td>\n",
-       "      <td>1.714498e+09</td>\n",
-       "      <td>0.298073</td>\n",
-       "      <td>0.744681</td>\n",
-       "      <td>780.0</td>\n",
-       "      <td>286.0</td>\n",
-       "      <td>{'runtime': 11}</td>\n",
-       "      <td>0.000631</td>\n",
-       "      <td>13.186315</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>False</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>70.0</td>\n",
-       "      <td>0.591233</td>\n",
-       "      <td>1.714498e+09</td>\n",
-       "      <td>0.316741</td>\n",
-       "      <td>0.723404</td>\n",
-       "      <td>420.0</td>\n",
-       "      <td>154.0</td>\n",
-       "      <td>{'runtime': 6}</td>\n",
-       "      <td>0.000803</td>\n",
-       "      <td>8.108738</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>False</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>...</th>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1426</th>\n",
-       "      <td>60.0</td>\n",
-       "      <td>1.160258</td>\n",
-       "      <td>1.714195e+09</td>\n",
-       "      <td>0.227150</td>\n",
-       "      <td>0.808511</td>\n",
-       "      <td>180.0</td>\n",
-       "      <td>132.0</td>\n",
-       "      <td>{'runtime': 13}</td>\n",
-       "      <td>0.008314</td>\n",
-       "      <td>15.043748</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>True</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1427</th>\n",
-       "      <td>80.0</td>\n",
-       "      <td>0.701639</td>\n",
-       "      <td>1.714195e+09</td>\n",
-       "      <td>0.314709</td>\n",
-       "      <td>0.702128</td>\n",
-       "      <td>240.0</td>\n",
-       "      <td>176.0</td>\n",
-       "      <td>{'runtime': 17}</td>\n",
-       "      <td>0.007743</td>\n",
-       "      <td>18.072189</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>True</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1429</th>\n",
-       "      <td>105.0</td>\n",
-       "      <td>0.421848</td>\n",
-       "      <td>1.714195e+09</td>\n",
-       "      <td>0.286058</td>\n",
-       "      <td>0.787234</td>\n",
-       "      <td>315.0</td>\n",
-       "      <td>231.0</td>\n",
-       "      <td>{'runtime': 21}</td>\n",
-       "      <td>0.007029</td>\n",
-       "      <td>22.765034</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>True</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1430</th>\n",
-       "      <td>75.0</td>\n",
-       "      <td>0.818408</td>\n",
-       "      <td>1.714195e+09</td>\n",
-       "      <td>0.283608</td>\n",
-       "      <td>0.744681</td>\n",
-       "      <td>225.0</td>\n",
-       "      <td>165.0</td>\n",
-       "      <td>{'runtime': 15}</td>\n",
-       "      <td>0.007886</td>\n",
-       "      <td>16.458794</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>True</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1431</th>\n",
-       "      <td>100.0</td>\n",
-       "      <td>0.631320</td>\n",
-       "      <td>1.714195e+09</td>\n",
-       "      <td>0.277067</td>\n",
-       "      <td>0.744681</td>\n",
-       "      <td>300.0</td>\n",
-       "      <td>220.0</td>\n",
-       "      <td>{'runtime': 20}</td>\n",
-       "      <td>0.007171</td>\n",
-       "      <td>21.385238</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>True</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "<p>72 rows × 132 columns</p>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "      epoch  val/loss    _timestamp  train/loss  val/accuracy  \\\n",
-       "0      95.0  0.440755  1.714498e+09    0.344573      0.829787   \n",
-       "1     130.0  0.698719  1.714498e+09    0.250919      0.765957   \n",
-       "2     100.0  0.571365  1.714498e+09    0.332483      0.659574   \n",
-       "3     130.0  0.424564  1.714498e+09    0.298073      0.744681   \n",
-       "4      70.0  0.591233  1.714498e+09    0.316741      0.723404   \n",
-       "...     ...       ...           ...         ...           ...   \n",
-       "1426   60.0  1.160258  1.714195e+09    0.227150      0.808511   \n",
-       "1427   80.0  0.701639  1.714195e+09    0.314709      0.702128   \n",
-       "1429  105.0  0.421848  1.714195e+09    0.286058      0.787234   \n",
-       "1430   75.0  0.818408  1.714195e+09    0.283608      0.744681   \n",
-       "1431  100.0  0.631320  1.714195e+09    0.277067      0.744681   \n",
-       "\n",
-       "      trainer/global_step  _step           _wandb   lr-Adam   _runtime  ...  \\\n",
-       "0                   570.0  209.0   {'runtime': 9}  0.000731  11.146549  ...   \n",
-       "1                   780.0  286.0  {'runtime': 11}  0.000631  13.230936  ...   \n",
-       "2                   600.0  220.0   {'runtime': 9}  0.000717  11.107776  ...   \n",
-       "3                   780.0  286.0  {'runtime': 11}  0.000631  13.186315  ...   \n",
-       "4                   420.0  154.0   {'runtime': 6}  0.000803   8.108738  ...   \n",
-       "...                   ...    ...              ...       ...        ...  ...   \n",
-       "1426                180.0  132.0  {'runtime': 13}  0.008314  15.043748  ...   \n",
-       "1427                240.0  176.0  {'runtime': 17}  0.007743  18.072189  ...   \n",
-       "1429                315.0  231.0  {'runtime': 21}  0.007029  22.765034  ...   \n",
-       "1430                225.0  165.0  {'runtime': 15}  0.007886  16.458794  ...   \n",
-       "1431                300.0  220.0  {'runtime': 20}  0.007171  21.385238  ...   \n",
-       "\n",
-       "      callbacks.model_checkpoint.every_n_epochs  \\\n",
-       "0                                           NaN   \n",
-       "1                                           NaN   \n",
-       "2                                           NaN   \n",
-       "3                                           NaN   \n",
-       "4                                           NaN   \n",
-       "...                                         ...   \n",
-       "1426                                        NaN   \n",
-       "1427                                        NaN   \n",
-       "1429                                        NaN   \n",
-       "1430                                        NaN   \n",
-       "1431                                        NaN   \n",
-       "\n",
-       "      callbacks.model_checkpoint.save_weights_only  \\\n",
-       "0                                            False   \n",
-       "1                                            False   \n",
-       "2                                            False   \n",
-       "3                                            False   \n",
-       "4                                            False   \n",
-       "...                                            ...   \n",
-       "1426                                         False   \n",
-       "1427                                         False   \n",
-       "1429                                         False   \n",
-       "1430                                         False   \n",
-       "1431                                         False   \n",
-       "\n",
-       "      callbacks.model_checkpoint.every_n_train_steps  \\\n",
-       "0                                                NaN   \n",
-       "1                                                NaN   \n",
-       "2                                                NaN   \n",
-       "3                                                NaN   \n",
-       "4                                                NaN   \n",
-       "...                                              ...   \n",
-       "1426                                             NaN   \n",
-       "1427                                             NaN   \n",
-       "1429                                             NaN   \n",
-       "1430                                             NaN   \n",
-       "1431                                             NaN   \n",
-       "\n",
-       "      callbacks.model_checkpoint.train_time_interval  \\\n",
-       "0                                                NaN   \n",
-       "1                                                NaN   \n",
-       "2                                                NaN   \n",
-       "3                                                NaN   \n",
-       "4                                                NaN   \n",
-       "...                                              ...   \n",
-       "1426                                             NaN   \n",
-       "1427                                             NaN   \n",
-       "1429                                             NaN   \n",
-       "1430                                             NaN   \n",
-       "1431                                             NaN   \n",
-       "\n",
-       "     callbacks.model_checkpoint.auto_insert_metric_name  \\\n",
-       "0                                                 False   \n",
-       "1                                                 False   \n",
-       "2                                                 False   \n",
-       "3                                                 False   \n",
-       "4                                                 False   \n",
-       "...                                                 ...   \n",
-       "1426                                              False   \n",
-       "1427                                              False   \n",
-       "1429                                              False   \n",
-       "1430                                              False   \n",
-       "1431                                              False   \n",
-       "\n",
-       "     callbacks.model_checkpoint.save_on_train_epoch_end  \\\n",
-       "0                                                   NaN   \n",
-       "1                                                   NaN   \n",
-       "2                                                   NaN   \n",
-       "3                                                   NaN   \n",
-       "4                                                   NaN   \n",
-       "...                                                 ...   \n",
-       "1426                                                NaN   \n",
-       "1427                                                NaN   \n",
-       "1429                                                NaN   \n",
-       "1430                                                NaN   \n",
-       "1431                                                NaN   \n",
-       "\n",
-       "             callbacks.rich_progress_bar._target_  \\\n",
-       "0     lightning.pytorch.callbacks.RichProgressBar   \n",
-       "1     lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2     lightning.pytorch.callbacks.RichProgressBar   \n",
-       "3     lightning.pytorch.callbacks.RichProgressBar   \n",
-       "4     lightning.pytorch.callbacks.RichProgressBar   \n",
-       "...                                           ...   \n",
-       "1426  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "1427  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "1429  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "1430  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "1431  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "\n",
-       "             callbacks.learning_rate_monitor._target_  \\\n",
-       "0     lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "1     lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2     lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "3     lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "4     lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "...                                               ...   \n",
-       "1426  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "1427  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "1429  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "1430  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "1431  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "\n",
-       "     callbacks.learning_rate_monitor.logging_interval  Infere Connectivity  \n",
-       "0                                               epoch                False  \n",
-       "1                                               epoch                False  \n",
-       "2                                               epoch                False  \n",
-       "3                                               epoch                False  \n",
-       "4                                               epoch                False  \n",
-       "...                                               ...                  ...  \n",
-       "1426                                            epoch                 True  \n",
-       "1427                                            epoch                 True  \n",
-       "1429                                            epoch                 True  \n",
-       "1430                                            epoch                 True  \n",
-       "1431                                            epoch                 True  \n",
-       "\n",
-       "[72 rows x 132 columns]"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "df[\n",
-    "    (df[\"dataset.parameters.data_name\"] == \"MUTAG\")\n",
-    "    & (df[\"model.backbone._target_\"] == \"SCN2\")\n",
-    "]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "collected_results_inferred_connectivity = defaultdict(dict)\n",
-    "\n",
-    "# Get the best result for each dataset and model for InfereKNNConnectivity case\n",
-    "for dataset in [\n",
-    "    \"MUTAG\",\n",
-    "    \"REDDIT-BINARY\",\n",
-    "    \"NCI1\",\n",
-    "    \"PROTEINS\",\n",
-    "    \"PubMed\",\n",
-    "    \"Cora\",\n",
-    "    \"citeseer\",\n",
-    "]:\n",
-    "    for model in collected_aggregated_results[dataset].keys():\n",
-    "        # try:\n",
-    "\n",
-    "        col_name = \"Infere Connectivity\"\n",
-    "        a = collected_aggregated_results[dataset][model]\n",
-    "\n",
-    "        a = a[a[col_name] == True]\n",
-    "\n",
-    "        # Check if there are any results\n",
-    "        if a.empty:\n",
-    "            continue\n",
-    "\n",
-    "        if subset[\"callbacks.early_stopping.mode\"].unique()[0] == \"max\":\n",
-    "            ascending = False\n",
-    "            final_best_ = a.sort_values(\n",
-    "                by=(f\"val/{get_metric(subset)}\", \"mean\"), ascending=ascending\n",
-    "            ).head(1)\n",
-    "            final_best_ = (final_best_ * 100).round(2)\n",
-    "        else:\n",
-    "            ascending = True\n",
-    "            final_best_ = a.sort_values(\n",
-    "                by=(f\"val/{get_metric(subset)}\", \"mean\"), ascending=ascending\n",
-    "            ).head(1)\n",
-    "\n",
-    "        collected_results_inferred_connectivity[dataset][model] = {\n",
-    "            \"mean\": final_best_[(f\"test/{get_metric(subset)}\", \"mean\")].values[0],\n",
-    "            \"std\": final_best_[(f\"test/{get_metric(subset)}\", \"std\")].values[0],\n",
-    "        }\n",
-    "        # except:\n",
-    "        #     pass\n",
-    "\n",
-    "collected_results_original_connectivity = defaultdict(dict)\n",
-    "# Get the best result for each dataset and model for classical case\n",
-    "for dataset in [\n",
-    "    \"REDDIT-BINARY\",\n",
-    "    \"MUTAG\",\n",
-    "    \"NCI1\",\n",
-    "    \"PROTEINS\",\n",
-    "    \"PubMed\",\n",
-    "    \"Cora\",\n",
-    "    \"citeseer\",\n",
-    "]:\n",
-    "    for model in collected_aggregated_results[dataset].keys():\n",
-    "        # try:\n",
-    "\n",
-    "        col_name = \"Infere Connectivity\"\n",
-    "        a = collected_aggregated_results[dataset][model]\n",
-    "\n",
-    "        a = a[a[col_name] == False]\n",
-    "\n",
-    "        # Check if there are any results\n",
-    "        if a.empty:\n",
-    "            continue\n",
-    "\n",
-    "        if subset[\"callbacks.early_stopping.mode\"].unique()[0] == \"max\":\n",
-    "            ascending = False\n",
-    "            final_best_ = a.sort_values(\n",
-    "                by=(f\"val/{get_metric(subset)}\", \"mean\"), ascending=ascending\n",
-    "            ).head(1)\n",
-    "            final_best_ = (final_best_ * 100).round(2)\n",
-    "        else:\n",
-    "            ascending = True\n",
-    "            final_best_ = a.sort_values(\n",
-    "                by=(f\"val/{get_metric(subset)}\", \"mean\"), ascending=ascending\n",
-    "            ).head(1)\n",
-    "\n",
-    "        collected_results_original_connectivity[dataset][model] = {\n",
-    "            \"mean\": final_best_[(f\"test/{get_metric(subset)}\", \"mean\")].values[0],\n",
-    "            \"std\": final_best_[(f\"test/{get_metric(subset)}\", \"std\")].values[0],\n",
-    "        }\n",
-    "        # except:\n",
-    "        #     pass"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "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>Dataset</th>\n",
-       "      <th>Cora</th>\n",
-       "      <th>MUTAG</th>\n",
-       "      <th>NCI1</th>\n",
-       "      <th>PROTEINS</th>\n",
-       "      <th>REDDIT-BINARY</th>\n",
-       "      <th>citeseer</th>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>Model</th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>GCN</th>\n",
-       "      <td>87.2 ± 1.2</td>\n",
-       "      <td>77.3 ± 2.46</td>\n",
-       "      <td>74.19 ± 1.22</td>\n",
-       "      <td>75.27 ± 2.8</td>\n",
-       "      <td>79.53 ± 1.4</td>\n",
-       "      <td>72.11 ± 1.75</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>SCN2</th>\n",
-       "      <td>84.79 ± 1.15</td>\n",
-       "      <td>78.72 ± 2.13</td>\n",
-       "      <td>74.29 ± 1.44</td>\n",
-       "      <td>76.46 ± 1.77</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>73.31 ± 2.55</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "Dataset          Cora         MUTAG          NCI1      PROTEINS REDDIT-BINARY  \\\n",
-       "Model                                                                           \n",
-       "GCN        87.2 ± 1.2   77.3 ± 2.46  74.19 ± 1.22   75.27 ± 2.8   79.53 ± 1.4   \n",
-       "SCN2     84.79 ± 1.15  78.72 ± 2.13  74.29 ± 1.44  76.46 ± 1.77           NaN   \n",
-       "\n",
-       "Dataset      citeseer  \n",
-       "Model                  \n",
-       "GCN      72.11 ± 1.75  \n",
-       "SCN2     73.31 ± 2.55  "
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Convert nested dictionary to DataFrame\n",
-    "nested_dict = dict(collected_results_original_connectivity)\n",
-    "result_dict = pd.DataFrame.from_dict(\n",
-    "    {\n",
-    "        (i, j): nested_dict[i][j]\n",
-    "        for i in nested_dict\n",
-    "        for j in nested_dict[i].keys()\n",
-    "    },\n",
-    "    orient=\"index\",\n",
-    ")\n",
-    "\n",
-    "\n",
-    "result_dict = result_dict.round(2)\n",
-    "result_dict[\"performance\"] = result_dict.apply(\n",
-    "    lambda x: f\"{x['mean']} ± {x['std']}\", axis=1\n",
-    ")\n",
-    "result_dict = result_dict.drop([\"mean\", \"std\"], axis=1)\n",
-    "\n",
-    "# Reset multiindex\n",
-    "result_dict = result_dict.reset_index()\n",
-    "# rename columns\n",
-    "result_dict.columns = [\"Dataset\", \"Model\", \"Performance\"]\n",
-    "\n",
-    "result_dict.pivot_table(\n",
-    "    index=\"Model\", columns=\"Dataset\", values=\"Performance\", aggfunc=\"first\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "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>Dataset</th>\n",
-       "      <th>Cora</th>\n",
-       "      <th>MUTAG</th>\n",
-       "      <th>NCI1</th>\n",
-       "      <th>PROTEINS</th>\n",
-       "      <th>PubMed</th>\n",
-       "      <th>REDDIT-BINARY</th>\n",
-       "      <th>citeseer</th>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>Model</th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>GCN</th>\n",
-       "      <td>67.65 ± 0.82</td>\n",
-       "      <td>80.14 ± 4.43</td>\n",
-       "      <td>68.84 ± 1.38</td>\n",
-       "      <td>74.79 ± 1.36</td>\n",
-       "      <td>81.59 ± 0.28</td>\n",
-       "      <td>76.13 ± 0.81</td>\n",
-       "      <td>56.46 ± 1.53</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>SCN2</th>\n",
-       "      <td>64.3 ± 3.55</td>\n",
-       "      <td>80.14 ± 3.25</td>\n",
-       "      <td>66.93 ± nan</td>\n",
-       "      <td>75.63 ± 1.86</td>\n",
-       "      <td>nan ± nan</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "Dataset          Cora         MUTAG          NCI1      PROTEINS        PubMed  \\\n",
-       "Model                                                                           \n",
-       "GCN      67.65 ± 0.82  80.14 ± 4.43  68.84 ± 1.38  74.79 ± 1.36  81.59 ± 0.28   \n",
-       "SCN2      64.3 ± 3.55  80.14 ± 3.25   66.93 ± nan  75.63 ± 1.86     nan ± nan   \n",
-       "\n",
-       "Dataset REDDIT-BINARY      citeseer  \n",
-       "Model                                \n",
-       "GCN      76.13 ± 0.81  56.46 ± 1.53  \n",
-       "SCN2              NaN           NaN  "
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Convert nested dictionary to DataFrame\n",
-    "nested_dict = dict(collected_results_inferred_connectivity)\n",
-    "result_dict = pd.DataFrame.from_dict(\n",
-    "    {\n",
-    "        (i, j): nested_dict[i][j]\n",
-    "        for i in nested_dict.keys()\n",
-    "        for j in nested_dict[i].keys()\n",
-    "    },\n",
-    "    orient=\"index\",\n",
-    ")\n",
-    "\n",
-    "\n",
-    "result_dict = result_dict.round(2)\n",
-    "result_dict[\"performance\"] = result_dict.apply(\n",
-    "    lambda x: f\"{x['mean']} ± {x['std']}\", axis=1\n",
-    ")\n",
-    "result_dict = result_dict.drop([\"mean\", \"std\"], axis=1)\n",
-    "\n",
-    "# Reset multiindex\n",
-    "result_dict = result_dict.reset_index()\n",
-    "# rename columns\n",
-    "result_dict.columns = [\"Dataset\", \"Model\", \"Performance\"]\n",
-    "result_dict.pivot_table(\n",
-    "    index=\"Model\", columns=\"Dataset\", values=\"Performance\", aggfunc=\"first\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\"\"\"\n",
-    "Cora\n",
-    "GCN 87.2 ± 1.2\n",
-    "SCN 84.79 ± 1.15\n",
-    "\n",
-    "Cora (KNN)\n",
-    "GCN 67.65 ± 0.82\n",
-    "SCN 64.3 ± 3.55\n",
-    "\n",
-    "PROTEINS\n",
-    "GCN 75.27 ± 2.8\n",
-    "SCN 76.46 ± 1.77\n",
-    "\n",
-    "PROTEINS (KNN)\n",
-    "GCN 74.79 ± 1.36\n",
-    "SCN 75.63 ± 1.86\n",
-    "\n",
-    "NCI1\n",
-    "74.19 ± 1.22\n",
-    "74.29 ± 1.44\n",
-    "\n",
-    "NCI1 (KNN)\n",
-    "GCN 68.84 ± 1.38\n",
-    "SCN -- ± --\n",
-    "\n",
-    "\n",
-    "Mutag\n",
-    "GCN 77.3 ± 2.46\n",
-    "SCN 78.72 ± 2.13\n",
-    "\n",
-    "Mutag (KNN)\n",
-    "GCN 80.14 ± 4.43\n",
-    "SCN 80.14 ± 3.25\n",
-    "\"\"\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "collected_results_inferred_connectivity = defaultdict(dict)\n",
-    "\n",
-    "# Get the best result for each dataset and model for InfereKNNConnectivity case\n",
-    "for dataset in [\n",
-    "    \"MUTAG\",\n",
-    "    \"REDDIT-BINARY\",\n",
-    "    \"NCI1\",\n",
-    "    \"PROTEINS\",\n",
-    "    \"PubMed\",\n",
-    "    \"Cora\",\n",
-    "    \"citeseer\",\n",
-    "]:\n",
-    "    for model in collected_aggregated_results[dataset].keys():\n",
-    "        # try:\n",
-    "\n",
-    "        col_name = \"Infere Connectivity\"\n",
-    "        a = collected_aggregated_results[dataset][model]\n",
-    "\n",
-    "        a = a[a[col_name] == True]\n",
-    "\n",
-    "        # Check if there are any results\n",
-    "        if a.empty:\n",
-    "            continue\n",
-    "\n",
-    "        if subset[\"callbacks.early_stopping.mode\"].unique()[0] == \"max\":\n",
-    "            ascending = False\n",
-    "            final_best_ = a.sort_values(\n",
-    "                by=(f\"val/{get_metric(subset)}\", \"mean\"), ascending=ascending\n",
-    "            ).head(1)\n",
-    "            final_best_ = (final_best_ * 100).round(2)\n",
-    "        else:\n",
-    "            ascending = True\n",
-    "            final_best_ = a.sort_values(\n",
-    "                by=(f\"val/{get_metric(subset)}\", \"mean\"), ascending=ascending\n",
-    "            ).head(1)\n",
-    "\n",
-    "        collected_results_inferred_connectivity[dataset][model] = {\n",
-    "            \"mean\": final_best_[(f\"test/{get_metric(subset)}\", \"mean\")].values[0],\n",
-    "            \"std\": final_best_[(f\"test/{get_metric(subset)}\", \"std\")].values[0],\n",
-    "        }\n",
-    "        # except:\n",
-    "        #     pass\n",
-    "\n",
-    "collected_results_original_connectivity = defaultdict(dict)\n",
-    "# Get the best result for each dataset and model for classical case\n",
-    "for dataset in [\n",
-    "    \"REDDIT-BINARY\",\n",
-    "    \"MUTAG\",\n",
-    "    \"NCI1\",\n",
-    "    \"PROTEINS\",\n",
-    "    \"PubMed\",\n",
-    "    \"Cora\",\n",
-    "    \"citeseer\",\n",
-    "]:\n",
-    "    for model in collected_aggregated_results[dataset].keys():\n",
-    "        # try:\n",
-    "\n",
-    "        col_name = \"Infere Connectivity\"\n",
-    "        a = collected_aggregated_results[dataset][model]\n",
-    "\n",
-    "        a = a[a[col_name] == False]\n",
-    "\n",
-    "        # Check if there are any results\n",
-    "        if a.empty:\n",
-    "            continue\n",
-    "\n",
-    "        if subset[\"callbacks.early_stopping.mode\"].unique()[0] == \"max\":\n",
-    "            ascending = False\n",
-    "            final_best_ = a.sort_values(\n",
-    "                by=(f\"val/{get_metric(subset)}\", \"mean\"), ascending=ascending\n",
-    "            ).head(1)\n",
-    "            final_best_ = (final_best_ * 100).round(2)\n",
-    "        else:\n",
-    "            ascending = True\n",
-    "            final_best_ = a.sort_values(\n",
-    "                by=(f\"val/{get_metric(subset)}\", \"mean\"), ascending=ascending\n",
-    "            ).head(1)\n",
-    "\n",
-    "        collected_results_original_connectivity[dataset][model] = {\n",
-    "            \"mean\": final_best_[(f\"test/{get_metric(subset)}\", \"mean\")].values[0],\n",
-    "            \"std\": final_best_[(f\"test/{get_metric(subset)}\", \"std\")].values[0],\n",
-    "        }\n",
-    "        # except:\n",
-    "        #     pass"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "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.11.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/notebooks/data.ipynb b/notebooks/data.ipynb
deleted file mode 100755
index fde4707b..00000000
--- a/notebooks/data.ipynb
+++ /dev/null
@@ -1,1594 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/tmp/ipykernel_477316/1574645353.py:36: UserWarning: \n",
-      "The version_base parameter is not specified.\n",
-      "Please specify a compatability version level, or None.\n",
-      "Will assume defaults for version 1.1\n",
-      "  initialize(config_path=\"../configs\", job_name=\"job\")\n"
-     ]
-    }
-   ],
-   "source": [
-    "import rootutils\n",
-    "\n",
-    "rootutils.setup_root(\"./\", indicator=\".project-root\", pythonpath=True)\n",
-    "\n",
-    "%load_ext autoreload\n",
-    "%autoreload 2\n",
-    "\n",
-    "import hydra\n",
-    "import torch\n",
-    "import torch_geometric\n",
-    "from hydra import compose, initialize\n",
-    "from omegaconf import OmegaConf\n",
-    "\n",
-    "from topobenchmarkx.data.datasets import DataloadDataset\n",
-    "from topobenchmarkx.data.load.loaders import (\n",
-    "    HypergraphLoader,\n",
-    ")\n",
-    "from topobenchmarkx.dataloader_fullbatch import FullBatchDataModule\n",
-    "from topobenchmarkx.utils.config_resolvers import (\n",
-    "    get_default_transform,\n",
-    "    get_monitor_metric,\n",
-    "    get_monitor_mode,\n",
-    "    infer_in_channels,\n",
-    ")\n",
-    "\n",
-    "OmegaConf.register_new_resolver(\"get_default_transform\", get_default_transform)\n",
-    "OmegaConf.register_new_resolver(\"get_monitor_metric\", get_monitor_metric)\n",
-    "OmegaConf.register_new_resolver(\"get_monitor_mode\", get_monitor_mode)\n",
-    "OmegaConf.register_new_resolver(\"infer_in_channels\", infer_in_channels)\n",
-    "OmegaConf.register_new_resolver(\n",
-    "    \"parameter_multiplication\", lambda x, y: int(int(x) * int(y))\n",
-    ")\n",
-    "\n",
-    "initialize(config_path=\"../configs\", job_name=\"job\")\n",
-    "cfg = compose(config_name=\"run.yaml\", return_hydra_config=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "cfg.dataset.transforms.graph2simplicial_lifting.complex_dim = 3"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Processing...\n",
-      "/home/lev/miniconda3/envs/topo/lib/python3.11/site-packages/scipy/sparse/_index.py:145: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil_matrix is more efficient.\n",
-      "  self._set_arrayXarray(i, j, x)\n",
-      "Done!\n",
-      "/home/lev/miniconda3/envs/topo/lib/python3.11/site-packages/torch_geometric/data/in_memory_dataset.py:300: UserWarning: It is not recommended to directly access the internal storage format `data` of an 'InMemoryDataset'. If you are absolutely certain what you are doing, access the internal storage via `InMemoryDataset._data` instead to suppress this warning. Alternatively, you can access stacked individual attributes of every graph via `dataset.{attr_name}`.\n",
-      "  warnings.warn(msg)\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Instantiate and load dataset\n",
-    "dataset = hydra.utils.instantiate(cfg.dataset, _recursive_=False)\n",
-    "dataset = dataset.load()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data = dataset[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Node features: 37\n",
-      "Number of labels: 2\n"
-     ]
-    }
-   ],
-   "source": [
-    "\n",
-    "nci1 = torch_geometric.datasets.TUDataset(\n",
-    "    root=\".\",\n",
-    "    name=\"NCI1\",\n",
-    "    use_node_attr=False,\n",
-    ")\n",
-    "node_features = [data.x.shape[1] for data in nci1][0]\n",
-    "print(\"Node features:\", node_features)\n",
-    "n_labels = torch.unique(torch.tensor([data.y for data in nci1]))\n",
-    "n_labels = len(n_labels)\n",
-    "print(\"Number of labels:\", n_labels)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Downloading https://www.chrsmrrs.com/graphkerneldatasets/NCI109.zip\n",
-      "Processing...\n",
-      "Done!\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Node features: 38\n",
-      "Number of labels: 2\n"
-     ]
-    }
-   ],
-   "source": [
-    "nci1 = torch_geometric.datasets.TUDataset(\n",
-    "    root=\".\",\n",
-    "    name=\"NCI109\",\n",
-    "    use_node_attr=False,\n",
-    ")\n",
-    "node_features = [data.x.shape[1] for data in nci1][0]\n",
-    "print(\"Node features:\", node_features)\n",
-    "n_labels = torch.unique(torch.tensor([data.y for data in nci1]))\n",
-    "n_labels = len(n_labels)\n",
-    "print(\"Number of labels:\", n_labels)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "NCI109(4127)"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "nci1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "imdb = torch_geometric.datasets.TUDataset(\n",
-    "    root=\".\",\n",
-    "    name=\"IMDB-MULTI\",\n",
-    "    use_node_attr=False,\n",
-    ")\n",
-    "max_degree = int(\n",
-    "    max(\n",
-    "        [torch.max(torch_geometric.utils.degree(data.edge_index[0])) for data in imdb]\n",
-    "    ).numpy()\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "3062"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "max_degree"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "x = torch.normal(0, 1, (1, 10))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "tensor([[[-1.2375,  1.0727,  0.3450,  1.0833,  0.4681, -0.1657,  0.5076,\n",
-       "          -0.5245, -0.2753, -1.0917],\n",
-       "         [-1.2375,  1.0727,  0.3450,  1.0833,  0.4681, -0.1657,  0.5076,\n",
-       "          -0.5245, -0.2753, -1.0917],\n",
-       "         [-1.2375,  1.0727,  0.3450,  1.0833,  0.4681, -0.1657,  0.5076,\n",
-       "          -0.5245, -0.2753, -1.0917],\n",
-       "         [-1.2375,  1.0727,  0.3450,  1.0833,  0.4681, -0.1657,  0.5076,\n",
-       "          -0.5245, -0.2753, -1.0917]],\n",
-       "\n",
-       "        [[-1.2375,  1.0727,  0.3450,  1.0833,  0.4681, -0.1657,  0.5076,\n",
-       "          -0.5245, -0.2753, -1.0917],\n",
-       "         [-1.2375,  1.0727,  0.3450,  1.0833,  0.4681, -0.1657,  0.5076,\n",
-       "          -0.5245, -0.2753, -1.0917],\n",
-       "         [-1.2375,  1.0727,  0.3450,  1.0833,  0.4681, -0.1657,  0.5076,\n",
-       "          -0.5245, -0.2753, -1.0917],\n",
-       "         [-1.2375,  1.0727,  0.3450,  1.0833,  0.4681, -0.1657,  0.5076,\n",
-       "          -0.5245, -0.2753, -1.0917]]])"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "x.expand(2, 4, -1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Check if torch_geometric.data has nonempty attribute 'x'"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "imdb[0].x"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 97,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "transform = torch_geometric.transforms.OneHotDegree(max_degree)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 79,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "TypeError",
-     "evalue": "zeros(): argument 'size' must be tuple of ints, but found element of type Tensor at pos 2",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[79], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtorch_geometric\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mutils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mone_hot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtensor\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmax_degree\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m/usr/local/lib/python3.11/site-packages/torch_geometric/utils/one_hot.py:36\u001b[0m, in \u001b[0;36mone_hot\u001b[0;34m(index, num_classes, dtype)\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m num_classes \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m     34\u001b[0m     num_classes \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(index\u001b[38;5;241m.\u001b[39mmax()) \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m---> 36\u001b[0m out \u001b[38;5;241m=\u001b[39m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mzeros\u001b[49m\u001b[43m(\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindex\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msize\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_classes\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     37\u001b[0m \u001b[43m                  \u001b[49m\u001b[43mdevice\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mindex\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     38\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m out\u001b[38;5;241m.\u001b[39mscatter_(\u001b[38;5;241m1\u001b[39m, index\u001b[38;5;241m.\u001b[39munsqueeze(\u001b[38;5;241m1\u001b[39m), \u001b[38;5;241m1\u001b[39m)\n",
-      "\u001b[0;31mTypeError\u001b[0m: zeros(): argument 'size' must be tuple of ints, but found element of type Tensor at pos 2"
-     ]
-    }
-   ],
-   "source": [
-    "torch_geometric.utils.one_hot(torch.tensor([1]), max_degree + 1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 77,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1"
-      ]
-     },
-     "execution_count": 77,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 48,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Data(edge_index=[2, 146], y=[1], num_nodes=20)"
-      ]
-     },
-     "execution_count": 48,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 51,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "TypeError",
-     "evalue": "zeros(): argument 'size' must be tuple of ints, but found element of type Tensor at pos 2",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[51], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtransform\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimdb\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m/usr/local/lib/python3.11/site-packages/torch_geometric/transforms/base_transform.py:32\u001b[0m, in \u001b[0;36mBaseTransform.__call__\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m     30\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, data: Any) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[1;32m     31\u001b[0m     \u001b[38;5;66;03m# Shallow-copy the data so that we prevent in-place data modification.\u001b[39;00m\n\u001b[0;32m---> 32\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mforward\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcopy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m/usr/local/lib/python3.11/site-packages/torch_geometric/transforms/one_hot_degree.py:35\u001b[0m, in \u001b[0;36mOneHotDegree.forward\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m     33\u001b[0m idx, x \u001b[38;5;241m=\u001b[39m data\u001b[38;5;241m.\u001b[39medge_index[\u001b[38;5;241m1\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39min_degree \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;241m0\u001b[39m], data\u001b[38;5;241m.\u001b[39mx\n\u001b[1;32m     34\u001b[0m deg \u001b[38;5;241m=\u001b[39m degree(idx, data\u001b[38;5;241m.\u001b[39mnum_nodes, dtype\u001b[38;5;241m=\u001b[39mtorch\u001b[38;5;241m.\u001b[39mlong)\n\u001b[0;32m---> 35\u001b[0m deg \u001b[38;5;241m=\u001b[39m \u001b[43mone_hot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdeg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_classes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmax_degree\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m     37\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m x \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcat:\n\u001b[1;32m     38\u001b[0m     x \u001b[38;5;241m=\u001b[39m x\u001b[38;5;241m.\u001b[39mview(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m1\u001b[39m) \u001b[38;5;28;01mif\u001b[39;00m x\u001b[38;5;241m.\u001b[39mdim() \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m x\n",
-      "File \u001b[0;32m/usr/local/lib/python3.11/site-packages/torch_geometric/utils/one_hot.py:36\u001b[0m, in \u001b[0;36mone_hot\u001b[0;34m(index, num_classes, dtype)\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m num_classes \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m     34\u001b[0m     num_classes \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(index\u001b[38;5;241m.\u001b[39mmax()) \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m---> 36\u001b[0m out \u001b[38;5;241m=\u001b[39m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mzeros\u001b[49m\u001b[43m(\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindex\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msize\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_classes\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     37\u001b[0m \u001b[43m                  \u001b[49m\u001b[43mdevice\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mindex\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     38\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m out\u001b[38;5;241m.\u001b[39mscatter_(\u001b[38;5;241m1\u001b[39m, index\u001b[38;5;241m.\u001b[39munsqueeze(\u001b[38;5;241m1\u001b[39m), \u001b[38;5;241m1\u001b[39m)\n",
-      "\u001b[0;31mTypeError\u001b[0m: zeros(): argument 'size' must be tuple of ints, but found element of type Tensor at pos 2"
-     ]
-    }
-   ],
-   "source": [
-    "transform(imdb[0])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "tensor(135.)"
-      ]
-     },
-     "execution_count": 36,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "RuntimeError",
-     "evalue": "Index tensor must have the same number of dimensions as self tensor",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[24], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtorch_geometric\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mutils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdegree\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimdb\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43medge_index\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m/usr/local/lib/python3.11/site-packages/torch_geometric/utils/degree.py:31\u001b[0m, in \u001b[0;36mdegree\u001b[0;34m(index, num_nodes, dtype)\u001b[0m\n\u001b[1;32m     29\u001b[0m out \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mzeros((N, ), dtype\u001b[38;5;241m=\u001b[39mdtype, device\u001b[38;5;241m=\u001b[39mindex\u001b[38;5;241m.\u001b[39mdevice)\n\u001b[1;32m     30\u001b[0m one \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mones((index\u001b[38;5;241m.\u001b[39msize(\u001b[38;5;241m0\u001b[39m), ), dtype\u001b[38;5;241m=\u001b[39mout\u001b[38;5;241m.\u001b[39mdtype, device\u001b[38;5;241m=\u001b[39mout\u001b[38;5;241m.\u001b[39mdevice)\n\u001b[0;32m---> 31\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mout\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mscatter_add_\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindex\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mone\u001b[49m\u001b[43m)\u001b[49m\n",
-      "\u001b[0;31mRuntimeError\u001b[0m: Index tensor must have the same number of dimensions as self tensor"
-     ]
-    }
-   ],
-   "source": [
-    "torch_geometric.utils.degree(imdb[0].edge_index)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "TypeError",
-     "evalue": "TUDataset.__init__() missing 2 required positional arguments: 'root' and 'name'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[10], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mtorch_geometric\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[43mtorch_geometric\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdatasets\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mTUDataset\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
-      "\u001b[0;31mTypeError\u001b[0m: TUDataset.__init__() missing 2 required positional arguments: 'root' and 'name'"
-     ]
-    }
-   ],
-   "source": [
-    "import torch_geometric\n",
-    "\n",
-    "torch_geometric.datasets.TUDataset"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'_target_': 'lightning.pytorch.trainer.Trainer', 'default_root_dir': '${paths.output_dir}', 'min_epochs': 1, 'max_epochs': 30, 'accelerator': 'gpu', 'devices': [0], 'check_val_every_n_epoch': 1, 'deterministic': False, 'inference_mode': False}"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "config.trainer"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "InterpolationResolutionError",
-     "evalue": "ValueError raised while resolving interpolation: HydraConfig was not set",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/base.py:764\u001b[0m, in \u001b[0;36mContainer.resolve_parse_tree\u001b[0;34m(self, parse_tree, node, memo, key)\u001b[0m\n\u001b[1;32m    763\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 764\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mvisitor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparse_tree\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    765\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m InterpolationResolutionError:\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/antlr4/tree/Tree.py:34\u001b[0m, in \u001b[0;36mParseTreeVisitor.visit\u001b[0;34m(self, tree)\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mvisit\u001b[39m(\u001b[38;5;28mself\u001b[39m, tree):\n\u001b[0;32m---> 34\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtree\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43maccept\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParser.py:206\u001b[0m, in \u001b[0;36mOmegaConfGrammarParser.ConfigValueContext.accept\u001b[0;34m(self, visitor)\u001b[0m\n\u001b[1;32m    205\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m( visitor, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvisitConfigValue\u001b[39m\u001b[38;5;124m\"\u001b[39m ):\n\u001b[0;32m--> 206\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mvisitor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisitConfigValue\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m    207\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar_visitor.py:101\u001b[0m, in \u001b[0;36mGrammarVisitor.visitConfigValue\u001b[0;34m(self, ctx)\u001b[0m\n\u001b[1;32m    100\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m ctx\u001b[38;5;241m.\u001b[39mgetChildCount() \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m2\u001b[39m\n\u001b[0;32m--> 101\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgetChild\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/antlr4/tree/Tree.py:34\u001b[0m, in \u001b[0;36mParseTreeVisitor.visit\u001b[0;34m(self, tree)\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mvisit\u001b[39m(\u001b[38;5;28mself\u001b[39m, tree):\n\u001b[0;32m---> 34\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtree\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43maccept\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParser.py:342\u001b[0m, in \u001b[0;36mOmegaConfGrammarParser.TextContext.accept\u001b[0;34m(self, visitor)\u001b[0m\n\u001b[1;32m    341\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m( visitor, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvisitText\u001b[39m\u001b[38;5;124m\"\u001b[39m ):\n\u001b[0;32m--> 342\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mvisitor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisitText\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m    343\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar_visitor.py:298\u001b[0m, in \u001b[0;36mGrammarVisitor.visitText\u001b[0;34m(self, ctx)\u001b[0m\n\u001b[1;32m    297\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(c, OmegaConfGrammarParser\u001b[38;5;241m.\u001b[39mInterpolationContext):\n\u001b[0;32m--> 298\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisitInterpolation\u001b[49m\u001b[43m(\u001b[49m\u001b[43mc\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    300\u001b[0m \u001b[38;5;66;03m# Otherwise, concatenate string representations together.\u001b[39;00m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar_visitor.py:125\u001b[0m, in \u001b[0;36mGrammarVisitor.visitInterpolation\u001b[0;34m(self, ctx)\u001b[0m\n\u001b[1;32m    124\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m ctx\u001b[38;5;241m.\u001b[39mgetChildCount() \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m  \u001b[38;5;66;03m# interpolationNode | interpolationResolver\u001b[39;00m\n\u001b[0;32m--> 125\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgetChild\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/antlr4/tree/Tree.py:34\u001b[0m, in \u001b[0;36mParseTreeVisitor.visit\u001b[0;34m(self, tree)\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mvisit\u001b[39m(\u001b[38;5;28mself\u001b[39m, tree):\n\u001b[0;32m---> 34\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtree\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43maccept\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParser.py:1041\u001b[0m, in \u001b[0;36mOmegaConfGrammarParser.InterpolationResolverContext.accept\u001b[0;34m(self, visitor)\u001b[0m\n\u001b[1;32m   1040\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m( visitor, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvisitInterpolationResolver\u001b[39m\u001b[38;5;124m\"\u001b[39m ):\n\u001b[0;32m-> 1041\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mvisitor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisitInterpolationResolver\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1042\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar_visitor.py:179\u001b[0m, in \u001b[0;36mGrammarVisitor.visitInterpolationResolver\u001b[0;34m(self, ctx)\u001b[0m\n\u001b[1;32m    177\u001b[0m         args_str\u001b[38;5;241m.\u001b[39mappend(txt)\n\u001b[0;32m--> 179\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresolver_interpolation_callback\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    180\u001b[0m \u001b[43m    \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mresolver_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    181\u001b[0m \u001b[43m    \u001b[49m\u001b[43margs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mtuple\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    182\u001b[0m \u001b[43m    \u001b[49m\u001b[43margs_str\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mtuple\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs_str\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    183\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/base.py:750\u001b[0m, in \u001b[0;36mContainer.resolve_parse_tree.<locals>.resolver_interpolation_callback\u001b[0;34m(name, args, args_str)\u001b[0m\n\u001b[1;32m    747\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mresolver_interpolation_callback\u001b[39m(\n\u001b[1;32m    748\u001b[0m     name: \u001b[38;5;28mstr\u001b[39m, args: Tuple[Any, \u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m], args_str: Tuple[\u001b[38;5;28mstr\u001b[39m, \u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m]\n\u001b[1;32m    749\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[0;32m--> 750\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_evaluate_custom_resolver\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    751\u001b[0m \u001b[43m        \u001b[49m\u001b[43mkey\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    752\u001b[0m \u001b[43m        \u001b[49m\u001b[43mnode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    753\u001b[0m \u001b[43m        \u001b[49m\u001b[43minter_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    754\u001b[0m \u001b[43m        \u001b[49m\u001b[43minter_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    755\u001b[0m \u001b[43m        \u001b[49m\u001b[43minter_args_str\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43margs_str\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    756\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/base.py:694\u001b[0m, in \u001b[0;36mContainer._evaluate_custom_resolver\u001b[0;34m(self, key, node, inter_type, inter_args, inter_args_str)\u001b[0m\n\u001b[1;32m    693\u001b[0m     root_node \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_root()\n\u001b[0;32m--> 694\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mresolver\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    695\u001b[0m \u001b[43m        \u001b[49m\u001b[43mroot_node\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    696\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    697\u001b[0m \u001b[43m        \u001b[49m\u001b[43mnode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    698\u001b[0m \u001b[43m        \u001b[49m\u001b[43minter_args\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    699\u001b[0m \u001b[43m        \u001b[49m\u001b[43minter_args_str\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    700\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    701\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/omegaconf.py:445\u001b[0m, in \u001b[0;36mOmegaConf.register_new_resolver.<locals>.resolver_wrapper\u001b[0;34m(config, parent, node, args, args_str)\u001b[0m\n\u001b[1;32m    443\u001b[0m     kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_root_\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m config\n\u001b[0;32m--> 445\u001b[0m ret \u001b[38;5;241m=\u001b[39m \u001b[43mresolver\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    447\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m use_cache:\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/hydra/core/utils.py:220\u001b[0m, in \u001b[0;36msetup_globals.<locals>.<lambda>\u001b[0;34m(path)\u001b[0m\n\u001b[1;32m    212\u001b[0m OmegaConf\u001b[38;5;241m.\u001b[39mregister_new_resolver(\n\u001b[1;32m    213\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnow\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m    214\u001b[0m     \u001b[38;5;28;01mlambda\u001b[39;00m pattern: datetime\u001b[38;5;241m.\u001b[39mnow()\u001b[38;5;241m.\u001b[39mstrftime(pattern),\n\u001b[1;32m    215\u001b[0m     use_cache\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m    216\u001b[0m     replace\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m    217\u001b[0m )\n\u001b[1;32m    218\u001b[0m OmegaConf\u001b[38;5;241m.\u001b[39mregister_new_resolver(\n\u001b[1;32m    219\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhydra\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m--> 220\u001b[0m     \u001b[38;5;28;01mlambda\u001b[39;00m path: OmegaConf\u001b[38;5;241m.\u001b[39mselect(cast(DictConfig, \u001b[43mHydraConfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m), path),\n\u001b[1;32m    221\u001b[0m     replace\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m    222\u001b[0m )\n\u001b[1;32m    224\u001b[0m vi \u001b[38;5;241m=\u001b[39m sys\u001b[38;5;241m.\u001b[39mversion_info\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/hydra/core/hydra_config.py:31\u001b[0m, in \u001b[0;36mHydraConfig.get\u001b[0;34m()\u001b[0m\n\u001b[1;32m     30\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m instance\u001b[38;5;241m.\u001b[39mcfg \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m---> 31\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHydraConfig was not set\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m     32\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m instance\u001b[38;5;241m.\u001b[39mcfg\u001b[38;5;241m.\u001b[39mhydra\n",
-      "\u001b[0;31mValueError\u001b[0m: HydraConfig was not set",
-      "\nDuring handling of the above exception, another exception occurred:\n",
-      "\u001b[0;31mInterpolationResolutionError\u001b[0m              Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[4], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m trainer \u001b[38;5;241m=\u001b[39m \u001b[43mhydra\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mutils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minstantiate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrainer\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/hydra/_internal/instantiate/_instantiate2.py:220\u001b[0m, in \u001b[0;36minstantiate\u001b[0;34m(config, *args, **kwargs)\u001b[0m\n\u001b[1;32m    217\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m kwargs:\n\u001b[1;32m    218\u001b[0m     config \u001b[38;5;241m=\u001b[39m OmegaConf\u001b[38;5;241m.\u001b[39mmerge(config, kwargs)\n\u001b[0;32m--> 220\u001b[0m \u001b[43mOmegaConf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresolve\u001b[49m\u001b[43m(\u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    222\u001b[0m _recursive_ \u001b[38;5;241m=\u001b[39m config\u001b[38;5;241m.\u001b[39mpop(_Keys\u001b[38;5;241m.\u001b[39mRECURSIVE, \u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m    223\u001b[0m _convert_ \u001b[38;5;241m=\u001b[39m config\u001b[38;5;241m.\u001b[39mpop(_Keys\u001b[38;5;241m.\u001b[39mCONVERT, ConvertMode\u001b[38;5;241m.\u001b[39mNONE)\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/omegaconf.py:785\u001b[0m, in \u001b[0;36mOmegaConf.resolve\u001b[0;34m(cfg)\u001b[0m\n\u001b[1;32m    779\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m OmegaConf\u001b[38;5;241m.\u001b[39mis_config(cfg):\n\u001b[1;32m    780\u001b[0m     \u001b[38;5;66;03m# Since this function is mutating the input object in-place, it doesn't make sense to\u001b[39;00m\n\u001b[1;32m    781\u001b[0m     \u001b[38;5;66;03m# auto-convert the input object to an OmegaConf container\u001b[39;00m\n\u001b[1;32m    782\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m    783\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInvalid config type (\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mtype\u001b[39m(cfg)\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m), expected an OmegaConf Container\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    784\u001b[0m     )\n\u001b[0;32m--> 785\u001b[0m \u001b[43momegaconf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_impl\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_resolve\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcfg\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/_impl.py:40\u001b[0m, in \u001b[0;36m_resolve\u001b[0;34m(cfg)\u001b[0m\n\u001b[1;32m     38\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(cfg, DictConfig):\n\u001b[1;32m     39\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m cfg\u001b[38;5;241m.\u001b[39mkeys():\n\u001b[0;32m---> 40\u001b[0m         \u001b[43m_resolve_container_value\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcfg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mk\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     42\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(cfg, ListConfig):\n\u001b[1;32m     43\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(cfg)):\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/_impl.py:14\u001b[0m, in \u001b[0;36m_resolve_container_value\u001b[0;34m(cfg, key)\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m node\u001b[38;5;241m.\u001b[39m_is_interpolation():\n\u001b[1;32m     13\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 14\u001b[0m         resolved \u001b[38;5;241m=\u001b[39m \u001b[43mnode\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_dereference_node\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     15\u001b[0m     \u001b[38;5;28;01mexcept\u001b[39;00m InterpolationToMissingValueError:\n\u001b[1;32m     16\u001b[0m         node\u001b[38;5;241m.\u001b[39m_set_value(MISSING)\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/base.py:246\u001b[0m, in \u001b[0;36mNode._dereference_node\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    245\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_dereference_node\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNode\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[0;32m--> 246\u001b[0m     node \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_dereference_node_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[43mthrow_on_resolution_failure\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m    247\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m node \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m    248\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m node\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/base.py:277\u001b[0m, in \u001b[0;36mNode._dereference_node_impl\u001b[0;34m(self, throw_on_resolution_failure, memo)\u001b[0m\n\u001b[1;32m    275\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m parent \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m    276\u001b[0m key \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_key()\n\u001b[0;32m--> 277\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mparent\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_resolve_interpolation_from_parse_tree\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    278\u001b[0m \u001b[43m    \u001b[49m\u001b[43mparent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparent\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    279\u001b[0m \u001b[43m    \u001b[49m\u001b[43mkey\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    280\u001b[0m \u001b[43m    \u001b[49m\u001b[43mvalue\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    281\u001b[0m \u001b[43m    \u001b[49m\u001b[43mparse_tree\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparse\u001b[49m\u001b[43m(\u001b[49m\u001b[43m_get_value\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    282\u001b[0m \u001b[43m    \u001b[49m\u001b[43mthrow_on_resolution_failure\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mthrow_on_resolution_failure\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    283\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmemo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmemo\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    284\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/base.py:584\u001b[0m, in \u001b[0;36mContainer._resolve_interpolation_from_parse_tree\u001b[0;34m(self, parent, value, key, parse_tree, throw_on_resolution_failure, memo)\u001b[0m\n\u001b[1;32m    554\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    555\u001b[0m \u001b[38;5;124;03mResolve an interpolation.\u001b[39;00m\n\u001b[1;32m    556\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    580\u001b[0m \u001b[38;5;124;03m    `throw_on_resolution_failure` is `False` and an error occurs during resolution.\u001b[39;00m\n\u001b[1;32m    581\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    583\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 584\u001b[0m     resolved \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresolve_parse_tree\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    585\u001b[0m \u001b[43m        \u001b[49m\u001b[43mparse_tree\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparse_tree\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkey\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmemo\u001b[49m\n\u001b[1;32m    586\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    587\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m InterpolationResolutionError:\n\u001b[1;32m    588\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m throw_on_resolution_failure:\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/base.py:764\u001b[0m, in \u001b[0;36mContainer.resolve_parse_tree\u001b[0;34m(self, parse_tree, node, memo, key)\u001b[0m\n\u001b[1;32m    758\u001b[0m visitor \u001b[38;5;241m=\u001b[39m GrammarVisitor(\n\u001b[1;32m    759\u001b[0m     node_interpolation_callback\u001b[38;5;241m=\u001b[39mnode_interpolation_callback,\n\u001b[1;32m    760\u001b[0m     resolver_interpolation_callback\u001b[38;5;241m=\u001b[39mresolver_interpolation_callback,\n\u001b[1;32m    761\u001b[0m     memo\u001b[38;5;241m=\u001b[39mmemo,\n\u001b[1;32m    762\u001b[0m )\n\u001b[1;32m    763\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 764\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mvisitor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparse_tree\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    765\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m InterpolationResolutionError:\n\u001b[1;32m    766\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/antlr4/tree/Tree.py:34\u001b[0m, in \u001b[0;36mParseTreeVisitor.visit\u001b[0;34m(self, tree)\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mvisit\u001b[39m(\u001b[38;5;28mself\u001b[39m, tree):\n\u001b[0;32m---> 34\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtree\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43maccept\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParser.py:206\u001b[0m, in \u001b[0;36mOmegaConfGrammarParser.ConfigValueContext.accept\u001b[0;34m(self, visitor)\u001b[0m\n\u001b[1;32m    204\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21maccept\u001b[39m(\u001b[38;5;28mself\u001b[39m, visitor:ParseTreeVisitor):\n\u001b[1;32m    205\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m( visitor, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvisitConfigValue\u001b[39m\u001b[38;5;124m\"\u001b[39m ):\n\u001b[0;32m--> 206\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mvisitor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisitConfigValue\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m    207\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    208\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m visitor\u001b[38;5;241m.\u001b[39mvisitChildren(\u001b[38;5;28mself\u001b[39m)\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar_visitor.py:101\u001b[0m, in \u001b[0;36mGrammarVisitor.visitConfigValue\u001b[0;34m(self, ctx)\u001b[0m\n\u001b[1;32m     98\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mvisitConfigValue\u001b[39m(\u001b[38;5;28mself\u001b[39m, ctx: OmegaConfGrammarParser\u001b[38;5;241m.\u001b[39mConfigValueContext) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[1;32m     99\u001b[0m     \u001b[38;5;66;03m# text EOF\u001b[39;00m\n\u001b[1;32m    100\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m ctx\u001b[38;5;241m.\u001b[39mgetChildCount() \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m2\u001b[39m\n\u001b[0;32m--> 101\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgetChild\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/antlr4/tree/Tree.py:34\u001b[0m, in \u001b[0;36mParseTreeVisitor.visit\u001b[0;34m(self, tree)\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mvisit\u001b[39m(\u001b[38;5;28mself\u001b[39m, tree):\n\u001b[0;32m---> 34\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtree\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43maccept\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParser.py:342\u001b[0m, in \u001b[0;36mOmegaConfGrammarParser.TextContext.accept\u001b[0;34m(self, visitor)\u001b[0m\n\u001b[1;32m    340\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21maccept\u001b[39m(\u001b[38;5;28mself\u001b[39m, visitor:ParseTreeVisitor):\n\u001b[1;32m    341\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m( visitor, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvisitText\u001b[39m\u001b[38;5;124m\"\u001b[39m ):\n\u001b[0;32m--> 342\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mvisitor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisitText\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m    343\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    344\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m visitor\u001b[38;5;241m.\u001b[39mvisitChildren(\u001b[38;5;28mself\u001b[39m)\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar_visitor.py:298\u001b[0m, in \u001b[0;36mGrammarVisitor.visitText\u001b[0;34m(self, ctx)\u001b[0m\n\u001b[1;32m    296\u001b[0m     c \u001b[38;5;241m=\u001b[39m ctx\u001b[38;5;241m.\u001b[39mgetChild(\u001b[38;5;241m0\u001b[39m)\n\u001b[1;32m    297\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(c, OmegaConfGrammarParser\u001b[38;5;241m.\u001b[39mInterpolationContext):\n\u001b[0;32m--> 298\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisitInterpolation\u001b[49m\u001b[43m(\u001b[49m\u001b[43mc\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    300\u001b[0m \u001b[38;5;66;03m# Otherwise, concatenate string representations together.\u001b[39;00m\n\u001b[1;32m    301\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_unescape(\u001b[38;5;28mlist\u001b[39m(ctx\u001b[38;5;241m.\u001b[39mgetChildren()))\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar_visitor.py:125\u001b[0m, in \u001b[0;36mGrammarVisitor.visitInterpolation\u001b[0;34m(self, ctx)\u001b[0m\n\u001b[1;32m    121\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mvisitInterpolation\u001b[39m(\n\u001b[1;32m    122\u001b[0m     \u001b[38;5;28mself\u001b[39m, ctx: OmegaConfGrammarParser\u001b[38;5;241m.\u001b[39mInterpolationContext\n\u001b[1;32m    123\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[1;32m    124\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m ctx\u001b[38;5;241m.\u001b[39mgetChildCount() \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m  \u001b[38;5;66;03m# interpolationNode | interpolationResolver\u001b[39;00m\n\u001b[0;32m--> 125\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgetChild\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/antlr4/tree/Tree.py:34\u001b[0m, in \u001b[0;36mParseTreeVisitor.visit\u001b[0;34m(self, tree)\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mvisit\u001b[39m(\u001b[38;5;28mself\u001b[39m, tree):\n\u001b[0;32m---> 34\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtree\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43maccept\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParser.py:921\u001b[0m, in \u001b[0;36mOmegaConfGrammarParser.InterpolationNodeContext.accept\u001b[0;34m(self, visitor)\u001b[0m\n\u001b[1;32m    919\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21maccept\u001b[39m(\u001b[38;5;28mself\u001b[39m, visitor:ParseTreeVisitor):\n\u001b[1;32m    920\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m( visitor, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvisitInterpolationNode\u001b[39m\u001b[38;5;124m\"\u001b[39m ):\n\u001b[0;32m--> 921\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mvisitor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisitInterpolationNode\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m    922\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    923\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m visitor\u001b[38;5;241m.\u001b[39mvisitChildren(\u001b[38;5;28mself\u001b[39m)\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar_visitor.py:158\u001b[0m, in \u001b[0;36mGrammarVisitor.visitInterpolationNode\u001b[0;34m(self, ctx)\u001b[0m\n\u001b[1;32m    155\u001b[0m         inter_key_tokens\u001b[38;5;241m.\u001b[39mappend(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvisitConfigKey(child))\n\u001b[1;32m    157\u001b[0m inter_key \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mjoin(inter_key_tokens)\n\u001b[0;32m--> 158\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnode_interpolation_callback\u001b[49m\u001b[43m(\u001b[49m\u001b[43minter_key\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/base.py:745\u001b[0m, in \u001b[0;36mContainer.resolve_parse_tree.<locals>.node_interpolation_callback\u001b[0;34m(inter_key, memo)\u001b[0m\n\u001b[1;32m    742\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mnode_interpolation_callback\u001b[39m(\n\u001b[1;32m    743\u001b[0m     inter_key: \u001b[38;5;28mstr\u001b[39m, memo: Optional[Set[\u001b[38;5;28mint\u001b[39m]]\n\u001b[1;32m    744\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Optional[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNode\u001b[39m\u001b[38;5;124m\"\u001b[39m]:\n\u001b[0;32m--> 745\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_resolve_node_interpolation\u001b[49m\u001b[43m(\u001b[49m\u001b[43minter_key\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minter_key\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/base.py:664\u001b[0m, in \u001b[0;36mContainer._resolve_node_interpolation\u001b[0;34m(self, inter_key, memo)\u001b[0m\n\u001b[1;32m    659\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m InterpolationKeyError(\n\u001b[1;32m    660\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mConfigKeyError while resolving interpolation: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mexc\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    661\u001b[0m     )\u001b[38;5;241m.\u001b[39mwith_traceback(sys\u001b[38;5;241m.\u001b[39mexc_info()[\u001b[38;5;241m2\u001b[39m])\n\u001b[1;32m    663\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 664\u001b[0m     parent, last_key, value \u001b[38;5;241m=\u001b[39m \u001b[43mroot_node\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_select_impl\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    665\u001b[0m \u001b[43m        \u001b[49m\u001b[43minter_key\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    666\u001b[0m \u001b[43m        \u001b[49m\u001b[43mthrow_on_missing\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    667\u001b[0m \u001b[43m        \u001b[49m\u001b[43mthrow_on_resolution_failure\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    668\u001b[0m \u001b[43m        \u001b[49m\u001b[43mmemo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmemo\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    669\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    670\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m MissingMandatoryValue \u001b[38;5;28;01mas\u001b[39;00m exc:\n\u001b[1;32m    671\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m InterpolationToMissingValueError(\n\u001b[1;32m    672\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMissingMandatoryValue while resolving interpolation: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mexc\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    673\u001b[0m     )\u001b[38;5;241m.\u001b[39mwith_traceback(sys\u001b[38;5;241m.\u001b[39mexc_info()[\u001b[38;5;241m2\u001b[39m])\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/base.py:531\u001b[0m, in \u001b[0;36mContainer._select_impl\u001b[0;34m(self, key, throw_on_missing, throw_on_resolution_failure, memo)\u001b[0m\n\u001b[1;32m    528\u001b[0m     memo\u001b[38;5;241m.\u001b[39madd(vid)\n\u001b[1;32m    530\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 531\u001b[0m     value \u001b[38;5;241m=\u001b[39m \u001b[43mroot\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_maybe_resolve_interpolation\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    532\u001b[0m \u001b[43m        \u001b[49m\u001b[43mparent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mroot\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    533\u001b[0m \u001b[43m        \u001b[49m\u001b[43mkey\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlast_key\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    534\u001b[0m \u001b[43m        \u001b[49m\u001b[43mvalue\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    535\u001b[0m \u001b[43m        \u001b[49m\u001b[43mthrow_on_resolution_failure\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mthrow_on_resolution_failure\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    536\u001b[0m \u001b[43m        \u001b[49m\u001b[43mmemo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmemo\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    537\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    538\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m    539\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m memo \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    540\u001b[0m         \u001b[38;5;66;03m# pop from memo \"stack\"\u001b[39;00m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/base.py:719\u001b[0m, in \u001b[0;36mContainer._maybe_resolve_interpolation\u001b[0;34m(self, parent, key, value, throw_on_resolution_failure, memo)\u001b[0m\n\u001b[1;32m    716\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m value\n\u001b[1;32m    718\u001b[0m parse_tree \u001b[38;5;241m=\u001b[39m parse(_get_value(value))\n\u001b[0;32m--> 719\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_resolve_interpolation_from_parse_tree\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    720\u001b[0m \u001b[43m    \u001b[49m\u001b[43mparent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparent\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    721\u001b[0m \u001b[43m    \u001b[49m\u001b[43mvalue\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    722\u001b[0m \u001b[43m    \u001b[49m\u001b[43mkey\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    723\u001b[0m \u001b[43m    \u001b[49m\u001b[43mparse_tree\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparse_tree\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    724\u001b[0m \u001b[43m    \u001b[49m\u001b[43mthrow_on_resolution_failure\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mthrow_on_resolution_failure\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    725\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmemo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmemo\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mset\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    726\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/base.py:584\u001b[0m, in \u001b[0;36mContainer._resolve_interpolation_from_parse_tree\u001b[0;34m(self, parent, value, key, parse_tree, throw_on_resolution_failure, memo)\u001b[0m\n\u001b[1;32m    554\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    555\u001b[0m \u001b[38;5;124;03mResolve an interpolation.\u001b[39;00m\n\u001b[1;32m    556\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    580\u001b[0m \u001b[38;5;124;03m    `throw_on_resolution_failure` is `False` and an error occurs during resolution.\u001b[39;00m\n\u001b[1;32m    581\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    583\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 584\u001b[0m     resolved \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresolve_parse_tree\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    585\u001b[0m \u001b[43m        \u001b[49m\u001b[43mparse_tree\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparse_tree\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkey\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmemo\u001b[49m\n\u001b[1;32m    586\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    587\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m InterpolationResolutionError:\n\u001b[1;32m    588\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m throw_on_resolution_failure:\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/base.py:769\u001b[0m, in \u001b[0;36mContainer.resolve_parse_tree\u001b[0;34m(self, parse_tree, node, memo, key)\u001b[0m\n\u001b[1;32m    766\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m\n\u001b[1;32m    767\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m exc:\n\u001b[1;32m    768\u001b[0m     \u001b[38;5;66;03m# Other kinds of exceptions are wrapped in an `InterpolationResolutionError`.\u001b[39;00m\n\u001b[0;32m--> 769\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m InterpolationResolutionError(\n\u001b[1;32m    770\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mtype\u001b[39m(exc)\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m raised while resolving interpolation: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mexc\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    771\u001b[0m     )\u001b[38;5;241m.\u001b[39mwith_traceback(sys\u001b[38;5;241m.\u001b[39mexc_info()[\u001b[38;5;241m2\u001b[39m])\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/base.py:764\u001b[0m, in \u001b[0;36mContainer.resolve_parse_tree\u001b[0;34m(self, parse_tree, node, memo, key)\u001b[0m\n\u001b[1;32m    758\u001b[0m visitor \u001b[38;5;241m=\u001b[39m GrammarVisitor(\n\u001b[1;32m    759\u001b[0m     node_interpolation_callback\u001b[38;5;241m=\u001b[39mnode_interpolation_callback,\n\u001b[1;32m    760\u001b[0m     resolver_interpolation_callback\u001b[38;5;241m=\u001b[39mresolver_interpolation_callback,\n\u001b[1;32m    761\u001b[0m     memo\u001b[38;5;241m=\u001b[39mmemo,\n\u001b[1;32m    762\u001b[0m )\n\u001b[1;32m    763\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 764\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mvisitor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparse_tree\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    765\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m InterpolationResolutionError:\n\u001b[1;32m    766\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/antlr4/tree/Tree.py:34\u001b[0m, in \u001b[0;36mParseTreeVisitor.visit\u001b[0;34m(self, tree)\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mvisit\u001b[39m(\u001b[38;5;28mself\u001b[39m, tree):\n\u001b[0;32m---> 34\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtree\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43maccept\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParser.py:206\u001b[0m, in \u001b[0;36mOmegaConfGrammarParser.ConfigValueContext.accept\u001b[0;34m(self, visitor)\u001b[0m\n\u001b[1;32m    204\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21maccept\u001b[39m(\u001b[38;5;28mself\u001b[39m, visitor:ParseTreeVisitor):\n\u001b[1;32m    205\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m( visitor, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvisitConfigValue\u001b[39m\u001b[38;5;124m\"\u001b[39m ):\n\u001b[0;32m--> 206\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mvisitor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisitConfigValue\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m    207\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    208\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m visitor\u001b[38;5;241m.\u001b[39mvisitChildren(\u001b[38;5;28mself\u001b[39m)\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar_visitor.py:101\u001b[0m, in \u001b[0;36mGrammarVisitor.visitConfigValue\u001b[0;34m(self, ctx)\u001b[0m\n\u001b[1;32m     98\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mvisitConfigValue\u001b[39m(\u001b[38;5;28mself\u001b[39m, ctx: OmegaConfGrammarParser\u001b[38;5;241m.\u001b[39mConfigValueContext) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[1;32m     99\u001b[0m     \u001b[38;5;66;03m# text EOF\u001b[39;00m\n\u001b[1;32m    100\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m ctx\u001b[38;5;241m.\u001b[39mgetChildCount() \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m2\u001b[39m\n\u001b[0;32m--> 101\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgetChild\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/antlr4/tree/Tree.py:34\u001b[0m, in \u001b[0;36mParseTreeVisitor.visit\u001b[0;34m(self, tree)\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mvisit\u001b[39m(\u001b[38;5;28mself\u001b[39m, tree):\n\u001b[0;32m---> 34\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtree\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43maccept\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParser.py:342\u001b[0m, in \u001b[0;36mOmegaConfGrammarParser.TextContext.accept\u001b[0;34m(self, visitor)\u001b[0m\n\u001b[1;32m    340\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21maccept\u001b[39m(\u001b[38;5;28mself\u001b[39m, visitor:ParseTreeVisitor):\n\u001b[1;32m    341\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m( visitor, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvisitText\u001b[39m\u001b[38;5;124m\"\u001b[39m ):\n\u001b[0;32m--> 342\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mvisitor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisitText\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m    343\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    344\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m visitor\u001b[38;5;241m.\u001b[39mvisitChildren(\u001b[38;5;28mself\u001b[39m)\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar_visitor.py:298\u001b[0m, in \u001b[0;36mGrammarVisitor.visitText\u001b[0;34m(self, ctx)\u001b[0m\n\u001b[1;32m    296\u001b[0m     c \u001b[38;5;241m=\u001b[39m ctx\u001b[38;5;241m.\u001b[39mgetChild(\u001b[38;5;241m0\u001b[39m)\n\u001b[1;32m    297\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(c, OmegaConfGrammarParser\u001b[38;5;241m.\u001b[39mInterpolationContext):\n\u001b[0;32m--> 298\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisitInterpolation\u001b[49m\u001b[43m(\u001b[49m\u001b[43mc\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    300\u001b[0m \u001b[38;5;66;03m# Otherwise, concatenate string representations together.\u001b[39;00m\n\u001b[1;32m    301\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_unescape(\u001b[38;5;28mlist\u001b[39m(ctx\u001b[38;5;241m.\u001b[39mgetChildren()))\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar_visitor.py:125\u001b[0m, in \u001b[0;36mGrammarVisitor.visitInterpolation\u001b[0;34m(self, ctx)\u001b[0m\n\u001b[1;32m    121\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mvisitInterpolation\u001b[39m(\n\u001b[1;32m    122\u001b[0m     \u001b[38;5;28mself\u001b[39m, ctx: OmegaConfGrammarParser\u001b[38;5;241m.\u001b[39mInterpolationContext\n\u001b[1;32m    123\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[1;32m    124\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m ctx\u001b[38;5;241m.\u001b[39mgetChildCount() \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m  \u001b[38;5;66;03m# interpolationNode | interpolationResolver\u001b[39;00m\n\u001b[0;32m--> 125\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgetChild\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/antlr4/tree/Tree.py:34\u001b[0m, in \u001b[0;36mParseTreeVisitor.visit\u001b[0;34m(self, tree)\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mvisit\u001b[39m(\u001b[38;5;28mself\u001b[39m, tree):\n\u001b[0;32m---> 34\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtree\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43maccept\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParser.py:1041\u001b[0m, in \u001b[0;36mOmegaConfGrammarParser.InterpolationResolverContext.accept\u001b[0;34m(self, visitor)\u001b[0m\n\u001b[1;32m   1039\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21maccept\u001b[39m(\u001b[38;5;28mself\u001b[39m, visitor:ParseTreeVisitor):\n\u001b[1;32m   1040\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m( visitor, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvisitInterpolationResolver\u001b[39m\u001b[38;5;124m\"\u001b[39m ):\n\u001b[0;32m-> 1041\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mvisitor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisitInterpolationResolver\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1042\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m   1043\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m visitor\u001b[38;5;241m.\u001b[39mvisitChildren(\u001b[38;5;28mself\u001b[39m)\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/grammar_visitor.py:179\u001b[0m, in \u001b[0;36mGrammarVisitor.visitInterpolationResolver\u001b[0;34m(self, ctx)\u001b[0m\n\u001b[1;32m    176\u001b[0m         args\u001b[38;5;241m.\u001b[39mappend(val)\n\u001b[1;32m    177\u001b[0m         args_str\u001b[38;5;241m.\u001b[39mappend(txt)\n\u001b[0;32m--> 179\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresolver_interpolation_callback\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    180\u001b[0m \u001b[43m    \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mresolver_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    181\u001b[0m \u001b[43m    \u001b[49m\u001b[43margs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mtuple\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    182\u001b[0m \u001b[43m    \u001b[49m\u001b[43margs_str\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mtuple\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs_str\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    183\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/base.py:750\u001b[0m, in \u001b[0;36mContainer.resolve_parse_tree.<locals>.resolver_interpolation_callback\u001b[0;34m(name, args, args_str)\u001b[0m\n\u001b[1;32m    747\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mresolver_interpolation_callback\u001b[39m(\n\u001b[1;32m    748\u001b[0m     name: \u001b[38;5;28mstr\u001b[39m, args: Tuple[Any, \u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m], args_str: Tuple[\u001b[38;5;28mstr\u001b[39m, \u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m]\n\u001b[1;32m    749\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[0;32m--> 750\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_evaluate_custom_resolver\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    751\u001b[0m \u001b[43m        \u001b[49m\u001b[43mkey\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    752\u001b[0m \u001b[43m        \u001b[49m\u001b[43mnode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    753\u001b[0m \u001b[43m        \u001b[49m\u001b[43minter_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    754\u001b[0m \u001b[43m        \u001b[49m\u001b[43minter_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    755\u001b[0m \u001b[43m        \u001b[49m\u001b[43minter_args_str\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43margs_str\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    756\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/base.py:694\u001b[0m, in \u001b[0;36mContainer._evaluate_custom_resolver\u001b[0;34m(self, key, node, inter_type, inter_args, inter_args_str)\u001b[0m\n\u001b[1;32m    692\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m resolver \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    693\u001b[0m     root_node \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_root()\n\u001b[0;32m--> 694\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mresolver\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    695\u001b[0m \u001b[43m        \u001b[49m\u001b[43mroot_node\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    696\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    697\u001b[0m \u001b[43m        \u001b[49m\u001b[43mnode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    698\u001b[0m \u001b[43m        \u001b[49m\u001b[43minter_args\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    699\u001b[0m \u001b[43m        \u001b[49m\u001b[43minter_args_str\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    700\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    701\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    702\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m UnsupportedInterpolationType(\n\u001b[1;32m    703\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUnsupported interpolation type \u001b[39m\u001b[38;5;132;01m{\u001b[39;00minter_type\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    704\u001b[0m     )\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/omegaconf/omegaconf.py:445\u001b[0m, in \u001b[0;36mOmegaConf.register_new_resolver.<locals>.resolver_wrapper\u001b[0;34m(config, parent, node, args, args_str)\u001b[0m\n\u001b[1;32m    442\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m pass_root:\n\u001b[1;32m    443\u001b[0m     kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_root_\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m config\n\u001b[0;32m--> 445\u001b[0m ret \u001b[38;5;241m=\u001b[39m \u001b[43mresolver\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    447\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m use_cache:\n\u001b[1;32m    448\u001b[0m     cache[args_str] \u001b[38;5;241m=\u001b[39m ret\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/hydra/core/utils.py:220\u001b[0m, in \u001b[0;36msetup_globals.<locals>.<lambda>\u001b[0;34m(path)\u001b[0m\n\u001b[1;32m    210\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21msetup_globals\u001b[39m() \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    211\u001b[0m     \u001b[38;5;66;03m# please add documentation when you add a new resolver\u001b[39;00m\n\u001b[1;32m    212\u001b[0m     OmegaConf\u001b[38;5;241m.\u001b[39mregister_new_resolver(\n\u001b[1;32m    213\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnow\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m    214\u001b[0m         \u001b[38;5;28;01mlambda\u001b[39;00m pattern: datetime\u001b[38;5;241m.\u001b[39mnow()\u001b[38;5;241m.\u001b[39mstrftime(pattern),\n\u001b[1;32m    215\u001b[0m         use_cache\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m    216\u001b[0m         replace\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m    217\u001b[0m     )\n\u001b[1;32m    218\u001b[0m     OmegaConf\u001b[38;5;241m.\u001b[39mregister_new_resolver(\n\u001b[1;32m    219\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhydra\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m--> 220\u001b[0m         \u001b[38;5;28;01mlambda\u001b[39;00m path: OmegaConf\u001b[38;5;241m.\u001b[39mselect(cast(DictConfig, \u001b[43mHydraConfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m), path),\n\u001b[1;32m    221\u001b[0m         replace\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m    222\u001b[0m     )\n\u001b[1;32m    224\u001b[0m     vi \u001b[38;5;241m=\u001b[39m sys\u001b[38;5;241m.\u001b[39mversion_info\n\u001b[1;32m    225\u001b[0m     version_dict \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m    226\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmajor\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mvi[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m    227\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mminor\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mvi[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mvi[\u001b[38;5;241m1\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m    228\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmicro\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mvi[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mvi[\u001b[38;5;241m1\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mvi[\u001b[38;5;241m2\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m    229\u001b[0m     }\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/hydra/core/hydra_config.py:31\u001b[0m, in \u001b[0;36mHydraConfig.get\u001b[0;34m()\u001b[0m\n\u001b[1;32m     29\u001b[0m instance \u001b[38;5;241m=\u001b[39m HydraConfig\u001b[38;5;241m.\u001b[39minstance()\n\u001b[1;32m     30\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m instance\u001b[38;5;241m.\u001b[39mcfg \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m---> 31\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHydraConfig was not set\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m     32\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m instance\u001b[38;5;241m.\u001b[39mcfg\u001b[38;5;241m.\u001b[39mhydra\n",
-      "\u001b[0;31mInterpolationResolutionError\u001b[0m: ValueError raised while resolving interpolation: HydraConfig was not set"
-     ]
-    }
-   ],
-   "source": [
-    "callbacks: List[Callback] = instantiate_callbacks(cfg.get(\"callbacks\"))\n",
-    "logger: List[Logger] = instantiate_loggers(cfg.get(\"logger\"))\n",
-    "\n",
-    "log.info(f\"Instantiating trainer <{cfg.trainer._target_}>\")\n",
-    "trainer: Trainer = hydra.utils.instantiate(\n",
-    "    cfg.trainer, callbacks=callbacks, logger=logger\n",
-    ")\n",
-    "trainer = hydra.utils.instantiate(config.trainer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Load data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Downloading https://www.chrsmrrs.com/graphkerneldatasets/MUTAG.zip\n",
-      "Processing...\n",
-      "/Users/gbg141/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/scipy/sparse/_index.py:143: SparseEfficiencyWarning: Changing the sparsity structure of a csc_matrix is expensive. lil_matrix is more efficient.\n",
-      "  self._set_arrayXarray(i, j, x)\n",
-      "Done!\n"
-     ]
-    }
-   ],
-   "source": [
-    "graph_loader = hydra.utils.instantiate(config.dataset, _recursive_=False)\n",
-    "data = graph_loader.load()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "d = data[0].data_lst"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(13, 14, 2)"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "d[0].shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Data(x=[13, 7], y=[1], up_laplacian_0=[13, 13], adjacency_0=[13, 13], hodge_laplacian_0=[13, 13], incidence_1=[13, 14], down_laplacian_1=[14, 14], up_laplacian_1=[14, 14], adjacency_1=[14, 14], hodge_laplacian_1=[14, 14], incidence_2=[14, 2], down_laplacian_2=[2, 2], hodge_laplacian_2=[2, 2], shape=[3], x_0=[13, 7], x_1=[14, 7], x_2=[2, 7], train_mask=[1], val_mask=[1], test_mask=[1])"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "d[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "simplicial_loader = hydra.utils.instantiate(config.dataset)\n",
-    "data = simplicial_loader.load()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/gbg141/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/lightning/pytorch/utilities/parsing.py:198: Attribute 'backbone' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['backbone'])`.\n",
-      "/Users/gbg141/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/lightning/pytorch/utilities/parsing.py:198: Attribute 'readout_workaround' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['readout_workaround'])`.\n",
-      "/Users/gbg141/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/lightning/pytorch/utilities/parsing.py:198: Attribute 'readout' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['readout'])`.\n"
-     ]
-    }
-   ],
-   "source": [
-    "from lightning import LightningModule\n",
-    "\n",
-    "model: LightningModule = hydra.utils.instantiate(config.model)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "TBXModel(\n",
-       "  (backbone): SANWrapper(\n",
-       "    (backbone): SAN()\n",
-       "  )\n",
-       "  (readout_workaround): ReadOutWorkaround()\n",
-       "  (readout): NodeLevelReadOut(\n",
-       "    (linear): Linear(in_features=16, out_features=2, bias=True)\n",
-       "  )\n",
-       "  (val_acc_best): MaxMetric()\n",
-       ")"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "model"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "34"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "data.num_nodes"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "tensor(indices=tensor([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13,\n",
-       "                        14, 15,  0, 16, 17, 18, 19, 20, 21, 22, 23,  1, 16, 24,\n",
-       "                        25, 26, 27, 28, 29, 30, 31,  2, 17, 24, 32, 33, 34,  3,\n",
-       "                        35, 36,  4, 37, 38, 39,  5, 35, 37, 40,  6, 18, 25, 32,\n",
-       "                         7, 26, 41, 42, 43, 27, 44,  8, 36, 38,  9, 10, 33, 11,\n",
-       "                        19, 28, 34, 45, 46, 47, 48, 49, 39, 40, 12, 20, 50, 51,\n",
-       "                        13, 21, 52, 53, 54, 14, 22, 55, 56, 57, 58, 59, 60, 61,\n",
-       "                        62, 63, 64, 57, 62, 65, 66, 67, 29, 58, 63, 68, 30, 69,\n",
-       "                        70, 59, 66, 71, 72, 23, 41, 73, 74, 15, 64, 65, 69, 75,\n",
-       "                        76, 31, 42, 46, 48, 50, 53, 55, 60, 71, 73, 75, 77, 43,\n",
-       "                        44, 45, 47, 49, 51, 52, 54, 56, 61, 67, 68, 70, 72, 74,\n",
-       "                        76, 77],\n",
-       "                       [ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n",
-       "                         0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,\n",
-       "                         2,  2,  2,  2,  2,  2,  2,  3,  3,  3,  3,  3,  3,  4,\n",
-       "                         4,  4,  5,  5,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,\n",
-       "                         8,  8,  8,  8,  8,  9,  9, 10, 10, 10, 11, 12, 12, 13,\n",
-       "                        13, 13, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18,\n",
-       "                        19, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 23, 23, 23,\n",
-       "                        24, 24, 24, 25, 25, 25, 26, 26, 27, 27, 27, 27, 28, 28,\n",
-       "                        28, 29, 29, 29, 29, 30, 30, 30, 30, 31, 31, 31, 31, 31,\n",
-       "                        31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33,\n",
-       "                        33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,\n",
-       "                        33, 33]]),\n",
-       "       values=tensor([-1., -1., -1., -1., -1., -1., -1., -1., -1., -1., -1.,\n",
-       "                      -1., -1., -1., -1., -1.,  1., -1., -1., -1., -1., -1.,\n",
-       "                      -1., -1., -1.,  1.,  1., -1., -1., -1., -1., -1., -1.,\n",
-       "                      -1., -1.,  1.,  1.,  1., -1., -1., -1.,  1., -1., -1.,\n",
-       "                       1., -1., -1., -1.,  1.,  1.,  1., -1.,  1.,  1.,  1.,\n",
-       "                       1.,  1.,  1., -1., -1., -1.,  1., -1.,  1.,  1.,  1.,\n",
-       "                       1.,  1.,  1.,  1.,  1.,  1.,  1., -1., -1., -1., -1.,\n",
-       "                      -1.,  1.,  1.,  1.,  1., -1., -1.,  1.,  1., -1., -1.,\n",
-       "                      -1.,  1.,  1., -1., -1., -1., -1., -1., -1., -1., -1.,\n",
-       "                      -1., -1.,  1.,  1., -1., -1., -1.,  1.,  1.,  1., -1.,\n",
-       "                       1., -1., -1.,  1.,  1., -1., -1.,  1.,  1., -1., -1.,\n",
-       "                       1.,  1.,  1.,  1., -1., -1.,  1.,  1.,  1.,  1.,  1.,\n",
-       "                       1.,  1.,  1.,  1.,  1.,  1., -1.,  1.,  1.,  1.,  1.,\n",
-       "                       1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,\n",
-       "                       1.,  1.]),\n",
-       "       size=(78, 34), nnz=156, layout=torch.sparse_coo)"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "data.incidence_1.T"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Lifting"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# # Load data\n",
-    "# from topobenchmarkx.data.load.loaders import HypergraphLoader\n",
-    "\n",
-    "# data_loader = HypergraphLoader(config)\n",
-    "# data = data_loader.load()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "dict_keys(['hydra', 'task_name', 'tags', 'train', 'test', 'ckpt_path', 'seed', 'dataset', 'transforms', 'model', 'evaluator', 'callbacks', 'trainer', 'paths', 'extras'])"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "config.keys()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'_target_': 'topobenchmarkx.transforms.lifting.DataLiftingTransform', 'lifting': 'HypergraphKHopLifting', 'k_value': 1, 'complex_dim': 'None', 'max_triangles': 'None', 'aggregation_method': 'None'}"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "config[\"transforms\"]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lifting = hydra.utils.instantiate(config.transforms)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'k_value': 1,\n",
-       " 'complex_dim': 'None',\n",
-       " 'max_triangles': 'None',\n",
-       " 'aggregation_method': 'None',\n",
-       " 'lifting': 'HypergraphKHopLifting'}"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lifting.parameters"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data = torch_geometric.data.Data()\n",
-    "data.x = torch.zeros([6, 1])\n",
-    "data.edge_index = torch.tensor([[0, 0, 0, 1, 1, 1, 2, 4], [1, 2, 3, 2, 3, 4, 3, 5]])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lifted_data = lifting(data)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Data(x=[6, 1], incidence_1=[6, 6], num_hyperedges=6, x_0=[6, 1], x_hyperedges=[6, 1])"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lifted_data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/gbg141/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/torch_geometric/data/dataset.py:234: UserWarning: The `pre_transform` argument differs from the one used in the pre-processed version of this dataset. If you want to make use of another pre-processing technique, pass `force_reload=True` explicitly to reload the dataset.\n",
-      "  warnings.warn(\n"
-     ]
-    }
-   ],
-   "source": [
-    "cora = torch_geometric.datasets.Planetoid(\n",
-    "    root=\"../datasets/graph/\", name=\"Cora\", pre_transform=lifting\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/gbg141/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/torch_geometric/data/in_memory_dataset.py:293: UserWarning: It is not recommended to directly access the internal storage format `data` of an 'InMemoryDataset'. If you are absolutely certain what you are doing, access the internal storage via `InMemoryDataset._data` instead to suppress this warning. Alternatively, you can access stacked individual attributes of every graph via `dataset.{attr_name}`.\n",
-      "  warnings.warn(msg)\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "Data(x=[2708, 1433], num_cells_0=2708, num_cells_1=10556, num_cells_2=2648, incidence_1=[2708, 10556], incidence_2=[10556, 2648], up_laplacian_1=[10556, 10556], up_laplacian_2=[2648, 2648], down_laplacian_2=[10556, 10556], down_laplacian_1=[2708, 2708], x_0=[2708, 1433], x_1=[10556, 1433], x_2=[2648, 1433])"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "cora.data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Data(num_hyperedges=2708, x_0=[2708, 1433], incidence_1=[2708, 2708], x=[2708, 1433], x_hyperedges=[2708, 1433])"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from torch.utils.data import DataLoader\n",
-    "from torch_geometric.data import Data\n",
-    "\n",
-    "\n",
-    "def collate_fn(batch):\n",
-    "    \"\"\"\n",
-    "    args:\n",
-    "        batch - list of (tensor, label)\n",
-    "\n",
-    "    reutrn:\n",
-    "        xs - a tensor of all examples in 'batch' after padding\n",
-    "        ys - a LongTensor of all labels in batch\n",
-    "    \"\"\"\n",
-    "\n",
-    "    for b in batch:\n",
-    "        values, keys = b[0], b[1]\n",
-    "        data = Data()\n",
-    "        for key, value in zip(keys, values, strict=False):\n",
-    "            data[key] = value\n",
-    "\n",
-    "    return data\n",
-    "\n",
-    "\n",
-    "d = DataLoader(dataset=DataloadDataset([cora.data]), batch_size=1, collate_fn=collate_fn)\n",
-    "next(iter(d))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'data_lst' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[1;32m/TopoBenchmarkX/notebooks/data.ipynb Cell 17\u001b[0m line \u001b[0;36m1\n\u001b[0;32m----> <a href='vscode-notebook-cell://attached-container%2B7b22636f6e7461696e65724e616d65223a222f6e696674795f73686f636b6c6579227d@ssh-remote%2Blevtel2/TopoBenchmarkX/notebooks/data.ipynb#X20sdnNjb2RlLXJlbW90ZQ%3D%3D?line=0'>1</a>\u001b[0m databatch \u001b[39m=\u001b[39m torch_geometric\u001b[39m.\u001b[39mdata\u001b[39m.\u001b[39mBatch\u001b[39m.\u001b[39mfrom_data_list(data_lst)\n",
-      "\u001b[0;31mNameError\u001b[0m: name 'data_lst' is not defined"
-     ]
-    }
-   ],
-   "source": [
-    "databatch = torch_geometric.data.Batch.from_data_list(data_lst)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "tensor([[   0,    1,    2,  ..., 2706, 2706, 2707],\n",
-       "        [ 978,  736,  399,  ...,  362,  419,  921]])"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "databatch.edge_index[:, :4905]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "tensor([[2708, 2709, 2710,  ..., 5414, 5414, 5415],\n",
-       "        [3686, 3444, 3107,  ..., 3070, 3127, 3629]])"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "databatch.edge_index[:, 4905:]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AllSetTransformer(\n",
-       "  (layers): ModuleList(\n",
-       "    (0): AllSetTransformerLayer(\n",
-       "      (vertex2edge): AllSetTransformerBlock(\n",
-       "        (multihead_att): MultiHeadAttention()\n",
-       "        (mlp): MLP(\n",
-       "          (0): Linear(in_features=64, out_features=64, bias=False)\n",
-       "          (1): Dropout(p=0.2, inplace=False)\n",
-       "        )\n",
-       "        (ln0): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
-       "        (ln1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
-       "      )\n",
-       "      (edge2vertex): AllSetTransformerBlock(\n",
-       "        (multihead_att): MultiHeadAttention()\n",
-       "        (mlp): MLP(\n",
-       "          (0): Linear(in_features=64, out_features=64, bias=False)\n",
-       "          (1): Dropout(p=0.2, inplace=False)\n",
-       "        )\n",
-       "        (ln0): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
-       "        (ln1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
-       "      )\n",
-       "    )\n",
-       "  )\n",
-       ")"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "databatch.edge_index = databatch.edge_index.to_sparse()\n",
-    "databatch.edge_index"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "from torch.utils.data import DataLoader, Dataset\n",
-    "\n",
-    "\n",
-    "class TextDataset(Dataset):\n",
-    "    def __init__(self, text_list, labels):\n",
-    "        self.text_list = text_list\n",
-    "        self.labels = labels\n",
-    "\n",
-    "    def __len__(self):\n",
-    "        return len(self.text_list)\n",
-    "\n",
-    "    def __getitem__(self, idx):\n",
-    "        text = self.text_list[idx]\n",
-    "        label = self.labels[idx]\n",
-    "\n",
-    "        # You can perform any text preprocessing here if needed\n",
-    "        # For example, tokenization, numerical encoding, etc.\n",
-    "\n",
-    "        return {\"text\": text, \"label\": label}\n",
-    "\n",
-    "\n",
-    "# Example usage\n",
-    "text_data = [\n",
-    "    \"This is an example.\",\n",
-    "    \"Another text sample.\",\n",
-    "    \"PyTorch DataLoader with text.\",\n",
-    "]\n",
-    "labels = [0, 1, 0]  # Example labels\n",
-    "\n",
-    "# Create an instance of your custom dataset\n",
-    "custom_dataset = TextDataset(text_data, labels)\n",
-    "\n",
-    "# Use DataLoader to load batches of data\n",
-    "batch_size = 2\n",
-    "data_loader = DataLoader(custom_dataset, batch_size=batch_size, shuffle=True)\n",
-    "\n",
-    "# Iterate through batches\n",
-    "for batch in data_loader:\n",
-    "    texts = batch[\"text\"]\n",
-    "    labels = batch[\"label\"]\n",
-    "\n",
-    "    # Perform your training/validation/test operations here\n",
-    "    print(\"Texts:\", texts)\n",
-    "    print(\"Labels:\", labels)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data_lst[0].keys()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from torch.utils.data import DataLoader\n",
-    "\n",
-    "dataloader = DataLoader(dataset, batch_size=1, shuffle=True)\n",
-    "next(iter(dataloader))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from torch_geometric.loader import DataLoader\n",
-    "\n",
-    "dataloader = DataLoader(dataset, batch_size=1, shuffle=False)\n",
-    "\n",
-    "next(iter(dataloader))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "config.data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Loss"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "loss = hydra.utils.instantiate(config.model.loss)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Backbone"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "hydra.utils.instantiate(config.model.backbone)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ReadOut"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "readout = hydra.utils.instantiate(config.model.readout)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<generator object Module.parameters at 0x19ca5db60>"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "readout.parameters()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Evaluator"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "evaluator = hydra.utils.instantiate(config.evaluator)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/gbg141/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/sklearn/metrics/_classification.py:1471: 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, msg_start, len(result))\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "{'labels': tensor([0, 1, 2, 1, 2, 2]),\n",
-       " 'logits': tensor([[ 1, 11, 11],\n",
-       "         [ 5, 11,  3],\n",
-       "         [ 2,  3,  4],\n",
-       "         [ 5, 16,  7],\n",
-       "         [ 8,  9, 10],\n",
-       "         [11, 12, 13]]),\n",
-       " 'metrics': {'acc': 0.8333333333333334,\n",
-       "  'pre_micro': 0.8333333333333334,\n",
-       "  'pre_macro': 0.5555555555555555,\n",
-       "  'rec_micro': 0.8333333333333334,\n",
-       "  'rec_macro': 0.6666666666666666,\n",
-       "  'f1_micro': 0.8333333333333334,\n",
-       "  'f1_macro': 0.6}}"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import torch\n",
-    "\n",
-    "d = {\n",
-    "    \"labels\": torch.tensor([0, 1, 2, 1, 2, 2]),\n",
-    "    \"logits\": torch.tensor(\n",
-    "        [[1, 11, 11], [5, 11, 3], [2, 3, 4], [5, 16, 7], [8, 9, 10], [11, 12, 13]]\n",
-    "    ),\n",
-    "}\n",
-    "\n",
-    "\n",
-    "evaluator.eval(d)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "tensor([1, 1, 2, 1, 2, 2])"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "d[\"logits\"].argmax(dim=1)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Dataloader"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Loading hypergraph dataset name: cora\n",
-      "number of nodes:2708, feature dimension: 1433\n",
-      "number of hyperedges: 1072\n",
-      "Final num_hyperedges 1392\n",
-      "Final num_nodes 2708\n",
-      "Final num_class 7\n"
-     ]
-    },
-    {
-     "ename": "FileNotFoundError",
-     "evalue": "[Errno 2] No such file or directory: '/Users/gbg141/Documents/TopoProjectX/TopoBenchmarkX/data//data_splits/cora/train_prop=0.5/split_0.npz'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[10], line 6\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mtopobenchmarkx\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mdata\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mdataloader_fullbatch\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m FullBatchDataModule\n\u001b[1;32m      5\u001b[0m data_loader \u001b[38;5;241m=\u001b[39m HypergraphLoader(config)\n\u001b[0;32m----> 6\u001b[0m data \u001b[38;5;241m=\u001b[39m \u001b[43mdata_loader\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      7\u001b[0m dataloader \u001b[38;5;241m=\u001b[39m FullBatchDataModule(data\u001b[38;5;241m=\u001b[39mdata)\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/topobenchmarkx/data/load/loaders.py:17\u001b[0m, in \u001b[0;36mHypergraphLoader.load\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mload\u001b[39m(\n\u001b[1;32m     14\u001b[0m     \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m     15\u001b[0m ):\n\u001b[1;32m     16\u001b[0m     data \u001b[38;5;241m=\u001b[39m load_hypergraph_pickle_dataset(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcfg\u001b[38;5;241m.\u001b[39mdata)\n\u001b[0;32m---> 17\u001b[0m     data \u001b[38;5;241m=\u001b[39m \u001b[43mload_split\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcfg\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     19\u001b[0m     \u001b[38;5;66;03m# We need to add checks that:\u001b[39;00m\n\u001b[1;32m     20\u001b[0m     \u001b[38;5;66;03m# All nodes belong to some edge, in case some not, create selfedge\u001b[39;00m\n\u001b[1;32m     22\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m data\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/topobenchmarkx/data/utils.py:131\u001b[0m, in \u001b[0;36mload_split\u001b[0;34m(data, cfg)\u001b[0m\n\u001b[1;32m    129\u001b[0m data_dir \u001b[38;5;241m=\u001b[39m cfg[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdata_split_dir\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m    130\u001b[0m load_path \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdata_dir\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m/split_\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mcfg[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdata_seed\u001b[39m\u001b[38;5;124m'\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.npz\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m--> 131\u001b[0m splits \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload\u001b[49m\u001b[43m(\u001b[49m\u001b[43mload_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mallow_pickle\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m    132\u001b[0m data\u001b[38;5;241m.\u001b[39mtrain_mask \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mfrom_numpy(splits[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtrain\u001b[39m\u001b[38;5;124m\"\u001b[39m])\n\u001b[1;32m    133\u001b[0m data\u001b[38;5;241m.\u001b[39mval_mask \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mfrom_numpy(splits[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvalid\u001b[39m\u001b[38;5;124m\"\u001b[39m])\n",
-      "File \u001b[0;32m~/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/numpy/lib/npyio.py:427\u001b[0m, in \u001b[0;36mload\u001b[0;34m(file, mmap_mode, allow_pickle, fix_imports, encoding, max_header_size)\u001b[0m\n\u001b[1;32m    425\u001b[0m     own_fid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m    426\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 427\u001b[0m     fid \u001b[38;5;241m=\u001b[39m stack\u001b[38;5;241m.\u001b[39menter_context(\u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mos_fspath\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrb\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m)\n\u001b[1;32m    428\u001b[0m     own_fid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m    430\u001b[0m \u001b[38;5;66;03m# Code to distinguish from NumPy binary files and pickles.\u001b[39;00m\n",
-      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/Users/gbg141/Documents/TopoProjectX/TopoBenchmarkX/data//data_splits/cora/train_prop=0.5/split_0.npz'"
-     ]
-    }
-   ],
-   "source": [
-    "# Load data\n",
-    "\n",
-    "data_loader = HypergraphLoader(config)\n",
-    "data = data_loader.load()\n",
-    "dataloader = FullBatchDataModule(data=data)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "batch = next(iter(dataloader.train_dataloader()))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "batch.x[batch.train_mask]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "a = hydra.utils.instantiate(config.model)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "a.hparams.backbone is a.backbone"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "id(a.hparams.backbone) == id(a.backbone)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "b = a.backbone.__class__"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# b in []topomodelx.nn.hypergraph.unigcnii.UniGCNII"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "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.11.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/notebooks/graph2simplicial/SimplicialCliqueLifting.ipynb b/notebooks/graph2simplicial/SimplicialCliqueLifting.ipynb
deleted file mode 100644
index 1e22c13a..00000000
--- a/notebooks/graph2simplicial/SimplicialCliqueLifting.ipynb
+++ /dev/null
@@ -1,263 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# SimplicialCliqueLifting Tutorial"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import rootutils\n",
-    "\n",
-    "rootutils.setup_root(\"./\", indicator=\".project-root\", pythonpath=True)\n",
-    "root_folder = rootutils.find_root()\n",
-    "import omegaconf\n",
-    "\n",
-    "from topobenchmarkx.data.load.loaders import GraphLoader"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Load dataset"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Import Dataset Config"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Either we keep yaml config files and provide a brief overview of them, or we build the required config files by hand in these tutorials. (I prefer the former option.)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'data_domain': 'graph', 'data_type': 'cocitation', 'data_name': 'Cora', 'data_dir': '/Users/gbg141/Documents/TopoProjectX/TopoBenchmarkX/datasets/graph/cocitation', 'data_split_dir': '/Users/gbg141/Documents/TopoProjectX/TopoBenchmarkX/datasets/graph/cocitation/data_splits/Cora', 'num_features': 1433, 'num_classes': 7, 'task': 'classification', 'loss_type': 'cross_entropy', 'monitor_metric': 'accuracy', 'task_level': 'node', 'data_seed': 0, 'split_type': 'random', 'k': 10, 'train_prop': 0.5, 'batch_size': 1, 'num_workers': 1, 'pin_memory': False}"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "dataset_name = \"cocitation_cora\"\n",
-    "dataset_config = omegaconf.OmegaConf.load(\n",
-    "    f\"{root_folder}/configs/dataset/{dataset_name}.yaml\"\n",
-    ").parameters\n",
-    "#################################################################################################################\n",
-    "# Need to interpolate a couple of paths by hand for now; will be solved when we generate the challenge repository:\n",
-    "dataset_config[\"data_dir\"] = (\n",
-    "    f\"{root_folder}/datasets/{dataset_config['data_domain']}/{dataset_config['data_type']}\"\n",
-    ")\n",
-    "dataset_config[\"data_split_dir\"] = (\n",
-    "    f\"{dataset_config['data_dir']}/data_splits/{dataset_config['data_name']}\"\n",
-    ")\n",
-    "#################################################################################################################\n",
-    "dataset_config"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Import Transform Config"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Same dilemma as before, yaml files or dicts within tutorials."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'lifting': {'_target_': 'topobenchmarkx.transforms.data_transform.DataTransform', 'transform_type': 'lifting', 'transform_name': 'SimplicialCliqueLifting', 'complex_dim': '${oc.select:dataset.parameters.max_dim_if_lifted,2}', 'preserve_edge_attr': '${oc.select:dataset.parameters.preserve_edge_attr_if_lifted,False}', 'signed': True, 'feature_lifting': 'ProjectionSum'}}\n"
-     ]
-    }
-   ],
-   "source": [
-    "lifting_type = \"graph2simplicial\"\n",
-    "id_lifting = \"simplicial_clique\"\n",
-    "transform_config = {\n",
-    "    \"lifting\": omegaconf.OmegaConf.load(\n",
-    "        f\"{root_folder}/configs/dataset/transforms/{lifting_type}_lifting/{id_lifting}.yaml\"\n",
-    "    )\n",
-    "    # other transforms (e.g. data manipulations, feature liftings) can be added here\n",
-    "}\n",
-    "print(transform_config)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Load and Transform the Dataset"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Transform parameters are the same, using existing data_dir: /Users/gbg141/Documents/TopoProjectX/TopoBenchmarkX/datasets/graph/cocitation/Cora/lifting/4278182681\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/gbg141/Documents/TopoProjectX/TopoBenchmarkX/venv_topox/lib/python3.11/site-packages/torch_geometric/data/in_memory_dataset.py:293: UserWarning: It is not recommended to directly access the internal storage format `data` of an 'InMemoryDataset'. If you are absolutely certain what you are doing, access the internal storage via `InMemoryDataset._data` instead to suppress this warning. Alternatively, you can access stacked individual attributes of every graph via `dataset.{attr_name}`.\n",
-      "  warnings.warn(msg)\n"
-     ]
-    }
-   ],
-   "source": [
-    "dataset = GraphLoader(dataset_config, transform_config).load()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Create a Neural Network Model"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "from topomodelx.nn.simplicial.san import SAN\n",
-    "\n",
-    "\n",
-    "class Network(torch.nn.Module):\n",
-    "    def __init__(self, in_channels, hidden_channels, out_channels, n_layers=1):\n",
-    "        super().__init__()\n",
-    "        self.base_model = SAN(\n",
-    "            in_channels=in_channels,\n",
-    "            hidden_channels=hidden_channels,\n",
-    "            n_layers=n_layers,\n",
-    "        )\n",
-    "        self.linear = torch.nn.Linear(hidden_channels, out_channels)\n",
-    "\n",
-    "    def forward(self, x, laplacian_up, laplacian_down):\n",
-    "        x = self.base_model(x, laplacian_up, laplacian_down)\n",
-    "        x = self.linear(x)\n",
-    "        return torch.sigmoid(x)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Run the Model"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "n_layers = 2\n",
-    "in_channels = dataset_config[\"num_features\"]\n",
-    "hidden_channels = 32\n",
-    "out_channels = dataset_config[\"num_classes\"]\n",
-    "\n",
-    "model = Network(\n",
-    "    in_channels=in_channels,\n",
-    "    hidden_channels=hidden_channels,\n",
-    "    out_channels=out_channels,\n",
-    "    n_layers=n_layers,\n",
-    ")\n",
-    "\n",
-    "data = dataset.data_lst[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "y_hat = model(data.x_1, data.up_laplacian_1, data.down_laplacian_1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "venv_topox",
-   "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.11.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/notebooks/play.ipynb b/notebooks/play.ipynb
deleted file mode 100644
index 04879188..00000000
--- a/notebooks/play.ipynb
+++ /dev/null
@@ -1,281 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 56,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import urllib.request\n",
-    "\n",
-    "import numpy as np\n",
-    "import torch\n",
-    "import torch_geometric\n",
-    "\n",
-    "\n",
-    "def hetero_load(name, path):\n",
-    "    file_name = f\"{name}.npz\"\n",
-    "\n",
-    "    data = np.load(os.path.join(path, file_name))\n",
-    "\n",
-    "    x = torch.tensor(data[\"node_features\"])\n",
-    "    y = torch.tensor(data[\"node_labels\"])\n",
-    "    edge_index = torch.tensor(data[\"edges\"]).T\n",
-    "\n",
-    "    # Make edge_index undirected\n",
-    "    edge_index = torch_geometric.utils.to_undirected(edge_index)\n",
-    "\n",
-    "    # Remove self-loops\n",
-    "    edge_index, _ = torch_geometric.utils.remove_self_loops(edge_index)\n",
-    "\n",
-    "    data = torch_geometric.data.Data(x=x, y=y, edge_index=edge_index)\n",
-    "    return data\n",
-    "\n",
-    "\n",
-    "def download_hetero_datasets(name, path):\n",
-    "    url = \"https://github.com/OpenGSL/HeterophilousDatasets/raw/main/data/\"\n",
-    "    name = f\"{name}.npz\"\n",
-    "    try:\n",
-    "        print(f\"Downloading {name}\")\n",
-    "        path2save = os.path.join(path, name)\n",
-    "        urllib.request.urlretrieve(url + name, path2save)\n",
-    "        print(\"Done!\")\n",
-    "    except:\n",
-    "        raise Exception(\n",
-    "            \"\"\"Download failed! Make sure you have stable Internet connection and enter the right name\"\"\"\n",
-    "        )\n",
-    "\n",
-    "\n",
-    "import os.path as osp\n",
-    "from collections.abc import Callable\n",
-    "\n",
-    "from omegaconf import DictConfig\n",
-    "from torch_geometric.data import Data, InMemoryDataset\n",
-    "from torch_geometric.io import fs\n",
-    "\n",
-    "from topobenchmarkx.data.load.heterophilic import (\n",
-    "    download_hetero_datasets,\n",
-    "    load_heterophilic_data,\n",
-    ")\n",
-    "from topobenchmarkx.data.load.split_utils import random_splitting\n",
-    "\n",
-    "\n",
-    "class HeteroDataset(InMemoryDataset):\n",
-    "    r\"\"\"\n",
-    "    Dataset class for US County Demographics dataset.\n",
-    "\n",
-    "    Args:\n",
-    "        root (str): Root directory where the dataset will be saved.\n",
-    "        name (str): Name of the dataset.\n",
-    "        parameters (DictConfig): Configuration parameters for the dataset.\n",
-    "        transform (Optional[Callable]): A function/transform that takes in an\n",
-    "            `torch_geometric.data.Data` object and returns a transformed version.\n",
-    "            The transform function is applied to the loaded data before saving it.\n",
-    "        pre_transform (Optional[Callable]): A function/transform that takes in an\n",
-    "            `torch_geometric.data.Data` object and returns a transformed version.\n",
-    "            The pre_transform function is applied to the data before the transform\n",
-    "            function is applied.\n",
-    "        pre_filter (Optional[Callable]): A function that takes in an\n",
-    "            `torch_geometric.data.Data` object and returns a boolean value\n",
-    "            indicating whether the data object should be included in the dataset.\n",
-    "        force_reload (bool): If set to True, the dataset will be re-downloaded\n",
-    "            even if it already exists on disk. (default: True)\n",
-    "        use_node_attr (bool): If set to True, the node attributes will be included\n",
-    "            in the dataset. (default: False)\n",
-    "        use_edge_attr (bool): If set to True, the edge attributes will be included\n",
-    "            in the dataset. (default: False)\n",
-    "\n",
-    "    Attributes:\n",
-    "        URLS (dict): Dictionary containing the URLs for downloading the dataset.\n",
-    "        FILE_FORMAT (dict): Dictionary containing the file formats for the dataset.\n",
-    "        RAW_FILE_NAMES (dict): Dictionary containing the raw file names for the dataset.\n",
-    "\n",
-    "    \"\"\"\n",
-    "\n",
-    "    RAW_FILE_NAMES = {}\n",
-    "\n",
-    "    def __init__(\n",
-    "        self,\n",
-    "        root: str,\n",
-    "        name: str,\n",
-    "        parameters: DictConfig,\n",
-    "        transform: Callable | None = None,\n",
-    "        pre_transform: Callable | None = None,\n",
-    "        pre_filter: Callable | None = None,\n",
-    "        force_reload: bool = True,\n",
-    "        use_node_attr: bool = False,\n",
-    "        use_edge_attr: bool = False,\n",
-    "    ) -> None:\n",
-    "        self.name = name  # .replace(\"_\", \"-\")\n",
-    "        self.parameters = parameters\n",
-    "        super().__init__(\n",
-    "            root, transform, pre_transform, pre_filter, force_reload=force_reload\n",
-    "        )\n",
-    "\n",
-    "        # Step 3:Load the processed data\n",
-    "        # After the data has been downloaded from source\n",
-    "        # Then preprocessed to obtain x,y and saved into processed folder\n",
-    "        # We can now load the processed data from processed folder\n",
-    "\n",
-    "        # Load the processed data\n",
-    "        data, _, _ = fs.torch_load(self.processed_paths[0])\n",
-    "\n",
-    "        # Map the loaded data into\n",
-    "        data = Data.from_dict(data)\n",
-    "\n",
-    "        # Step 5: Create the splits and upload desired fold\n",
-    "        splits = random_splitting(data.y, parameters=self.parameters)\n",
-    "\n",
-    "        # Assign train val test masks to the graph\n",
-    "        data.train_mask = torch.from_numpy(splits[\"train\"])\n",
-    "        data.val_mask = torch.from_numpy(splits[\"valid\"])\n",
-    "        data.test_mask = torch.from_numpy(splits[\"test\"])\n",
-    "\n",
-    "        # Assign data object to self.data, to make it be prodessed by Dataset class\n",
-    "        self.data, self.slices = self.collate([data])\n",
-    "\n",
-    "    # Do not forget to take care of properties\n",
-    "    @property\n",
-    "    def raw_dir(self) -> str:\n",
-    "        return osp.join(self.root, self.name, \"raw\")\n",
-    "\n",
-    "    @property\n",
-    "    def processed_dir(self) -> str:\n",
-    "        return osp.join(self.root, self.name, \"processed\")\n",
-    "\n",
-    "    @property\n",
-    "    def processed_file_names(self) -> str:\n",
-    "        return \"data.pt\"\n",
-    "\n",
-    "    @property\n",
-    "    def raw_file_names(self) -> list[str]:\n",
-    "        \"\"\"Spefify the downloaded raw fine name\"\"\"\n",
-    "        return [f\"{self.name}.npz\"]\n",
-    "\n",
-    "    def download(self) -> None:\n",
-    "        \"\"\"\n",
-    "        Downloads the dataset from the specified URL and saves it to the raw directory.\n",
-    "\n",
-    "        Raises:\n",
-    "            FileNotFoundError: If the dataset URL is not found.\n",
-    "        \"\"\"\n",
-    "\n",
-    "        # Step 1: Download data from the source\n",
-    "        download_hetero_datasets(name=self.name, path=self.raw_dir)\n",
-    "\n",
-    "    def process(self) -> None:\n",
-    "        \"\"\"\n",
-    "        Process the data for the dataset.\n",
-    "\n",
-    "        This method loads the US county demographics data, applies any pre-processing transformations if specified,\n",
-    "        and saves the processed data to the appropriate location.\n",
-    "\n",
-    "        Returns:\n",
-    "            None\n",
-    "        \"\"\"\n",
-    "\n",
-    "        data = load_heterophilic_data(name=self.name, path=self.raw_dir)\n",
-    "        data = data if self.pre_transform is None else self.pre_transform(data)\n",
-    "        self.save([data], self.processed_paths[0])\n",
-    "\n",
-    "    def __repr__(self) -> str:\n",
-    "        return f\"{self.name}()\"\n",
-    "\n",
-    "\n",
-    "data_dir = \"/home/lev/projects/TopoBenchmarkX/datasets\"\n",
-    "data_domain = \"graph\"\n",
-    "data_type = \"heterophilic\"\n",
-    "data_name = \"amazon_ratings\"\n",
-    "\n",
-    "data_dir = f\"{data_dir}/{data_domain}/{data_type}\"\n",
-    "\n",
-    "parameters = {\n",
-    "    \"split_type\": \"random\",\n",
-    "    \"k\": 10,\n",
-    "    \"train_prop\": 0.5,\n",
-    "    \"data_seed\": 0,\n",
-    "    \"data_split_dir\": f\"/home/lev/projects/TopoBenchmarkX/datasets/data_splits/{data_name}\",\n",
-    "}\n",
-    "\n",
-    "dataset = HeteroDataset(\n",
-    "    name=data_name, root=data_dir, parameters=parameters, force_reload=True\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 57,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Processing...\n",
-      "Done!\n"
-     ]
-    }
-   ],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "dataset[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "topo",
-   "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.11.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/notebooks/result_processing.ipynb b/notebooks/result_processing.ipynb
deleted file mode 100644
index 7708a01f..00000000
--- a/notebooks/result_processing.ipynb
+++ /dev/null
@@ -1,6737 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import ast\n",
-    "import glob\n",
-    "import warnings\n",
-    "from collections import defaultdict\n",
-    "from datetime import date\n",
-    "\n",
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "import wandb\n",
-    "\n",
-    "today = date.today()\n",
-    "api = wandb.Api()\n",
-    "\n",
-    "# # Find all csv files in the current directory\n",
-    "csv_files = glob.glob(\"*.csv\")\n",
-    "# # Collect all the names of the csv files without the extension\n",
-    "csv_names = [csv_file[:-4] for csv_file in csv_files]\n",
-    "project_name = \"topobenchmark_0503\"  #'best_results_edhnn'\n",
-    "user = \"telyatnikov_sap\"\n",
-    "\n",
-    "if project_name not in csv_names:\n",
-    "    runs = api.runs(f\"{user}/{project_name}\")\n",
-    "\n",
-    "    summary_list, config_list, name_list = [], [], []\n",
-    "    for run in runs:\n",
-    "        # .summary contains the output keys/values for metrics like accuracy.\n",
-    "        #  We call ._json_dict to omit large files\n",
-    "        summary_list.append(run.summary._json_dict)\n",
-    "\n",
-    "        # .config contains the hyperparameters.\n",
-    "        #  We remove special values that start with _.\n",
-    "        config_list.append(\n",
-    "            {k: v for k, v in run.config.items() if not k.startswith(\"_\")}\n",
-    "        )\n",
-    "\n",
-    "        # .name is the human-readable name of the run.\n",
-    "        name_list.append(run.name)\n",
-    "\n",
-    "    runs_df = pd.DataFrame(\n",
-    "        {\"summary\": summary_list, \"config\": config_list, \"name\": name_list}\n",
-    "    )\n",
-    "\n",
-    "    runs_df.to_csv(f\"{project_name}.csv\")\n",
-    "else:\n",
-    "    runs_df = pd.read_csv(f\"{project_name}.csv\", index_col=0)\n",
-    "\n",
-    "    for row in runs_df.iloc:\n",
-    "        row[\"summary\"] = ast.literal_eval(row[\"summary\"])\n",
-    "        row[\"config\"] = ast.literal_eval(row[\"config\"])\n",
-    "\n",
-    "\n",
-    "for row in runs_df.iloc:\n",
-    "    row[\"summary\"].update(row[\"config\"])\n",
-    "\n",
-    "lst = [i[\"summary\"] for i in runs_df.iloc]\n",
-    "df = pd.DataFrame.from_dict(lst)\n",
-    "\n",
-    "df_init = df.copy()\n",
-    "\n",
-    "# Get average epoch run time\n",
-    "df[\"epoch_run_time\"] = df[\"_runtime\"] / df[\"epoch\"]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Index(['_step', 'lr-Adam', '_runtime', 'val/loss', 'train/loss',\n",
-       "       'val/accuracy', 'train/accuracy', 'epoch', '_timestamp',\n",
-       "       'trainer/global_step', 'seed', 'tags', 'model', 'extras', 'dataset',\n",
-       "       'trainer', 'callbacks', 'ckpt_path', 'task_name', 'model/params/total',\n",
-       "       'model/params/trainable', 'model/params/non_trainable', '_wandb',\n",
-       "       'test/loss', 'test/accuracy', 'val/mse', 'test/mse', 'train/mse',\n",
-       "       'val/mae', 'train/mae', 'test/mae'],\n",
-       "      dtype='object')"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "df_init.columns"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'enforce_tags': True, 'print_config': True, 'ignore_warnings': False}"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "df_init[\"extras\"][0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "KeyError",
-     "evalue": "'model'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
-      "File \u001b[0;32m~/miniconda3/envs/topox/lib/python3.11/site-packages/pandas/core/indexes/base.py:3805\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m   3804\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 3805\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_engine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcasted_key\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   3806\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m err:\n",
-      "File \u001b[0;32mindex.pyx:167\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n",
-      "File \u001b[0;32mindex.pyx:196\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n",
-      "File \u001b[0;32mpandas/_libs/hashtable_class_helper.pxi:7081\u001b[0m, in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n",
-      "File \u001b[0;32mpandas/_libs/hashtable_class_helper.pxi:7089\u001b[0m, in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n",
-      "\u001b[0;31mKeyError\u001b[0m: 'model'",
-      "\nThe above exception was the direct cause of the following exception:\n",
-      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[7], line 23\u001b[0m\n\u001b[1;32m     21\u001b[0m config_columns \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m     22\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m column \u001b[38;5;129;01min\u001b[39;00m columns_to_normalize:\n\u001b[0;32m---> 23\u001b[0m     df, columns \u001b[38;5;241m=\u001b[39m \u001b[43mnormalize_column\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcolumn\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     24\u001b[0m     config_columns\u001b[38;5;241m.\u001b[39mextend(columns)\n",
-      "Cell \u001b[0;32mIn[7], line 3\u001b[0m, in \u001b[0;36mnormalize_column\u001b[0;34m(df, column_to_normalize)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mnormalize_column\u001b[39m(df, column_to_normalize):\n\u001b[1;32m      2\u001b[0m     \u001b[38;5;66;03m# Use json_normalize to flatten the nested dictionaries into separate columns\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m     flattened_df \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mjson_normalize(\u001b[43mdf\u001b[49m\u001b[43m[\u001b[49m\u001b[43mcolumn_to_normalize\u001b[49m\u001b[43m]\u001b[49m)\n\u001b[1;32m      4\u001b[0m     \u001b[38;5;66;03m# Rename columns to include 'nested_column' prefix\u001b[39;00m\n\u001b[1;32m      5\u001b[0m     flattened_df\u001b[38;5;241m.\u001b[39mcolumns \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m      6\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mcolumn_to_normalize\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mcol\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m col \u001b[38;5;129;01min\u001b[39;00m flattened_df\u001b[38;5;241m.\u001b[39mcolumns\n\u001b[1;32m      7\u001b[0m     ]\n",
-      "File \u001b[0;32m~/miniconda3/envs/topox/lib/python3.11/site-packages/pandas/core/frame.py:4102\u001b[0m, in \u001b[0;36mDataFrame.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m   4100\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcolumns\u001b[38;5;241m.\u001b[39mnlevels \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m   4101\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_getitem_multilevel(key)\n\u001b[0;32m-> 4102\u001b[0m indexer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcolumns\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   4103\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_integer(indexer):\n\u001b[1;32m   4104\u001b[0m     indexer \u001b[38;5;241m=\u001b[39m [indexer]\n",
-      "File \u001b[0;32m~/miniconda3/envs/topox/lib/python3.11/site-packages/pandas/core/indexes/base.py:3812\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m   3807\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(casted_key, \u001b[38;5;28mslice\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m (\n\u001b[1;32m   3808\u001b[0m         \u001b[38;5;28misinstance\u001b[39m(casted_key, abc\u001b[38;5;241m.\u001b[39mIterable)\n\u001b[1;32m   3809\u001b[0m         \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28many\u001b[39m(\u001b[38;5;28misinstance\u001b[39m(x, \u001b[38;5;28mslice\u001b[39m) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m casted_key)\n\u001b[1;32m   3810\u001b[0m     ):\n\u001b[1;32m   3811\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m InvalidIndexError(key)\n\u001b[0;32m-> 3812\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(key) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01merr\u001b[39;00m\n\u001b[1;32m   3813\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[1;32m   3814\u001b[0m     \u001b[38;5;66;03m# If we have a listlike key, _check_indexing_error will raise\u001b[39;00m\n\u001b[1;32m   3815\u001b[0m     \u001b[38;5;66;03m#  InvalidIndexError. Otherwise we fall through and re-raise\u001b[39;00m\n\u001b[1;32m   3816\u001b[0m     \u001b[38;5;66;03m#  the TypeError.\u001b[39;00m\n\u001b[1;32m   3817\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_check_indexing_error(key)\n",
-      "\u001b[0;31mKeyError\u001b[0m: 'model'"
-     ]
-    }
-   ],
-   "source": [
-    "def normalize_column(df, column_to_normalize):\n",
-    "    # Use json_normalize to flatten the nested dictionaries into separate columns\n",
-    "    flattened_df = pd.json_normalize(df[column_to_normalize])\n",
-    "    # Rename columns to include 'nested_column' prefix\n",
-    "    flattened_df.columns = [\n",
-    "        f\"{column_to_normalize}.{col}\" for col in flattened_df.columns\n",
-    "    ]\n",
-    "    # Concatenate the flattened DataFrame with the original DataFrame\n",
-    "    result_df = pd.concat([df, flattened_df], axis=1)\n",
-    "    # Get new columns names\n",
-    "    new_columns = flattened_df.columns\n",
-    "    # Drop the original nested column if needed\n",
-    "    result_df.drop(column_to_normalize, axis=1, inplace=True)\n",
-    "    return result_df, new_columns\n",
-    "\n",
-    "\n",
-    "# Config columns to normalize\n",
-    "columns_to_normalize = [\"model\", \"dataset\", \"callbacks\", \"paths\"]\n",
-    "\n",
-    "# Keep track of config columns added\n",
-    "config_columns = []\n",
-    "for column in columns_to_normalize:\n",
-    "    df, columns = normalize_column(df, column)\n",
-    "    config_columns.extend(columns)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['_step',\n",
-       " 'lr-Adam',\n",
-       " '_runtime',\n",
-       " 'val/loss',\n",
-       " 'train/loss',\n",
-       " 'val/accuracy',\n",
-       " 'train/accuracy',\n",
-       " 'epoch',\n",
-       " '_timestamp',\n",
-       " 'trainer/global_step',\n",
-       " 'seed',\n",
-       " 'tags',\n",
-       " 'extras',\n",
-       " 'trainer',\n",
-       " 'ckpt_path',\n",
-       " 'task_name',\n",
-       " 'model/params/total',\n",
-       " 'model/params/trainable',\n",
-       " 'model/params/non_trainable',\n",
-       " '_wandb',\n",
-       " 'test/loss',\n",
-       " 'test/accuracy',\n",
-       " 'val/mse',\n",
-       " 'test/mse',\n",
-       " 'train/mse',\n",
-       " 'val/mae',\n",
-       " 'train/mae',\n",
-       " 'test/mae',\n",
-       " 'epoch_run_time',\n",
-       " 'model.compile',\n",
-       " 'model._target_',\n",
-       " 'model.loss.task',\n",
-       " 'model.loss._target_',\n",
-       " 'model.loss.loss_type',\n",
-       " 'model.readout._target_',\n",
-       " 'model.readout.task_level',\n",
-       " 'model.readout.in_channels',\n",
-       " 'model.readout.out_channels',\n",
-       " 'model.readout.pooling_type',\n",
-       " 'model.backbone._target_',\n",
-       " 'model.backbone.n_layers',\n",
-       " 'model.backbone.sc_order',\n",
-       " 'model.backbone.aggr_norm',\n",
-       " 'model.backbone.conv_order',\n",
-       " 'model.backbone.update_func',\n",
-       " 'model.backbone.in_channels_all',\n",
-       " 'model.backbone.hidden_channels_all',\n",
-       " 'model.optimizer.lr',\n",
-       " 'model.optimizer._target_',\n",
-       " 'model.optimizer._partial_',\n",
-       " 'model.optimizer.weight_decay',\n",
-       " 'model.scheduler._target_',\n",
-       " 'model.scheduler._partial_',\n",
-       " 'model.scheduler.last_epoch',\n",
-       " 'model.scheduler.total_iters',\n",
-       " 'model.feature_encoder._target_',\n",
-       " 'model.feature_encoder.in_channels',\n",
-       " 'model.feature_encoder.out_channels',\n",
-       " 'model.feature_encoder.selected_dimensions',\n",
-       " 'model.backbone_wrapper._target_',\n",
-       " 'model.backbone_wrapper._partial_',\n",
-       " 'model.backbone_wrapper.out_channels',\n",
-       " 'model.backbone_wrapper.wrapper_readout',\n",
-       " 'model.backbone.channels',\n",
-       " 'model.backbone.max_rank',\n",
-       " 'model.backbone.dropout',\n",
-       " 'model.backbone.in_channels',\n",
-       " 'model.scheduler.gamma',\n",
-       " 'model.scheduler.step_size',\n",
-       " 'model.feature_encoder.proj_dropout',\n",
-       " 'model.backbone.hid_channels',\n",
-       " 'model.backbone.in_channels_0',\n",
-       " 'model.backbone.in_channels_1',\n",
-       " 'model.backbone.in_channels_2',\n",
-       " 'model.backbone.act',\n",
-       " 'model.backbone.num_layers',\n",
-       " 'model.backbone.hidden_channels',\n",
-       " 'model.model_name',\n",
-       " 'model.backbone.mlp_norm._target_',\n",
-       " 'model.backbone.mlp_norm._partial_',\n",
-       " 'model.backbone.mlp_dropout',\n",
-       " 'model.backbone.layer_dropout',\n",
-       " 'model.backbone.mlp_activation._target_',\n",
-       " 'model.backbone.mlp_activation._partial_',\n",
-       " 'model.backbone.mlp_num_layers',\n",
-       " 'model.backbone.beta',\n",
-       " 'model.backbone.alpha',\n",
-       " 'model.backbone.input_drop',\n",
-       " 'model.backbone.layer_drop',\n",
-       " 'model.model_domain',\n",
-       " 'model.backbone.aggregate',\n",
-       " 'model.backbone.activation',\n",
-       " 'model.backbone.edconv_type',\n",
-       " 'model.backbone.num_features',\n",
-       " 'model.backbone.input_dropout',\n",
-       " 'model.backbone.All_num_layers',\n",
-       " 'model.backbone.MLP_num_layers',\n",
-       " 'dataset._target_',\n",
-       " 'dataset.parameters.k',\n",
-       " 'dataset.parameters.task',\n",
-       " 'dataset.parameters.data_dir',\n",
-       " 'dataset.parameters.data_name',\n",
-       " 'dataset.parameters.data_seed',\n",
-       " 'dataset.parameters.data_type',\n",
-       " 'dataset.parameters.loss_type',\n",
-       " 'dataset.parameters.batch_size',\n",
-       " 'dataset.parameters.pin_memory',\n",
-       " 'dataset.parameters.split_type',\n",
-       " 'dataset.parameters.task_level',\n",
-       " 'dataset.parameters.data_domain',\n",
-       " 'dataset.parameters.num_classes',\n",
-       " 'dataset.parameters.num_workers',\n",
-       " 'dataset.parameters.num_features',\n",
-       " 'dataset.parameters.data_split_dir',\n",
-       " 'dataset.parameters.monitor_metric',\n",
-       " 'dataset.transforms.graph2simplicial_lifting.signed',\n",
-       " 'dataset.transforms.graph2simplicial_lifting._target_',\n",
-       " 'dataset.transforms.graph2simplicial_lifting.complex_dim',\n",
-       " 'dataset.transforms.graph2simplicial_lifting.transform_name',\n",
-       " 'dataset.transforms.graph2simplicial_lifting.transform_type',\n",
-       " 'dataset.transforms.graph2simplicial_lifting.feature_lifting',\n",
-       " 'dataset.transforms.graph2simplicial_lifting.preserve_edge_attr',\n",
-       " 'dataset.transforms.data_manipulations._target_',\n",
-       " 'dataset.transforms.data_manipulations.transform_name',\n",
-       " 'dataset.transforms.data_manipulations.transform_type',\n",
-       " 'dataset.parameters.max_dim_if_lifted',\n",
-       " 'dataset.parameters.preserve_edge_attr_if_lifted',\n",
-       " 'dataset.transforms.graph2cell_lifting.k_value',\n",
-       " 'dataset.transforms.graph2cell_lifting._target_',\n",
-       " 'dataset.transforms.graph2cell_lifting.complex_dim',\n",
-       " 'dataset.transforms.graph2cell_lifting.transform_name',\n",
-       " 'dataset.transforms.graph2cell_lifting.transform_type',\n",
-       " 'dataset.transforms.graph2cell_lifting.max_cell_length',\n",
-       " 'dataset.transforms.graph2cell_lifting.preserve_edge_attr',\n",
-       " 'dataset.parameters.max_node_degree',\n",
-       " 'dataset.transforms.data_manipulations.std',\n",
-       " 'dataset.transforms.data_manipulations.mean',\n",
-       " 'dataset.transforms.data_manipulations.num_features',\n",
-       " 'dataset.transforms.graph2hypergraph_lifting.k_value',\n",
-       " 'dataset.transforms.graph2hypergraph_lifting._target_',\n",
-       " 'dataset.transforms.graph2hypergraph_lifting.transform_name',\n",
-       " 'dataset.transforms.graph2hypergraph_lifting.transform_type',\n",
-       " 'dataset.parameters.max_x_1_degree',\n",
-       " 'dataset.transforms.data_manipulations.selected_fields',\n",
-       " 'dataset.transforms.one_hot_node_degree_features._target_',\n",
-       " 'dataset.transforms.one_hot_node_degree_features.max_degrees',\n",
-       " 'dataset.transforms.one_hot_node_degree_features.degrees_fields',\n",
-       " 'dataset.transforms.one_hot_node_degree_features.transform_name',\n",
-       " 'dataset.transforms.one_hot_node_degree_features.transform_type',\n",
-       " 'dataset.transforms.one_hot_node_degree_features.features_fields',\n",
-       " 'callbacks.model_summary._target_',\n",
-       " 'callbacks.model_summary.max_depth',\n",
-       " 'callbacks.early_stopping.mode',\n",
-       " 'callbacks.early_stopping.strict',\n",
-       " 'callbacks.early_stopping.monitor',\n",
-       " 'callbacks.early_stopping.verbose',\n",
-       " 'callbacks.early_stopping._target_',\n",
-       " 'callbacks.early_stopping.patience',\n",
-       " 'callbacks.early_stopping.min_delta',\n",
-       " 'callbacks.early_stopping.check_finite',\n",
-       " 'callbacks.early_stopping.stopping_threshold',\n",
-       " 'callbacks.early_stopping.divergence_threshold',\n",
-       " 'callbacks.early_stopping.check_on_train_epoch_end',\n",
-       " 'callbacks.model_checkpoint.mode',\n",
-       " 'callbacks.model_checkpoint.dirpath',\n",
-       " 'callbacks.model_checkpoint.monitor',\n",
-       " 'callbacks.model_checkpoint.verbose',\n",
-       " 'callbacks.model_checkpoint._target_',\n",
-       " 'callbacks.model_checkpoint.filename',\n",
-       " 'callbacks.model_checkpoint.save_last',\n",
-       " 'callbacks.model_checkpoint.save_top_k',\n",
-       " 'callbacks.model_checkpoint.every_n_epochs',\n",
-       " 'callbacks.model_checkpoint.save_weights_only',\n",
-       " 'callbacks.model_checkpoint.every_n_train_steps',\n",
-       " 'callbacks.model_checkpoint.train_time_interval',\n",
-       " 'callbacks.model_checkpoint.auto_insert_metric_name',\n",
-       " 'callbacks.model_checkpoint.save_on_train_epoch_end',\n",
-       " 'callbacks.rich_progress_bar._target_',\n",
-       " 'callbacks.learning_rate_monitor._target_',\n",
-       " 'callbacks.learning_rate_monitor.logging_interval']"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "list(df.keys())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Remove columns that are not needed (we shouldn't vary them or their variation is not interesting)\n",
-    "remove_col = [\n",
-    "    \"dataset.transforms.data_manipulations.selected_fields\",\n",
-    "    \"callbacks.model_checkpoint.dirpath\",\n",
-    "]\n",
-    "df = df.drop(remove_col, axis=1)\n",
-    "\n",
-    "# Ensure that removed columns are not present in config_columns\n",
-    "config_columns = [col for col in config_columns if col != remove_col]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Number of rows with model.backbone._target_ = nan is 4\n",
-      "Number of rows with callbacks.early_stopping.monitor = nan is 0\n",
-      "Because of SCCN and CWN false runs there were 96 such runs on 13/03/24\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\n",
-    "    f\"Number of rows with model.backbone._target_ = nan is {sum(df['model.backbone._target_'].isna())}\"\n",
-    ")\n",
-    "# Drop na values if there are\n",
-    "df = df.dropna(subset=[\"model.backbone._target_\"])\n",
-    "# Reset index\n",
-    "df = df.reset_index(drop=True)\n",
-    "\n",
-    "# Drop rows that 'callbacks.early_stopping.monitor' isna\n",
-    "print(\n",
-    "    f\"Number of rows with callbacks.early_stopping.monitor = nan is {sum(df['callbacks.early_stopping.monitor'].isna())}\"\n",
-    ")\n",
-    "print(\"Because of SCCN and CWN false runs there were 96 such runs on 13/03/24\")\n",
-    "df = df.dropna(subset=[\"callbacks.early_stopping.monitor\"])\n",
-    "# Reset index\n",
-    "df = df.reset_index(drop=True)\n",
-    "\n",
-    "\n",
-    "# Get correct names for the models\n",
-    "df[\"model.backbone._target_\"] = df[\"model.backbone._target_\"].apply(\n",
-    "    lambda x: x.split(\".\")[-1]\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array(['SCCNNCustom', 'SCCN', 'SCCNN', 'CWNDCM', 'CWN', 'GCN', 'AllSet',\n",
-       "       'UniGCNII', 'EDGNN', 'GIN'], dtype=object)"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "df[\"model.backbone._target_\"].unique()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Attention the columns: model.backbone.in_channels_all, has issues with unique values\n",
-      "Attention the columns: model.backbone.hidden_channels_all, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCNNCustom on NCI1:\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.backbone_wrapper.wrapper_readout: ['signal_prop_down' 'original']\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCN on NCI1:\n",
-      "model.readout.in_channels: [16. 64.]\n",
-      "\n",
-      "model.readout.pooling_type: ['sum' 'mean']\n",
-      "\n",
-      "model.backbone.n_layers: [1. 2.]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [16. 64.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [16. 64.]\n",
-      "\n",
-      "model.backbone_wrapper.wrapper_readout: ['original' 'signal_prop_down']\n",
-      "\n",
-      "model.backbone.channels: [16. 64.]\n",
-      "\n",
-      "model.backbone.max_rank: [1. 2.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [0. 5. 3.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [True False]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.feature_lifting: ['concatenation' 'ProjectionSum' nan]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.backbone.in_channels_all, has issues with unique values\n",
-      "Attention the columns: model.backbone.hidden_channels_all, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCNN on NCI1:\n",
-      "model.readout.in_channels: [64. 16.]\n",
-      "\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.wrapper_readout: ['signal_prop_down' 'original']\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for CWNDCM on NCI1:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.n_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.feature_encoder.proj_dropout: [0.5  0.25]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for CWN on NCI1:\n",
-      "model.readout.in_channels: [ 16. 128.  64.  32.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1. 4. 3.]\n",
-      "\n",
-      "model.optimizer.lr: [0.01  0.001]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [ 16. 128.  64.  32.]\n",
-      "\n",
-      "model.feature_encoder.proj_dropout: [0.25 0.5 ]\n",
-      "\n",
-      "model.backbone.hid_channels: [ 16. 128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels_0: [ 16. 128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels_1: [ 16. 128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels_2: [ 16. 128.  64.  32.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [128. 256.]\n",
-      "\n",
-      "dataset.parameters.monitor_metric: ['accuracy' nan]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GCN on NCI1:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for AllSet on NCI1:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.n_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.layer_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.mlp_num_layers: [2. 1.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for UniGCNII on NCI1:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.n_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.input_drop: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.layer_drop: [0.5  0.25 0.  ]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for EDGNN on NCI1:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.num_features: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.input_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.All_num_layers: [3. 2. 1.]\n",
-      "\n",
-      "model.backbone.MLP_num_layers: [2. 1. 0.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GIN on NCI1:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.backbone.in_channels_all, has issues with unique values\n",
-      "Attention the columns: model.backbone.hidden_channels_all, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCNNCustom on PROTEINS:\n",
-      "model.readout.in_channels: [64. 16.]\n",
-      "\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.wrapper_readout: ['signal_prop_down' 'original']\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCN on PROTEINS:\n",
-      "model.readout.in_channels: [64. 16.]\n",
-      "\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.feature_encoder._target_: ['topobenchmarkx.models.encoders.default_encoders.SetFeatureEncoder'\n",
-      " 'topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder']\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.wrapper_readout: ['signal_prop_down' 'original']\n",
-      "\n",
-      "model.backbone.channels: [64. 16.]\n",
-      "\n",
-      "model.backbone.max_rank: [2. 1.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.feature_lifting: ['set' 'concatenation' nan]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.backbone.in_channels_all, has issues with unique values\n",
-      "Attention the columns: model.backbone.hidden_channels_all, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCNN on PROTEINS:\n",
-      "model.readout.in_channels: [64. 16.]\n",
-      "\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.wrapper_readout: ['signal_prop_down' 'original']\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "---------\n",
-      "---------\n",
-      "No results for CWNDCM on PROTEINS\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for CWN on PROTEINS:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.n_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.feature_encoder.proj_dropout: [0.5  0.25]\n",
-      "\n",
-      "model.backbone.hid_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels_0: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels_1: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels_2: [128.  64.  32.  16.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GCN on PROTEINS:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for AllSet on PROTEINS:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.n_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.layer_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.mlp_num_layers: [2. 1.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for UniGCNII on PROTEINS:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.n_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.input_drop: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.layer_drop: [0.5  0.25 0.  ]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for EDGNN on PROTEINS:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.num_features: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.input_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.All_num_layers: [3. 2. 1.]\n",
-      "\n",
-      "model.backbone.MLP_num_layers: [2. 1. 0.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [0. 5. 3.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GIN on PROTEINS:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.backbone.in_channels_all, has issues with unique values\n",
-      "Attention the columns: model.backbone.hidden_channels_all, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCNNCustom on PubMed:\n",
-      "model.readout.in_channels: [64. 32.]\n",
-      "\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 32.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCN on PubMed:\n",
-      "model.readout.in_channels: [64. 32.]\n",
-      "\n",
-      "model.readout.pooling_type: ['sum' 'mean']\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone.channels: [64. 32.]\n",
-      "\n",
-      "model.backbone.max_rank: [2. 1.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [0. 5. 3.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.backbone.in_channels_all, has issues with unique values\n",
-      "Attention the columns: model.backbone.hidden_channels_all, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCNN on PubMed:\n",
-      "model.readout.in_channels: [64. 32.]\n",
-      "\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 32.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for CWNDCM on PubMed:\n",
-      "model.readout.in_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.feature_encoder.proj_dropout: [0.5  0.25]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for CWN on PubMed:\n",
-      "model.readout.in_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.feature_encoder.proj_dropout: [0.5  0.25]\n",
-      "\n",
-      "model.backbone.hid_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels_0: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels_1: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels_2: [128.  64.  32.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GCN on PubMed:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for AllSet on PubMed:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.layer_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.mlp_num_layers: [2. 1.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for UniGCNII on PubMed:\n",
-      "model.readout.in_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.input_drop: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.layer_drop: [0.5  0.25 0.  ]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for EDGNN on PubMed:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.num_features: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.input_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.All_num_layers: [2. 1.]\n",
-      "\n",
-      "model.backbone.MLP_num_layers: [2. 1. 0.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GIN on PubMed:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.backbone.in_channels_all, has issues with unique values\n",
-      "Attention the columns: model.backbone.hidden_channels_all, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCNNCustom on citeseer:\n",
-      "model.readout.in_channels: [64. 32.]\n",
-      "\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 32.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCN on citeseer:\n",
-      "model.readout.in_channels: [64. 32.]\n",
-      "\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone.channels: [64. 32.]\n",
-      "\n",
-      "model.backbone.max_rank: [2. 1.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.backbone.in_channels_all, has issues with unique values\n",
-      "Attention the columns: model.backbone.hidden_channels_all, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCNN on citeseer:\n",
-      "model.readout.in_channels: [64. 32.]\n",
-      "\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 32.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for CWNDCM on citeseer:\n",
-      "model.readout.in_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.feature_encoder.proj_dropout: [0.5  0.25]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for CWN on citeseer:\n",
-      "model.readout.in_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.feature_encoder.proj_dropout: [0.5  0.25]\n",
-      "\n",
-      "model.backbone.hid_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels_0: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels_1: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels_2: [128.  64.  32.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GCN on citeseer:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for AllSet on citeseer:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.layer_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.mlp_num_layers: [2. 1.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for UniGCNII on citeseer:\n",
-      "model.readout.in_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.input_drop: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.layer_drop: [0.5  0.25 0.  ]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for EDGNN on citeseer:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.num_features: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.input_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.All_num_layers: [2. 1.]\n",
-      "\n",
-      "model.backbone.MLP_num_layers: [2. 1. 0.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GIN on citeseer:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.backbone.in_channels_all, has issues with unique values\n",
-      "Attention the columns: model.backbone.hidden_channels_all, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCNNCustom on Cora:\n",
-      "model.readout.in_channels: [64. 32.]\n",
-      "\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 32.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCN on Cora:\n",
-      "model.readout.in_channels: [64. 32.]\n",
-      "\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone.channels: [64. 32.]\n",
-      "\n",
-      "model.backbone.max_rank: [2. 1.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.backbone.in_channels_all, has issues with unique values\n",
-      "Attention the columns: model.backbone.hidden_channels_all, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCNN on Cora:\n",
-      "model.readout.in_channels: [64. 32.]\n",
-      "\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 32.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 32.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for CWNDCM on Cora:\n",
-      "model.readout.in_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.feature_encoder.proj_dropout: [0.5  0.25]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for CWN on Cora:\n",
-      "model.readout.in_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.feature_encoder.proj_dropout: [0.5  0.25]\n",
-      "\n",
-      "model.backbone.hid_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels_0: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels_1: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels_2: [128.  64.  32.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GCN on Cora:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.in_channels: [32. 64.]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for AllSet on Cora:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.layer_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.mlp_num_layers: [2. 1.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for UniGCNII on Cora:\n",
-      "model.readout.in_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [128.  64.  32.]\n",
-      "\n",
-      "model.backbone.input_drop: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.layer_drop: [0.5  0.25 0.  ]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for EDGNN on Cora:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.num_features: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.input_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.All_num_layers: [2. 1.]\n",
-      "\n",
-      "model.backbone.MLP_num_layers: [2. 1. 0.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GIN on Cora:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.backbone.in_channels_all, has issues with unique values\n",
-      "Attention the columns: model.backbone.hidden_channels_all, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCNNCustom on ZINC:\n",
-      "model.readout.in_channels: [64. 16.]\n",
-      "\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [4. 2.]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.wrapper_readout: ['signal_prop_down' 'original']\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCN on ZINC:\n",
-      "model.readout.in_channels: [64. 16.]\n",
-      "\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [4. 2.]\n",
-      "\n",
-      "model.feature_encoder._target_: ['topobenchmarkx.models.encoders.default_encoders.SetFeatureEncoder'\n",
-      " 'topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder']\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.wrapper_readout: ['signal_prop_down' 'original']\n",
-      "\n",
-      "model.backbone.channels: [64. 16.]\n",
-      "\n",
-      "model.backbone.max_rank: [2. 1.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [128. 256.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.feature_lifting: ['set' 'concatenation' nan]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.backbone.in_channels_all, has issues with unique values\n",
-      "Attention the columns: model.backbone.hidden_channels_all, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCNN on ZINC:\n",
-      "model.readout.in_channels: [64. 16.]\n",
-      "\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [4. 2.]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.wrapper_readout: ['signal_prop_down' 'original']\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for CWNDCM on ZINC:\n",
-      "model.readout.in_channels: [ 16. 128.  64.  32.]\n",
-      "\n",
-      "model.backbone.n_layers: [1. 4. 3. 2.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [ 16. 128.  64.  32.]\n",
-      "\n",
-      "model.backbone.in_channels: [ 16. 128.  64.  32.]\n",
-      "\n",
-      "model.feature_encoder.proj_dropout: [0.5  0.25]\n",
-      "\n",
-      "dataset.parameters.batch_size: [128. 256.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for CWN on ZINC:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.n_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.feature_encoder.proj_dropout: [0.5  0.25]\n",
-      "\n",
-      "model.backbone.hid_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels_0: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels_1: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels_2: [128.  64.  32.  16.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GCN on ZINC:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "---------\n",
-      "No results for AllSet on ZINC\n",
-      "---------\n",
-      "---------\n",
-      "No results for UniGCNII on ZINC\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for EDGNN on ZINC:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.num_features: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.input_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.All_num_layers: [3. 2. 1.]\n",
-      "\n",
-      "model.backbone.MLP_num_layers: [2. 1. 0.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [0. 3.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GIN on ZINC:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "---------\n",
-      "No results for SCCNNCustom on MUTAG\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.parameters.num_features, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCN on MUTAG:\n",
-      "model.readout.in_channels: [64. 16.]\n",
-      "\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.wrapper_readout: ['signal_prop_down' 'original']\n",
-      "\n",
-      "model.backbone.channels: [64. 16.]\n",
-      "\n",
-      "model.backbone.max_rank: [2. 1.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.backbone.in_channels_all, has issues with unique values\n",
-      "Attention the columns: model.backbone.hidden_channels_all, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: model.feature_encoder.selected_dimensions, has issues with unique values\n",
-      "Attention the columns: dataset.parameters.num_features, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for SCCNN on MUTAG:\n",
-      "model.readout.in_channels: [64. 16.]\n",
-      "\n",
-      "model.readout.pooling_type: ['mean' 'sum']\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1.]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.out_channels: [64. 16.]\n",
-      "\n",
-      "model.backbone_wrapper.wrapper_readout: ['signal_prop_down' 'original']\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.transforms.graph2simplicial_lifting.signed: [False True]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.parameters.num_features, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for CWNDCM on MUTAG:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.n_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.feature_encoder.proj_dropout: [0.5  0.25]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.parameters.num_features, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for CWN on MUTAG:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.n_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.feature_encoder.proj_dropout: [0.5  0.25]\n",
-      "\n",
-      "model.backbone.hid_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels_0: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels_1: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels_2: [128.  64.  32.  16.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.parameters.num_features, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GCN on MUTAG:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [64. 32.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for AllSet on MUTAG:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.n_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.layer_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.mlp_num_layers: [2. 1.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "---------\n",
-      "No results for UniGCNII on MUTAG\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for EDGNN on MUTAG:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.num_features: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.input_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.All_num_layers: [3. 2. 1.]\n",
-      "\n",
-      "model.backbone.MLP_num_layers: [2. 1. 0.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GIN on MUTAG:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [64. 32.]\n",
-      "\n",
-      "---------\n",
-      "---------\n",
-      "No results for SCCNNCustom on REDDIT-BINARY\n",
-      "---------\n",
-      "---------\n",
-      "No results for SCCN on REDDIT-BINARY\n",
-      "---------\n",
-      "---------\n",
-      "No results for SCCNN on REDDIT-BINARY\n",
-      "---------\n",
-      "---------\n",
-      "No results for CWNDCM on REDDIT-BINARY\n",
-      "---------\n",
-      "---------\n",
-      "No results for CWN on REDDIT-BINARY\n",
-      "---------\n",
-      "Attention the columns: model.feature_encoder.in_channels, has issues with unique values\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GCN on REDDIT-BINARY:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "dataset.parameters.monitor_metric: ['accuracy' nan]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for AllSet on REDDIT-BINARY:\n",
-      "model.readout.in_channels: [ 64.  32.  16. 128.]\n",
-      "\n",
-      "model.backbone.n_layers: [2. 1. 4. 3.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [ 64.  32.  16. 128.]\n",
-      "\n",
-      "model.backbone.in_channels: [ 64.  32.  16. 128.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [ 64.  32.  16. 128.]\n",
-      "\n",
-      "model.backbone.layer_dropout: [0.25 0.   0.5 ]\n",
-      "\n",
-      "model.backbone.mlp_num_layers: [1. 2.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [0. 5. 3.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [128. 256.]\n",
-      "\n",
-      "---------\n",
-      "---------\n",
-      "No results for UniGCNII on REDDIT-BINARY\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for EDGNN on REDDIT-BINARY:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.num_features: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.input_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.All_num_layers: [3. 2. 1.]\n",
-      "\n",
-      "model.backbone.MLP_num_layers: [2. 1. 0.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GIN on REDDIT-BINARY:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "---------\n",
-      "No results for SCCNNCustom on IMDB-MULTI\n",
-      "---------\n",
-      "---------\n",
-      "No results for SCCN on IMDB-MULTI\n",
-      "---------\n",
-      "---------\n",
-      "No results for SCCNN on IMDB-MULTI\n",
-      "---------\n",
-      "---------\n",
-      "No results for CWNDCM on IMDB-MULTI\n",
-      "---------\n",
-      "---------\n",
-      "No results for CWN on IMDB-MULTI\n",
-      "---------\n",
-      "---------\n",
-      "No results for GCN on IMDB-MULTI\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for AllSet on IMDB-MULTI:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.n_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.layer_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.mlp_num_layers: [2. 1.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "---------\n",
-      "No results for UniGCNII on IMDB-MULTI\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for EDGNN on IMDB-MULTI:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.num_features: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.input_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.All_num_layers: [3. 2. 1.]\n",
-      "\n",
-      "model.backbone.MLP_num_layers: [2. 1. 0.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GIN on IMDB-MULTI:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "---------\n",
-      "No results for SCCNNCustom on IMDB-BINARY\n",
-      "---------\n",
-      "---------\n",
-      "No results for SCCN on IMDB-BINARY\n",
-      "---------\n",
-      "---------\n",
-      "No results for SCCNN on IMDB-BINARY\n",
-      "---------\n",
-      "---------\n",
-      "No results for CWNDCM on IMDB-BINARY\n",
-      "---------\n",
-      "---------\n",
-      "No results for CWN on IMDB-BINARY\n",
-      "---------\n",
-      "---------\n",
-      "No results for GCN on IMDB-BINARY\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for AllSet on IMDB-BINARY:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.n_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.layer_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.mlp_num_layers: [2. 1.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "---------\n",
-      "No results for UniGCNII on IMDB-BINARY\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for EDGNN on IMDB-BINARY:\n",
-      "model.readout.in_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.num_features: [128.  64.  32.  16.]\n",
-      "\n",
-      "model.backbone.input_dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.All_num_layers: [3. 2. 1.]\n",
-      "\n",
-      "model.backbone.MLP_num_layers: [2. 1. 0.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n",
-      "Attention the columns: dataset.transforms.data_manipulations.selected_fields, has issues with unique values\n",
-      "Attention the columns: callbacks.model_checkpoint.dirpath, has issues with unique values\n",
-      "Unique values for each config column for GIN on IMDB-BINARY:\n",
-      "model.readout.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.optimizer.lr: [0.001 0.01 ]\n",
-      "\n",
-      "model.feature_encoder.out_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.dropout: [0.5  0.25 0.  ]\n",
-      "\n",
-      "model.backbone.in_channels: [256. 128.  64.]\n",
-      "\n",
-      "model.backbone.num_layers: [4. 3. 2. 1.]\n",
-      "\n",
-      "model.backbone.hidden_channels: [256. 128.  64.]\n",
-      "\n",
-      "dataset.parameters.data_seed: [5. 3. 0.]\n",
-      "\n",
-      "dataset.parameters.batch_size: [256. 128.]\n",
-      "\n",
-      "---------\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Identify unique models in DataFrame\n",
-    "unique_models = df[\"model.backbone._target_\"].unique()\n",
-    "\n",
-    "# Identify unique datasets in DataFrame\n",
-    "unique_datasets = df[\"dataset.parameters.data_name\"].unique()\n",
-    "\n",
-    "\n",
-    "collected_results = defaultdict(dict)\n",
-    "collected_aggregated_results = defaultdict(dict)\n",
-    "collected_non_aggregated_results = defaultdict(dict)\n",
-    "# Got over each dataset and model and find the best result\n",
-    "for dataset in unique_datasets:\n",
-    "    for model in unique_models:\n",
-    "        # Get the subset of the DataFrame for the current dataset and model\n",
-    "        subset = df[\n",
-    "            (df[\"dataset.parameters.data_name\"] == dataset)\n",
-    "            & (df[\"model.backbone._target_\"] == model)\n",
-    "        ]\n",
-    "\n",
-    "        if subset.empty:\n",
-    "            print(\"---------\")\n",
-    "            print(f\"No results for {model} on {dataset}\")\n",
-    "            print(\"---------\")\n",
-    "            continue\n",
-    "        # Suppress all warnings\n",
-    "        warnings.filterwarnings(\"ignore\")\n",
-    "        subset[\"Model\"] = model\n",
-    "        warnings.filterwarnings(\"default\")\n",
-    "\n",
-    "        def get_metric(df):\n",
-    "            metric_ = df[\"callbacks.early_stopping.monitor\"].unique()\n",
-    "            assert len(metric_) == 1, \"There should be only one metric to optimize\"\n",
-    "            metric = metric_[0]\n",
-    "            return metric.split(\"/\")[-1]\n",
-    "\n",
-    "        # Cols to get statistics later\n",
-    "        # TODO: log maximum validation value for optimized metric\n",
-    "        performance_cols = [f\"test/{get_metric(subset)}\"]\n",
-    "\n",
-    "        # Get the unique values for each config column\n",
-    "        unique_colums_values = {}\n",
-    "        for col in config_columns:\n",
-    "            try:\n",
-    "                unique_colums_values[col] = subset[col].unique()\n",
-    "            except:\n",
-    "                print(f\"Attention the columns: {col}, has issues with unique values\")\n",
-    "\n",
-    "        # Keep only those keys that have more than one unique value\n",
-    "        unique_colums_values = {\n",
-    "            k: v for k, v in unique_colums_values.items() if len(v) > 1\n",
-    "        }\n",
-    "\n",
-    "        # Print the unique values for each config column\n",
-    "\n",
-    "        print(f\"Unique values for each config column for {model} on {dataset}:\")\n",
-    "        for col, unique in unique_colums_values.items():\n",
-    "            print(f\"{col}: {unique}\")\n",
-    "            print()\n",
-    "        print(\"---------\")\n",
-    "\n",
-    "        # Check if \"special colums\" are not in unique_colums_values\n",
-    "        # For example dataset.parameters.data_seed should not be in aggregation columns\n",
-    "        # If it is, then we should remove it from the list\n",
-    "        special_columns = [\"dataset.parameters.data_seed\"]\n",
-    "\n",
-    "        for col in special_columns:\n",
-    "            if col in unique_colums_values:\n",
-    "                unique_colums_values.pop(col)\n",
-    "\n",
-    "        # Obtain the aggregation columns\n",
-    "        aggregation_columns = [\"Model\"] + list(unique_colums_values.keys())\n",
-    "\n",
-    "        collected_non_aggregated_results[dataset][model] = {\n",
-    "            \"df\": subset.copy(),\n",
-    "            \"aggregation_columns\": aggregation_columns,\n",
-    "            \"performance_cols\": performance_cols,\n",
-    "        }\n",
-    "\n",
-    "        # Aggregate the subset by the aggregation columns and get the best result for each group\n",
-    "        aggregated = subset.groupby(aggregation_columns).agg(\n",
-    "            {col: [\"mean\", \"std\"] for col in performance_cols}\n",
-    "        )\n",
-    "\n",
-    "        # Go from MultiIndex to Index\n",
-    "        aggregated = aggregated.reset_index()\n",
-    "\n",
-    "        assert (\n",
-    "            len(subset[\"callbacks.early_stopping.mode\"].unique()) == 1\n",
-    "        ), \"There should be only one mode for early stopping\"\n",
-    "        # Identify the mode of the early stopping mode\n",
-    "\n",
-    "        if subset[\"callbacks.early_stopping.mode\"].unique()[0] == \"max\":\n",
-    "            ascending = False\n",
-    "            final_best_ = aggregated.sort_values(\n",
-    "                by=(f\"test/{get_metric(subset)}\", \"mean\"), ascending=ascending\n",
-    "            ).head(1)\n",
-    "            final_best_ = (final_best_ * 100).round(2)\n",
-    "        else:\n",
-    "            ascending = True\n",
-    "            final_best_ = aggregated.sort_values(\n",
-    "                by=(f\"test/{get_metric(subset)}\", \"mean\"), ascending=ascending\n",
-    "            ).head(1)\n",
-    "\n",
-    "        collected_results[dataset][model] = {\n",
-    "            \"mean\": final_best_[(f\"test/{get_metric(subset)}\", \"mean\")].values[0],\n",
-    "            \"std\": final_best_[(f\"test/{get_metric(subset)}\", \"std\")].values[0],\n",
-    "        }\n",
-    "        collected_aggregated_results[dataset][model] = aggregated.sort_values(\n",
-    "            by=(f\"test/{get_metric(subset)}\", \"mean\"), ascending=ascending\n",
-    "        )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/tmp/ipykernel_1237364/3015536791.py:9: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
-      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
-      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
-      "\n",
-      "df[\"col\"][row_indexer] = value\n",
-      "\n",
-      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n",
-      "\n",
-      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
-      "\n",
-      "  a[\"dataset.transforms.graph2simplicial_lifting.feature_lifting\"][\n",
-      "/tmp/ipykernel_1237364/3015536791.py:9: SettingWithCopyWarning: \n",
-      "A value is trying to be set on a copy of a slice from a DataFrame\n",
-      "\n",
-      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
-      "  a[\"dataset.transforms.graph2simplicial_lifting.feature_lifting\"][\n"
-     ]
-    },
-    {
-     "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 tr th {\n",
-       "        text-align: left;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead tr:last-of-type th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th colspan=\"2\" halign=\"left\">test/accuracy</th>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th>mean</th>\n",
-       "      <th>std</th>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>Model</th>\n",
-       "      <th>model.readout.in_channels</th>\n",
-       "      <th>model.readout.pooling_type</th>\n",
-       "      <th>model.backbone.n_layers</th>\n",
-       "      <th>model.feature_encoder.out_channels</th>\n",
-       "      <th>model.backbone_wrapper.out_channels</th>\n",
-       "      <th>model.backbone.channels</th>\n",
-       "      <th>model.backbone.max_rank</th>\n",
-       "      <th>dataset.transforms.graph2simplicial_lifting.signed</th>\n",
-       "      <th>dataset.transforms.graph2simplicial_lifting.feature_lifting</th>\n",
-       "      <th>model.feature_encoder._target_</th>\n",
-       "      <th>model.backbone_wrapper.wrapper_readout</th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th rowspan=\"16\" valign=\"top\">SCCN</th>\n",
-       "      <th rowspan=\"2\" valign=\"top\">32.0</th>\n",
-       "      <th>sum</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>True</th>\n",
-       "      <th>projection</th>\n",
-       "      <th>topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder</th>\n",
-       "      <th>original</th>\n",
-       "      <td>0.207872</td>\n",
-       "      <td>0.018203</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>mean</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>True</th>\n",
-       "      <th>projection</th>\n",
-       "      <th>topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder</th>\n",
-       "      <th>original</th>\n",
-       "      <td>0.211562</td>\n",
-       "      <td>0.016639</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th rowspan=\"4\" valign=\"top\">64.0</th>\n",
-       "      <th>sum</th>\n",
-       "      <th>2.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>True</th>\n",
-       "      <th>projection</th>\n",
-       "      <th>topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder</th>\n",
-       "      <th>original</th>\n",
-       "      <td>0.221402</td>\n",
-       "      <td>0.007380</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th rowspan=\"2\" valign=\"top\">mean</th>\n",
-       "      <th>2.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>True</th>\n",
-       "      <th>projection</th>\n",
-       "      <th>topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder</th>\n",
-       "      <th>original</th>\n",
-       "      <td>0.222632</td>\n",
-       "      <td>0.007681</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>True</th>\n",
-       "      <th>projection</th>\n",
-       "      <th>topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder</th>\n",
-       "      <th>original</th>\n",
-       "      <td>0.238622</td>\n",
-       "      <td>0.018936</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>sum</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>True</th>\n",
-       "      <th>projection</th>\n",
-       "      <th>topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder</th>\n",
-       "      <th>original</th>\n",
-       "      <td>0.238622</td>\n",
-       "      <td>0.018936</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th rowspan=\"4\" valign=\"top\">32.0</th>\n",
-       "      <th>sum</th>\n",
-       "      <th>2.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>True</th>\n",
-       "      <th>projection</th>\n",
-       "      <th>topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder</th>\n",
-       "      <th>original</th>\n",
-       "      <td>0.264453</td>\n",
-       "      <td>0.015363</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th rowspan=\"2\" valign=\"top\">mean</th>\n",
-       "      <th>2.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>True</th>\n",
-       "      <th>projection</th>\n",
-       "      <th>topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder</th>\n",
-       "      <th>original</th>\n",
-       "      <td>0.266913</td>\n",
-       "      <td>0.020323</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>False</th>\n",
-       "      <th>projection</th>\n",
-       "      <th>topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder</th>\n",
-       "      <th>original</th>\n",
-       "      <td>0.870849</td>\n",
-       "      <td>0.031311</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>sum</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>False</th>\n",
-       "      <th>projection</th>\n",
-       "      <th>topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder</th>\n",
-       "      <th>original</th>\n",
-       "      <td>0.872079</td>\n",
-       "      <td>0.020323</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th rowspan=\"2\" valign=\"top\">64.0</th>\n",
-       "      <th>mean</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>False</th>\n",
-       "      <th>projection</th>\n",
-       "      <th>topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder</th>\n",
-       "      <th>original</th>\n",
-       "      <td>0.889299</td>\n",
-       "      <td>0.009763</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>sum</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>False</th>\n",
-       "      <th>projection</th>\n",
-       "      <th>topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder</th>\n",
-       "      <th>original</th>\n",
-       "      <td>0.890529</td>\n",
-       "      <td>0.008522</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>32.0</th>\n",
-       "      <th>mean</th>\n",
-       "      <th>2.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>False</th>\n",
-       "      <th>projection</th>\n",
-       "      <th>topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder</th>\n",
-       "      <th>original</th>\n",
-       "      <td>0.890529</td>\n",
-       "      <td>0.012959</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th rowspan=\"2\" valign=\"top\">64.0</th>\n",
-       "      <th>sum</th>\n",
-       "      <th>2.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>False</th>\n",
-       "      <th>projection</th>\n",
-       "      <th>topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder</th>\n",
-       "      <th>original</th>\n",
-       "      <td>0.891759</td>\n",
-       "      <td>0.020982</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>mean</th>\n",
-       "      <th>2.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>64.0</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>False</th>\n",
-       "      <th>projection</th>\n",
-       "      <th>topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder</th>\n",
-       "      <th>original</th>\n",
-       "      <td>0.891759</td>\n",
-       "      <td>0.018573</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>32.0</th>\n",
-       "      <th>sum</th>\n",
-       "      <th>2.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>32.0</th>\n",
-       "      <th>1.0</th>\n",
-       "      <th>False</th>\n",
-       "      <th>projection</th>\n",
-       "      <th>topobenchmarkx.models.encoders.default_encoders.BaseFeatureEncoder</th>\n",
-       "      <th>original</th>\n",
-       "      <td>0.891759</td>\n",
-       "      <td>0.011273</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "                                                                                                                                                                                                                                                                                                                                                                                                          test/accuracy  \\\n",
-       "                                                                                                                                                                                                                                                                                                                                                                                                                   mean   \n",
-       "Model model.readout.in_channels model.readout.pooling_type model.backbone.n_layers model.feature_encoder.out_channels model.backbone_wrapper.out_channels model.backbone.channels model.backbone.max_rank dataset.transforms.graph2simplicial_lifting.signed dataset.transforms.graph2simplicial_lifting.fea... model.feature_encoder._target_                     model.backbone_wrapper.wrapper_readout                 \n",
-       "SCCN  32.0                      sum                        1.0                     32.0                               32.0                                32.0                    1.0                     True                                               projection                                         topobenchmarkx.models.encoders.default_encoders... original                                    0.207872   \n",
-       "                                mean                       1.0                     32.0                               32.0                                32.0                    1.0                     True                                               projection                                         topobenchmarkx.models.encoders.default_encoders... original                                    0.211562   \n",
-       "      64.0                      sum                        2.0                     64.0                               64.0                                64.0                    1.0                     True                                               projection                                         topobenchmarkx.models.encoders.default_encoders... original                                    0.221402   \n",
-       "                                mean                       2.0                     64.0                               64.0                                64.0                    1.0                     True                                               projection                                         topobenchmarkx.models.encoders.default_encoders... original                                    0.222632   \n",
-       "                                                           1.0                     64.0                               64.0                                64.0                    1.0                     True                                               projection                                         topobenchmarkx.models.encoders.default_encoders... original                                    0.238622   \n",
-       "                                sum                        1.0                     64.0                               64.0                                64.0                    1.0                     True                                               projection                                         topobenchmarkx.models.encoders.default_encoders... original                                    0.238622   \n",
-       "      32.0                      sum                        2.0                     32.0                               32.0                                32.0                    1.0                     True                                               projection                                         topobenchmarkx.models.encoders.default_encoders... original                                    0.264453   \n",
-       "                                mean                       2.0                     32.0                               32.0                                32.0                    1.0                     True                                               projection                                         topobenchmarkx.models.encoders.default_encoders... original                                    0.266913   \n",
-       "                                                           1.0                     32.0                               32.0                                32.0                    1.0                     False                                              projection                                         topobenchmarkx.models.encoders.default_encoders... original                                    0.870849   \n",
-       "                                sum                        1.0                     32.0                               32.0                                32.0                    1.0                     False                                              projection                                         topobenchmarkx.models.encoders.default_encoders... original                                    0.872079   \n",
-       "      64.0                      mean                       1.0                     64.0                               64.0                                64.0                    1.0                     False                                              projection                                         topobenchmarkx.models.encoders.default_encoders... original                                    0.889299   \n",
-       "                                sum                        1.0                     64.0                               64.0                                64.0                    1.0                     False                                              projection                                         topobenchmarkx.models.encoders.default_encoders... original                                    0.890529   \n",
-       "      32.0                      mean                       2.0                     32.0                               32.0                                32.0                    1.0                     False                                              projection                                         topobenchmarkx.models.encoders.default_encoders... original                                    0.890529   \n",
-       "      64.0                      sum                        2.0                     64.0                               64.0                                64.0                    1.0                     False                                              projection                                         topobenchmarkx.models.encoders.default_encoders... original                                    0.891759   \n",
-       "                                mean                       2.0                     64.0                               64.0                                64.0                    1.0                     False                                              projection                                         topobenchmarkx.models.encoders.default_encoders... original                                    0.891759   \n",
-       "      32.0                      sum                        2.0                     32.0                               32.0                                32.0                    1.0                     False                                              projection                                         topobenchmarkx.models.encoders.default_encoders... original                                    0.891759   \n",
-       "\n",
-       "                                                                                                                                                                                                                                                                                                                                                                                                                     \n",
-       "                                                                                                                                                                                                                                                                                                                                                                                                                std  \n",
-       "Model model.readout.in_channels model.readout.pooling_type model.backbone.n_layers model.feature_encoder.out_channels model.backbone_wrapper.out_channels model.backbone.channels model.backbone.max_rank dataset.transforms.graph2simplicial_lifting.signed dataset.transforms.graph2simplicial_lifting.fea... model.feature_encoder._target_                     model.backbone_wrapper.wrapper_readout            \n",
-       "SCCN  32.0                      sum                        1.0                     32.0                               32.0                                32.0                    1.0                     True                                               projection                                         topobenchmarkx.models.encoders.default_encoders... original                                0.018203  \n",
-       "                                mean                       1.0                     32.0                               32.0                                32.0                    1.0                     True                                               projection                                         topobenchmarkx.models.encoders.default_encoders... original                                0.016639  \n",
-       "      64.0                      sum                        2.0                     64.0                               64.0                                64.0                    1.0                     True                                               projection                                         topobenchmarkx.models.encoders.default_encoders... original                                0.007380  \n",
-       "                                mean                       2.0                     64.0                               64.0                                64.0                    1.0                     True                                               projection                                         topobenchmarkx.models.encoders.default_encoders... original                                0.007681  \n",
-       "                                                           1.0                     64.0                               64.0                                64.0                    1.0                     True                                               projection                                         topobenchmarkx.models.encoders.default_encoders... original                                0.018936  \n",
-       "                                sum                        1.0                     64.0                               64.0                                64.0                    1.0                     True                                               projection                                         topobenchmarkx.models.encoders.default_encoders... original                                0.018936  \n",
-       "      32.0                      sum                        2.0                     32.0                               32.0                                32.0                    1.0                     True                                               projection                                         topobenchmarkx.models.encoders.default_encoders... original                                0.015363  \n",
-       "                                mean                       2.0                     32.0                               32.0                                32.0                    1.0                     True                                               projection                                         topobenchmarkx.models.encoders.default_encoders... original                                0.020323  \n",
-       "                                                           1.0                     32.0                               32.0                                32.0                    1.0                     False                                              projection                                         topobenchmarkx.models.encoders.default_encoders... original                                0.031311  \n",
-       "                                sum                        1.0                     32.0                               32.0                                32.0                    1.0                     False                                              projection                                         topobenchmarkx.models.encoders.default_encoders... original                                0.020323  \n",
-       "      64.0                      mean                       1.0                     64.0                               64.0                                64.0                    1.0                     False                                              projection                                         topobenchmarkx.models.encoders.default_encoders... original                                0.009763  \n",
-       "                                sum                        1.0                     64.0                               64.0                                64.0                    1.0                     False                                              projection                                         topobenchmarkx.models.encoders.default_encoders... original                                0.008522  \n",
-       "      32.0                      mean                       2.0                     32.0                               32.0                                32.0                    1.0                     False                                              projection                                         topobenchmarkx.models.encoders.default_encoders... original                                0.012959  \n",
-       "      64.0                      sum                        2.0                     64.0                               64.0                                64.0                    1.0                     False                                              projection                                         topobenchmarkx.models.encoders.default_encoders... original                                0.020982  \n",
-       "                                mean                       2.0                     64.0                               64.0                                64.0                    1.0                     False                                              projection                                         topobenchmarkx.models.encoders.default_encoders... original                                0.018573  \n",
-       "      32.0                      sum                        2.0                     32.0                               32.0                                32.0                    1.0                     False                                              projection                                         topobenchmarkx.models.encoders.default_encoders... original                                0.011273  "
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# collected_aggregated_results['ZINC']['SCCN']\n",
-    "a = collected_non_aggregated_results[\"Cora\"][\"SCCN\"][\"df\"]\n",
-    "aggregation_columns = collected_non_aggregated_results[\"Cora\"][\"SCCN\"][\n",
-    "    \"aggregation_columns\"\n",
-    "]\n",
-    "performance_cols = collected_non_aggregated_results[\"Cora\"][\"SCCN\"][\"performance_cols\"]\n",
-    "\n",
-    "# a = a[(a['dataset.transforms.graph2simplicial_lifting.feature_lifting'] =='set') | (a['dataset.transforms.graph2simplicial_lifting.feature_lifting'] =='concatenation')]\n",
-    "a[\"dataset.transforms.graph2simplicial_lifting.feature_lifting\"][\n",
-    "    a[\"dataset.transforms.graph2simplicial_lifting.feature_lifting\"].isna()\n",
-    "] = \"projection\"\n",
-    "# a = a[~a[\"test/mae\"].isna()]\n",
-    "a = a[~a[\"test/accuracy\"].isna()]\n",
-    "\n",
-    "a = a.groupby(\n",
-    "    aggregation_columns\n",
-    "    + [\n",
-    "        \"dataset.transforms.graph2simplicial_lifting.feature_lifting\",\n",
-    "        \"model.feature_encoder._target_\",\n",
-    "        \"model.backbone_wrapper.wrapper_readout\",\n",
-    "    ]\n",
-    ").agg({col: [\"mean\", \"std\"] for col in performance_cols})\n",
-    "\n",
-    "ascending = True\n",
-    "# a = a.sort_values(by=(\"test/mae\", \"mean\"), ascending=ascending)\n",
-    "a = a.sort_values(by=(\"test/accuracy\", \"mean\"), ascending=ascending)\n",
-    "# Show all rows\n",
-    "pd.set_option(\"display.max_rows\", None)\n",
-    "\n",
-    "a"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "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>_step</th>\n",
-       "      <th>lr-Adam</th>\n",
-       "      <th>_runtime</th>\n",
-       "      <th>val/loss</th>\n",
-       "      <th>train/loss</th>\n",
-       "      <th>val/accuracy</th>\n",
-       "      <th>train/accuracy</th>\n",
-       "      <th>epoch</th>\n",
-       "      <th>_timestamp</th>\n",
-       "      <th>trainer/global_step</th>\n",
-       "      <th>...</th>\n",
-       "      <th>callbacks.model_checkpoint.every_n_epochs</th>\n",
-       "      <th>callbacks.model_checkpoint.save_weights_only</th>\n",
-       "      <th>callbacks.model_checkpoint.every_n_train_steps</th>\n",
-       "      <th>callbacks.model_checkpoint.train_time_interval</th>\n",
-       "      <th>callbacks.model_checkpoint.auto_insert_metric_name</th>\n",
-       "      <th>callbacks.model_checkpoint.save_on_train_epoch_end</th>\n",
-       "      <th>callbacks.rich_progress_bar._target_</th>\n",
-       "      <th>callbacks.learning_rate_monitor._target_</th>\n",
-       "      <th>callbacks.learning_rate_monitor.logging_interval</th>\n",
-       "      <th>Model</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>2501</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2502</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2503</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2504</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2505</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2506</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2508</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2509</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2510</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2511</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2512</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2513</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2514</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2515</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2516</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2517</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2518</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2519</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2520</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2521</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2522</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2523</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2524</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2525</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2526</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2527</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2528</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2529</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2530</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2531</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2532</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2533</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2534</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2535</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2536</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2537</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2538</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2539</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2540</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2541</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2542</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2543</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2544</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2545</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2546</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2547</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2548</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2549</th>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2550</th>\n",
-       "      <td>154.0</td>\n",
-       "      <td>0.008029</td>\n",
-       "      <td>7.608606</td>\n",
-       "      <td>0.540317</td>\n",
-       "      <td>0.023364</td>\n",
-       "      <td>0.896679</td>\n",
-       "      <td>0.995897</td>\n",
-       "      <td>70.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>70.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2551</th>\n",
-       "      <td>121.0</td>\n",
-       "      <td>0.008457</td>\n",
-       "      <td>5.678141</td>\n",
-       "      <td>6.526974</td>\n",
-       "      <td>0.429147</td>\n",
-       "      <td>0.114391</td>\n",
-       "      <td>0.909725</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2552</th>\n",
-       "      <td>154.0</td>\n",
-       "      <td>0.008029</td>\n",
-       "      <td>6.367233</td>\n",
-       "      <td>0.536447</td>\n",
-       "      <td>0.024491</td>\n",
-       "      <td>0.892989</td>\n",
-       "      <td>0.995076</td>\n",
-       "      <td>70.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>70.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2553</th>\n",
-       "      <td>121.0</td>\n",
-       "      <td>0.008457</td>\n",
-       "      <td>5.730413</td>\n",
-       "      <td>6.754055</td>\n",
-       "      <td>0.420306</td>\n",
-       "      <td>0.084871</td>\n",
-       "      <td>0.906032</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2554</th>\n",
-       "      <td>154.0</td>\n",
-       "      <td>0.008029</td>\n",
-       "      <td>6.440230</td>\n",
-       "      <td>0.872223</td>\n",
-       "      <td>0.028146</td>\n",
-       "      <td>0.837638</td>\n",
-       "      <td>0.995076</td>\n",
-       "      <td>70.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>70.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2555</th>\n",
-       "      <td>132.0</td>\n",
-       "      <td>0.008314</td>\n",
-       "      <td>5.864329</td>\n",
-       "      <td>6.491078</td>\n",
-       "      <td>0.409160</td>\n",
-       "      <td>0.147601</td>\n",
-       "      <td>0.906853</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2556</th>\n",
-       "      <td>154.0</td>\n",
-       "      <td>0.008029</td>\n",
-       "      <td>6.558354</td>\n",
-       "      <td>0.870394</td>\n",
-       "      <td>0.026946</td>\n",
-       "      <td>0.841328</td>\n",
-       "      <td>0.995486</td>\n",
-       "      <td>70.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>70.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2557</th>\n",
-       "      <td>132.0</td>\n",
-       "      <td>0.008314</td>\n",
-       "      <td>5.960813</td>\n",
-       "      <td>6.392102</td>\n",
-       "      <td>0.407368</td>\n",
-       "      <td>0.143911</td>\n",
-       "      <td>0.911777</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2558</th>\n",
-       "      <td>165.0</td>\n",
-       "      <td>0.007886</td>\n",
-       "      <td>6.843802</td>\n",
-       "      <td>0.804343</td>\n",
-       "      <td>0.021995</td>\n",
-       "      <td>0.870849</td>\n",
-       "      <td>0.996307</td>\n",
-       "      <td>75.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>75.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2559</th>\n",
-       "      <td>121.0</td>\n",
-       "      <td>0.008457</td>\n",
-       "      <td>6.564709</td>\n",
-       "      <td>5.851659</td>\n",
-       "      <td>0.427017</td>\n",
-       "      <td>0.177122</td>\n",
-       "      <td>0.910956</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2560</th>\n",
-       "      <td>165.0</td>\n",
-       "      <td>0.007886</td>\n",
-       "      <td>7.030522</td>\n",
-       "      <td>0.786347</td>\n",
-       "      <td>0.020831</td>\n",
-       "      <td>0.867159</td>\n",
-       "      <td>0.996717</td>\n",
-       "      <td>75.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>75.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2561</th>\n",
-       "      <td>143.0</td>\n",
-       "      <td>0.008171</td>\n",
-       "      <td>6.064869</td>\n",
-       "      <td>6.021095</td>\n",
-       "      <td>0.382104</td>\n",
-       "      <td>0.184502</td>\n",
-       "      <td>0.920394</td>\n",
-       "      <td>65.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>65.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2562</th>\n",
-       "      <td>132.0</td>\n",
-       "      <td>0.008314</td>\n",
-       "      <td>5.776957</td>\n",
-       "      <td>0.602078</td>\n",
-       "      <td>0.007965</td>\n",
-       "      <td>0.889299</td>\n",
-       "      <td>0.998359</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2563</th>\n",
-       "      <td>121.0</td>\n",
-       "      <td>0.008457</td>\n",
-       "      <td>5.438082</td>\n",
-       "      <td>6.400484</td>\n",
-       "      <td>0.237617</td>\n",
-       "      <td>0.143911</td>\n",
-       "      <td>0.951990</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2564</th>\n",
-       "      <td>132.0</td>\n",
-       "      <td>0.008314</td>\n",
-       "      <td>10.791918</td>\n",
-       "      <td>0.611318</td>\n",
-       "      <td>0.007137</td>\n",
-       "      <td>0.881919</td>\n",
-       "      <td>0.998359</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2565</th>\n",
-       "      <td>121.0</td>\n",
-       "      <td>0.008457</td>\n",
-       "      <td>5.441335</td>\n",
-       "      <td>6.447779</td>\n",
-       "      <td>0.235947</td>\n",
-       "      <td>0.143911</td>\n",
-       "      <td>0.952401</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2567</th>\n",
-       "      <td>132.0</td>\n",
-       "      <td>0.008314</td>\n",
-       "      <td>5.746273</td>\n",
-       "      <td>0.904160</td>\n",
-       "      <td>0.004386</td>\n",
-       "      <td>0.841328</td>\n",
-       "      <td>0.998769</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2568</th>\n",
-       "      <td>121.0</td>\n",
-       "      <td>0.008457</td>\n",
-       "      <td>5.480576</td>\n",
-       "      <td>6.215590</td>\n",
-       "      <td>0.239272</td>\n",
-       "      <td>0.184502</td>\n",
-       "      <td>0.951580</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2569</th>\n",
-       "      <td>132.0</td>\n",
-       "      <td>0.008314</td>\n",
-       "      <td>5.776445</td>\n",
-       "      <td>0.878947</td>\n",
-       "      <td>0.004788</td>\n",
-       "      <td>0.845018</td>\n",
-       "      <td>0.998359</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2570</th>\n",
-       "      <td>121.0</td>\n",
-       "      <td>0.008457</td>\n",
-       "      <td>6.400216</td>\n",
-       "      <td>6.118556</td>\n",
-       "      <td>0.240687</td>\n",
-       "      <td>0.188192</td>\n",
-       "      <td>0.950349</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2571</th>\n",
-       "      <td>132.0</td>\n",
-       "      <td>0.008314</td>\n",
-       "      <td>6.768067</td>\n",
-       "      <td>0.826713</td>\n",
-       "      <td>0.005357</td>\n",
-       "      <td>0.848709</td>\n",
-       "      <td>0.998359</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2572</th>\n",
-       "      <td>132.0</td>\n",
-       "      <td>0.008314</td>\n",
-       "      <td>5.724424</td>\n",
-       "      <td>5.652013</td>\n",
-       "      <td>0.243514</td>\n",
-       "      <td>0.217712</td>\n",
-       "      <td>0.951990</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2573</th>\n",
-       "      <td>132.0</td>\n",
-       "      <td>0.008314</td>\n",
-       "      <td>5.736698</td>\n",
-       "      <td>0.822887</td>\n",
-       "      <td>0.006914</td>\n",
-       "      <td>0.852399</td>\n",
-       "      <td>0.998359</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2574</th>\n",
-       "      <td>132.0</td>\n",
-       "      <td>0.008314</td>\n",
-       "      <td>5.638951</td>\n",
-       "      <td>5.751070</td>\n",
-       "      <td>0.241462</td>\n",
-       "      <td>0.206642</td>\n",
-       "      <td>0.951990</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>60.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2575</th>\n",
-       "      <td>165.0</td>\n",
-       "      <td>0.007886</td>\n",
-       "      <td>6.754391</td>\n",
-       "      <td>0.502912</td>\n",
-       "      <td>0.037106</td>\n",
-       "      <td>0.900369</td>\n",
-       "      <td>0.993435</td>\n",
-       "      <td>75.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>75.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2576</th>\n",
-       "      <td>121.0</td>\n",
-       "      <td>0.008457</td>\n",
-       "      <td>5.577818</td>\n",
-       "      <td>5.864879</td>\n",
-       "      <td>0.557414</td>\n",
-       "      <td>0.121771</td>\n",
-       "      <td>0.876487</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2577</th>\n",
-       "      <td>165.0</td>\n",
-       "      <td>0.007886</td>\n",
-       "      <td>6.914924</td>\n",
-       "      <td>0.490508</td>\n",
-       "      <td>0.035976</td>\n",
-       "      <td>0.900369</td>\n",
-       "      <td>0.993845</td>\n",
-       "      <td>75.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>75.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2578</th>\n",
-       "      <td>121.0</td>\n",
-       "      <td>0.008457</td>\n",
-       "      <td>5.549250</td>\n",
-       "      <td>5.956728</td>\n",
-       "      <td>0.550597</td>\n",
-       "      <td>0.129151</td>\n",
-       "      <td>0.876898</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2579</th>\n",
-       "      <td>143.0</td>\n",
-       "      <td>0.008171</td>\n",
-       "      <td>7.461420</td>\n",
-       "      <td>0.670681</td>\n",
-       "      <td>0.049441</td>\n",
-       "      <td>0.852399</td>\n",
-       "      <td>0.991383</td>\n",
-       "      <td>65.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>65.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2580</th>\n",
-       "      <td>121.0</td>\n",
-       "      <td>0.008457</td>\n",
-       "      <td>6.728678</td>\n",
-       "      <td>5.996273</td>\n",
-       "      <td>0.554403</td>\n",
-       "      <td>0.154982</td>\n",
-       "      <td>0.876898</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2581</th>\n",
-       "      <td>143.0</td>\n",
-       "      <td>0.008171</td>\n",
-       "      <td>6.120946</td>\n",
-       "      <td>0.678197</td>\n",
-       "      <td>0.047631</td>\n",
-       "      <td>0.856089</td>\n",
-       "      <td>0.991793</td>\n",
-       "      <td>65.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>65.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2582</th>\n",
-       "      <td>121.0</td>\n",
-       "      <td>0.008457</td>\n",
-       "      <td>5.564567</td>\n",
-       "      <td>6.107959</td>\n",
-       "      <td>0.560592</td>\n",
-       "      <td>0.129151</td>\n",
-       "      <td>0.877719</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2583</th>\n",
-       "      <td>143.0</td>\n",
-       "      <td>0.008171</td>\n",
-       "      <td>6.248095</td>\n",
-       "      <td>0.721080</td>\n",
-       "      <td>0.052217</td>\n",
-       "      <td>0.859779</td>\n",
-       "      <td>0.992204</td>\n",
-       "      <td>65.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>65.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2584</th>\n",
-       "      <td>121.0</td>\n",
-       "      <td>0.008457</td>\n",
-       "      <td>5.623619</td>\n",
-       "      <td>5.650265</td>\n",
-       "      <td>0.562599</td>\n",
-       "      <td>0.151292</td>\n",
-       "      <td>0.878950</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2586</th>\n",
-       "      <td>187.0</td>\n",
-       "      <td>0.007600</td>\n",
-       "      <td>7.103708</td>\n",
-       "      <td>0.716716</td>\n",
-       "      <td>0.040608</td>\n",
-       "      <td>0.863469</td>\n",
-       "      <td>0.992614</td>\n",
-       "      <td>85.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>85.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2587</th>\n",
-       "      <td>121.0</td>\n",
-       "      <td>0.008457</td>\n",
-       "      <td>5.532818</td>\n",
-       "      <td>5.422974</td>\n",
-       "      <td>0.571389</td>\n",
-       "      <td>0.158672</td>\n",
-       "      <td>0.876077</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2588</th>\n",
-       "      <td>154.0</td>\n",
-       "      <td>0.008029</td>\n",
-       "      <td>6.058695</td>\n",
-       "      <td>0.535041</td>\n",
-       "      <td>0.019448</td>\n",
-       "      <td>0.867159</td>\n",
-       "      <td>0.997948</td>\n",
-       "      <td>70.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>70.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2589</th>\n",
-       "      <td>121.0</td>\n",
-       "      <td>0.008457</td>\n",
-       "      <td>6.555320</td>\n",
-       "      <td>5.318046</td>\n",
-       "      <td>0.337789</td>\n",
-       "      <td>0.151292</td>\n",
-       "      <td>0.914649</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2590</th>\n",
-       "      <td>154.0</td>\n",
-       "      <td>0.008029</td>\n",
-       "      <td>7.625160</td>\n",
-       "      <td>0.529025</td>\n",
-       "      <td>0.020766</td>\n",
-       "      <td>0.874539</td>\n",
-       "      <td>0.997128</td>\n",
-       "      <td>70.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>70.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2591</th>\n",
-       "      <td>121.0</td>\n",
-       "      <td>0.008457</td>\n",
-       "      <td>5.362995</td>\n",
-       "      <td>5.370859</td>\n",
-       "      <td>0.340166</td>\n",
-       "      <td>0.136531</td>\n",
-       "      <td>0.917932</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2592</th>\n",
-       "      <td>143.0</td>\n",
-       "      <td>0.008171</td>\n",
-       "      <td>6.121146</td>\n",
-       "      <td>0.781860</td>\n",
-       "      <td>0.019583</td>\n",
-       "      <td>0.830258</td>\n",
-       "      <td>0.996717</td>\n",
-       "      <td>65.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>65.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2593</th>\n",
-       "      <td>198.0</td>\n",
-       "      <td>0.007457</td>\n",
-       "      <td>8.846750</td>\n",
-       "      <td>5.228642</td>\n",
-       "      <td>0.289181</td>\n",
-       "      <td>0.188192</td>\n",
-       "      <td>0.932704</td>\n",
-       "      <td>90.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>90.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2594</th>\n",
-       "      <td>187.0</td>\n",
-       "      <td>0.007600</td>\n",
-       "      <td>8.505518</td>\n",
-       "      <td>0.816010</td>\n",
-       "      <td>0.015894</td>\n",
-       "      <td>0.826568</td>\n",
-       "      <td>0.996307</td>\n",
-       "      <td>85.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>85.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2595</th>\n",
-       "      <td>143.0</td>\n",
-       "      <td>0.008171</td>\n",
-       "      <td>7.227815</td>\n",
-       "      <td>5.082430</td>\n",
-       "      <td>0.326597</td>\n",
-       "      <td>0.184502</td>\n",
-       "      <td>0.925728</td>\n",
-       "      <td>65.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>65.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2596</th>\n",
-       "      <td>73.0</td>\n",
-       "      <td>0.009057</td>\n",
-       "      <td>5.421983</td>\n",
-       "      <td>0.522891</td>\n",
-       "      <td>0.067826</td>\n",
-       "      <td>0.856089</td>\n",
-       "      <td>0.992204</td>\n",
-       "      <td>33.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>33.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2597</th>\n",
-       "      <td>121.0</td>\n",
-       "      <td>0.008457</td>\n",
-       "      <td>6.256240</td>\n",
-       "      <td>4.836885</td>\n",
-       "      <td>0.348682</td>\n",
-       "      <td>0.202952</td>\n",
-       "      <td>0.923266</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2598</th>\n",
-       "      <td>154.0</td>\n",
-       "      <td>0.008029</td>\n",
-       "      <td>7.143852</td>\n",
-       "      <td>0.675752</td>\n",
-       "      <td>0.021100</td>\n",
-       "      <td>0.852399</td>\n",
-       "      <td>0.997128</td>\n",
-       "      <td>70.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>70.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2599</th>\n",
-       "      <td>121.0</td>\n",
-       "      <td>0.008457</td>\n",
-       "      <td>6.671425</td>\n",
-       "      <td>4.815981</td>\n",
-       "      <td>0.344246</td>\n",
-       "      <td>0.199262</td>\n",
-       "      <td>0.920394</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>1.711031e+09</td>\n",
-       "      <td>55.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>False</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>lightning.pytorch.callbacks.RichProgressBar</td>\n",
-       "      <td>lightning.pytorch.callbacks.LearningRateMonitor</td>\n",
-       "      <td>epoch</td>\n",
-       "      <td>SCCN</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "<p>96 rows × 179 columns</p>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "      _step   lr-Adam   _runtime  val/loss  train/loss  val/accuracy  \\\n",
-       "2501    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2502    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2503    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2504    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2505    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2506    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2508    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2509    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2510    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2511    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2512    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2513    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2514    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2515    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2516    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2517    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2518    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2519    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2520    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2521    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2522    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2523    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2524    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2525    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2526    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2527    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2528    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2529    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2530    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2531    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2532    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2533    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2534    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2535    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2536    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2537    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2538    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2539    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2540    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2541    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2542    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2543    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2544    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2545    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2546    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2547    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2548    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2549    NaN       NaN        NaN       NaN         NaN           NaN   \n",
-       "2550  154.0  0.008029   7.608606  0.540317    0.023364      0.896679   \n",
-       "2551  121.0  0.008457   5.678141  6.526974    0.429147      0.114391   \n",
-       "2552  154.0  0.008029   6.367233  0.536447    0.024491      0.892989   \n",
-       "2553  121.0  0.008457   5.730413  6.754055    0.420306      0.084871   \n",
-       "2554  154.0  0.008029   6.440230  0.872223    0.028146      0.837638   \n",
-       "2555  132.0  0.008314   5.864329  6.491078    0.409160      0.147601   \n",
-       "2556  154.0  0.008029   6.558354  0.870394    0.026946      0.841328   \n",
-       "2557  132.0  0.008314   5.960813  6.392102    0.407368      0.143911   \n",
-       "2558  165.0  0.007886   6.843802  0.804343    0.021995      0.870849   \n",
-       "2559  121.0  0.008457   6.564709  5.851659    0.427017      0.177122   \n",
-       "2560  165.0  0.007886   7.030522  0.786347    0.020831      0.867159   \n",
-       "2561  143.0  0.008171   6.064869  6.021095    0.382104      0.184502   \n",
-       "2562  132.0  0.008314   5.776957  0.602078    0.007965      0.889299   \n",
-       "2563  121.0  0.008457   5.438082  6.400484    0.237617      0.143911   \n",
-       "2564  132.0  0.008314  10.791918  0.611318    0.007137      0.881919   \n",
-       "2565  121.0  0.008457   5.441335  6.447779    0.235947      0.143911   \n",
-       "2567  132.0  0.008314   5.746273  0.904160    0.004386      0.841328   \n",
-       "2568  121.0  0.008457   5.480576  6.215590    0.239272      0.184502   \n",
-       "2569  132.0  0.008314   5.776445  0.878947    0.004788      0.845018   \n",
-       "2570  121.0  0.008457   6.400216  6.118556    0.240687      0.188192   \n",
-       "2571  132.0  0.008314   6.768067  0.826713    0.005357      0.848709   \n",
-       "2572  132.0  0.008314   5.724424  5.652013    0.243514      0.217712   \n",
-       "2573  132.0  0.008314   5.736698  0.822887    0.006914      0.852399   \n",
-       "2574  132.0  0.008314   5.638951  5.751070    0.241462      0.206642   \n",
-       "2575  165.0  0.007886   6.754391  0.502912    0.037106      0.900369   \n",
-       "2576  121.0  0.008457   5.577818  5.864879    0.557414      0.121771   \n",
-       "2577  165.0  0.007886   6.914924  0.490508    0.035976      0.900369   \n",
-       "2578  121.0  0.008457   5.549250  5.956728    0.550597      0.129151   \n",
-       "2579  143.0  0.008171   7.461420  0.670681    0.049441      0.852399   \n",
-       "2580  121.0  0.008457   6.728678  5.996273    0.554403      0.154982   \n",
-       "2581  143.0  0.008171   6.120946  0.678197    0.047631      0.856089   \n",
-       "2582  121.0  0.008457   5.564567  6.107959    0.560592      0.129151   \n",
-       "2583  143.0  0.008171   6.248095  0.721080    0.052217      0.859779   \n",
-       "2584  121.0  0.008457   5.623619  5.650265    0.562599      0.151292   \n",
-       "2586  187.0  0.007600   7.103708  0.716716    0.040608      0.863469   \n",
-       "2587  121.0  0.008457   5.532818  5.422974    0.571389      0.158672   \n",
-       "2588  154.0  0.008029   6.058695  0.535041    0.019448      0.867159   \n",
-       "2589  121.0  0.008457   6.555320  5.318046    0.337789      0.151292   \n",
-       "2590  154.0  0.008029   7.625160  0.529025    0.020766      0.874539   \n",
-       "2591  121.0  0.008457   5.362995  5.370859    0.340166      0.136531   \n",
-       "2592  143.0  0.008171   6.121146  0.781860    0.019583      0.830258   \n",
-       "2593  198.0  0.007457   8.846750  5.228642    0.289181      0.188192   \n",
-       "2594  187.0  0.007600   8.505518  0.816010    0.015894      0.826568   \n",
-       "2595  143.0  0.008171   7.227815  5.082430    0.326597      0.184502   \n",
-       "2596   73.0  0.009057   5.421983  0.522891    0.067826      0.856089   \n",
-       "2597  121.0  0.008457   6.256240  4.836885    0.348682      0.202952   \n",
-       "2598  154.0  0.008029   7.143852  0.675752    0.021100      0.852399   \n",
-       "2599  121.0  0.008457   6.671425  4.815981    0.344246      0.199262   \n",
-       "\n",
-       "      train/accuracy  epoch    _timestamp  trainer/global_step  ...  \\\n",
-       "2501             NaN    NaN           NaN                  NaN  ...   \n",
-       "2502             NaN    NaN           NaN                  NaN  ...   \n",
-       "2503             NaN    NaN           NaN                  NaN  ...   \n",
-       "2504             NaN    NaN           NaN                  NaN  ...   \n",
-       "2505             NaN    NaN           NaN                  NaN  ...   \n",
-       "2506             NaN    NaN           NaN                  NaN  ...   \n",
-       "2508             NaN    NaN           NaN                  NaN  ...   \n",
-       "2509             NaN    NaN           NaN                  NaN  ...   \n",
-       "2510             NaN    NaN           NaN                  NaN  ...   \n",
-       "2511             NaN    NaN           NaN                  NaN  ...   \n",
-       "2512             NaN    NaN           NaN                  NaN  ...   \n",
-       "2513             NaN    NaN           NaN                  NaN  ...   \n",
-       "2514             NaN    NaN           NaN                  NaN  ...   \n",
-       "2515             NaN    NaN           NaN                  NaN  ...   \n",
-       "2516             NaN    NaN           NaN                  NaN  ...   \n",
-       "2517             NaN    NaN           NaN                  NaN  ...   \n",
-       "2518             NaN    NaN           NaN                  NaN  ...   \n",
-       "2519             NaN    NaN           NaN                  NaN  ...   \n",
-       "2520             NaN    NaN           NaN                  NaN  ...   \n",
-       "2521             NaN    NaN           NaN                  NaN  ...   \n",
-       "2522             NaN    NaN           NaN                  NaN  ...   \n",
-       "2523             NaN    NaN           NaN                  NaN  ...   \n",
-       "2524             NaN    NaN           NaN                  NaN  ...   \n",
-       "2525             NaN    NaN           NaN                  NaN  ...   \n",
-       "2526             NaN    NaN           NaN                  NaN  ...   \n",
-       "2527             NaN    NaN           NaN                  NaN  ...   \n",
-       "2528             NaN    NaN           NaN                  NaN  ...   \n",
-       "2529             NaN    NaN           NaN                  NaN  ...   \n",
-       "2530             NaN    NaN           NaN                  NaN  ...   \n",
-       "2531             NaN    NaN           NaN                  NaN  ...   \n",
-       "2532             NaN    NaN           NaN                  NaN  ...   \n",
-       "2533             NaN    NaN           NaN                  NaN  ...   \n",
-       "2534             NaN    NaN           NaN                  NaN  ...   \n",
-       "2535             NaN    NaN           NaN                  NaN  ...   \n",
-       "2536             NaN    NaN           NaN                  NaN  ...   \n",
-       "2537             NaN    NaN           NaN                  NaN  ...   \n",
-       "2538             NaN    NaN           NaN                  NaN  ...   \n",
-       "2539             NaN    NaN           NaN                  NaN  ...   \n",
-       "2540             NaN    NaN           NaN                  NaN  ...   \n",
-       "2541             NaN    NaN           NaN                  NaN  ...   \n",
-       "2542             NaN    NaN           NaN                  NaN  ...   \n",
-       "2543             NaN    NaN           NaN                  NaN  ...   \n",
-       "2544             NaN    NaN           NaN                  NaN  ...   \n",
-       "2545             NaN    NaN           NaN                  NaN  ...   \n",
-       "2546             NaN    NaN           NaN                  NaN  ...   \n",
-       "2547             NaN    NaN           NaN                  NaN  ...   \n",
-       "2548             NaN    NaN           NaN                  NaN  ...   \n",
-       "2549             NaN    NaN           NaN                  NaN  ...   \n",
-       "2550        0.995897   70.0  1.711031e+09                 70.0  ...   \n",
-       "2551        0.909725   55.0  1.711031e+09                 55.0  ...   \n",
-       "2552        0.995076   70.0  1.711031e+09                 70.0  ...   \n",
-       "2553        0.906032   55.0  1.711031e+09                 55.0  ...   \n",
-       "2554        0.995076   70.0  1.711031e+09                 70.0  ...   \n",
-       "2555        0.906853   60.0  1.711031e+09                 60.0  ...   \n",
-       "2556        0.995486   70.0  1.711031e+09                 70.0  ...   \n",
-       "2557        0.911777   60.0  1.711031e+09                 60.0  ...   \n",
-       "2558        0.996307   75.0  1.711031e+09                 75.0  ...   \n",
-       "2559        0.910956   55.0  1.711031e+09                 55.0  ...   \n",
-       "2560        0.996717   75.0  1.711031e+09                 75.0  ...   \n",
-       "2561        0.920394   65.0  1.711031e+09                 65.0  ...   \n",
-       "2562        0.998359   60.0  1.711031e+09                 60.0  ...   \n",
-       "2563        0.951990   55.0  1.711031e+09                 55.0  ...   \n",
-       "2564        0.998359   60.0  1.711031e+09                 60.0  ...   \n",
-       "2565        0.952401   55.0  1.711031e+09                 55.0  ...   \n",
-       "2567        0.998769   60.0  1.711031e+09                 60.0  ...   \n",
-       "2568        0.951580   55.0  1.711031e+09                 55.0  ...   \n",
-       "2569        0.998359   60.0  1.711031e+09                 60.0  ...   \n",
-       "2570        0.950349   55.0  1.711031e+09                 55.0  ...   \n",
-       "2571        0.998359   60.0  1.711031e+09                 60.0  ...   \n",
-       "2572        0.951990   60.0  1.711031e+09                 60.0  ...   \n",
-       "2573        0.998359   60.0  1.711031e+09                 60.0  ...   \n",
-       "2574        0.951990   60.0  1.711031e+09                 60.0  ...   \n",
-       "2575        0.993435   75.0  1.711031e+09                 75.0  ...   \n",
-       "2576        0.876487   55.0  1.711031e+09                 55.0  ...   \n",
-       "2577        0.993845   75.0  1.711031e+09                 75.0  ...   \n",
-       "2578        0.876898   55.0  1.711031e+09                 55.0  ...   \n",
-       "2579        0.991383   65.0  1.711031e+09                 65.0  ...   \n",
-       "2580        0.876898   55.0  1.711031e+09                 55.0  ...   \n",
-       "2581        0.991793   65.0  1.711031e+09                 65.0  ...   \n",
-       "2582        0.877719   55.0  1.711031e+09                 55.0  ...   \n",
-       "2583        0.992204   65.0  1.711031e+09                 65.0  ...   \n",
-       "2584        0.878950   55.0  1.711031e+09                 55.0  ...   \n",
-       "2586        0.992614   85.0  1.711031e+09                 85.0  ...   \n",
-       "2587        0.876077   55.0  1.711031e+09                 55.0  ...   \n",
-       "2588        0.997948   70.0  1.711031e+09                 70.0  ...   \n",
-       "2589        0.914649   55.0  1.711031e+09                 55.0  ...   \n",
-       "2590        0.997128   70.0  1.711031e+09                 70.0  ...   \n",
-       "2591        0.917932   55.0  1.711031e+09                 55.0  ...   \n",
-       "2592        0.996717   65.0  1.711031e+09                 65.0  ...   \n",
-       "2593        0.932704   90.0  1.711031e+09                 90.0  ...   \n",
-       "2594        0.996307   85.0  1.711031e+09                 85.0  ...   \n",
-       "2595        0.925728   65.0  1.711031e+09                 65.0  ...   \n",
-       "2596        0.992204   33.0  1.711031e+09                 33.0  ...   \n",
-       "2597        0.923266   55.0  1.711031e+09                 55.0  ...   \n",
-       "2598        0.997128   70.0  1.711031e+09                 70.0  ...   \n",
-       "2599        0.920394   55.0  1.711031e+09                 55.0  ...   \n",
-       "\n",
-       "      callbacks.model_checkpoint.every_n_epochs  \\\n",
-       "2501                                        NaN   \n",
-       "2502                                        NaN   \n",
-       "2503                                        NaN   \n",
-       "2504                                        NaN   \n",
-       "2505                                        NaN   \n",
-       "2506                                        NaN   \n",
-       "2508                                        NaN   \n",
-       "2509                                        NaN   \n",
-       "2510                                        NaN   \n",
-       "2511                                        NaN   \n",
-       "2512                                        NaN   \n",
-       "2513                                        NaN   \n",
-       "2514                                        NaN   \n",
-       "2515                                        NaN   \n",
-       "2516                                        NaN   \n",
-       "2517                                        NaN   \n",
-       "2518                                        NaN   \n",
-       "2519                                        NaN   \n",
-       "2520                                        NaN   \n",
-       "2521                                        NaN   \n",
-       "2522                                        NaN   \n",
-       "2523                                        NaN   \n",
-       "2524                                        NaN   \n",
-       "2525                                        NaN   \n",
-       "2526                                        NaN   \n",
-       "2527                                        NaN   \n",
-       "2528                                        NaN   \n",
-       "2529                                        NaN   \n",
-       "2530                                        NaN   \n",
-       "2531                                        NaN   \n",
-       "2532                                        NaN   \n",
-       "2533                                        NaN   \n",
-       "2534                                        NaN   \n",
-       "2535                                        NaN   \n",
-       "2536                                        NaN   \n",
-       "2537                                        NaN   \n",
-       "2538                                        NaN   \n",
-       "2539                                        NaN   \n",
-       "2540                                        NaN   \n",
-       "2541                                        NaN   \n",
-       "2542                                        NaN   \n",
-       "2543                                        NaN   \n",
-       "2544                                        NaN   \n",
-       "2545                                        NaN   \n",
-       "2546                                        NaN   \n",
-       "2547                                        NaN   \n",
-       "2548                                        NaN   \n",
-       "2549                                        NaN   \n",
-       "2550                                        NaN   \n",
-       "2551                                        NaN   \n",
-       "2552                                        NaN   \n",
-       "2553                                        NaN   \n",
-       "2554                                        NaN   \n",
-       "2555                                        NaN   \n",
-       "2556                                        NaN   \n",
-       "2557                                        NaN   \n",
-       "2558                                        NaN   \n",
-       "2559                                        NaN   \n",
-       "2560                                        NaN   \n",
-       "2561                                        NaN   \n",
-       "2562                                        NaN   \n",
-       "2563                                        NaN   \n",
-       "2564                                        NaN   \n",
-       "2565                                        NaN   \n",
-       "2567                                        NaN   \n",
-       "2568                                        NaN   \n",
-       "2569                                        NaN   \n",
-       "2570                                        NaN   \n",
-       "2571                                        NaN   \n",
-       "2572                                        NaN   \n",
-       "2573                                        NaN   \n",
-       "2574                                        NaN   \n",
-       "2575                                        NaN   \n",
-       "2576                                        NaN   \n",
-       "2577                                        NaN   \n",
-       "2578                                        NaN   \n",
-       "2579                                        NaN   \n",
-       "2580                                        NaN   \n",
-       "2581                                        NaN   \n",
-       "2582                                        NaN   \n",
-       "2583                                        NaN   \n",
-       "2584                                        NaN   \n",
-       "2586                                        NaN   \n",
-       "2587                                        NaN   \n",
-       "2588                                        NaN   \n",
-       "2589                                        NaN   \n",
-       "2590                                        NaN   \n",
-       "2591                                        NaN   \n",
-       "2592                                        NaN   \n",
-       "2593                                        NaN   \n",
-       "2594                                        NaN   \n",
-       "2595                                        NaN   \n",
-       "2596                                        NaN   \n",
-       "2597                                        NaN   \n",
-       "2598                                        NaN   \n",
-       "2599                                        NaN   \n",
-       "\n",
-       "     callbacks.model_checkpoint.save_weights_only  \\\n",
-       "2501                                        False   \n",
-       "2502                                        False   \n",
-       "2503                                        False   \n",
-       "2504                                        False   \n",
-       "2505                                        False   \n",
-       "2506                                        False   \n",
-       "2508                                        False   \n",
-       "2509                                        False   \n",
-       "2510                                        False   \n",
-       "2511                                        False   \n",
-       "2512                                        False   \n",
-       "2513                                        False   \n",
-       "2514                                        False   \n",
-       "2515                                        False   \n",
-       "2516                                        False   \n",
-       "2517                                        False   \n",
-       "2518                                        False   \n",
-       "2519                                        False   \n",
-       "2520                                        False   \n",
-       "2521                                        False   \n",
-       "2522                                        False   \n",
-       "2523                                        False   \n",
-       "2524                                        False   \n",
-       "2525                                        False   \n",
-       "2526                                        False   \n",
-       "2527                                        False   \n",
-       "2528                                        False   \n",
-       "2529                                        False   \n",
-       "2530                                        False   \n",
-       "2531                                        False   \n",
-       "2532                                        False   \n",
-       "2533                                        False   \n",
-       "2534                                        False   \n",
-       "2535                                        False   \n",
-       "2536                                        False   \n",
-       "2537                                        False   \n",
-       "2538                                        False   \n",
-       "2539                                        False   \n",
-       "2540                                        False   \n",
-       "2541                                        False   \n",
-       "2542                                        False   \n",
-       "2543                                        False   \n",
-       "2544                                        False   \n",
-       "2545                                        False   \n",
-       "2546                                        False   \n",
-       "2547                                        False   \n",
-       "2548                                        False   \n",
-       "2549                                        False   \n",
-       "2550                                        False   \n",
-       "2551                                        False   \n",
-       "2552                                        False   \n",
-       "2553                                        False   \n",
-       "2554                                        False   \n",
-       "2555                                        False   \n",
-       "2556                                        False   \n",
-       "2557                                        False   \n",
-       "2558                                        False   \n",
-       "2559                                        False   \n",
-       "2560                                        False   \n",
-       "2561                                        False   \n",
-       "2562                                        False   \n",
-       "2563                                        False   \n",
-       "2564                                        False   \n",
-       "2565                                        False   \n",
-       "2567                                        False   \n",
-       "2568                                        False   \n",
-       "2569                                        False   \n",
-       "2570                                        False   \n",
-       "2571                                        False   \n",
-       "2572                                        False   \n",
-       "2573                                        False   \n",
-       "2574                                        False   \n",
-       "2575                                        False   \n",
-       "2576                                        False   \n",
-       "2577                                        False   \n",
-       "2578                                        False   \n",
-       "2579                                        False   \n",
-       "2580                                        False   \n",
-       "2581                                        False   \n",
-       "2582                                        False   \n",
-       "2583                                        False   \n",
-       "2584                                        False   \n",
-       "2586                                        False   \n",
-       "2587                                        False   \n",
-       "2588                                        False   \n",
-       "2589                                        False   \n",
-       "2590                                        False   \n",
-       "2591                                        False   \n",
-       "2592                                        False   \n",
-       "2593                                        False   \n",
-       "2594                                        False   \n",
-       "2595                                        False   \n",
-       "2596                                        False   \n",
-       "2597                                        False   \n",
-       "2598                                        False   \n",
-       "2599                                        False   \n",
-       "\n",
-       "     callbacks.model_checkpoint.every_n_train_steps  \\\n",
-       "2501                                            NaN   \n",
-       "2502                                            NaN   \n",
-       "2503                                            NaN   \n",
-       "2504                                            NaN   \n",
-       "2505                                            NaN   \n",
-       "2506                                            NaN   \n",
-       "2508                                            NaN   \n",
-       "2509                                            NaN   \n",
-       "2510                                            NaN   \n",
-       "2511                                            NaN   \n",
-       "2512                                            NaN   \n",
-       "2513                                            NaN   \n",
-       "2514                                            NaN   \n",
-       "2515                                            NaN   \n",
-       "2516                                            NaN   \n",
-       "2517                                            NaN   \n",
-       "2518                                            NaN   \n",
-       "2519                                            NaN   \n",
-       "2520                                            NaN   \n",
-       "2521                                            NaN   \n",
-       "2522                                            NaN   \n",
-       "2523                                            NaN   \n",
-       "2524                                            NaN   \n",
-       "2525                                            NaN   \n",
-       "2526                                            NaN   \n",
-       "2527                                            NaN   \n",
-       "2528                                            NaN   \n",
-       "2529                                            NaN   \n",
-       "2530                                            NaN   \n",
-       "2531                                            NaN   \n",
-       "2532                                            NaN   \n",
-       "2533                                            NaN   \n",
-       "2534                                            NaN   \n",
-       "2535                                            NaN   \n",
-       "2536                                            NaN   \n",
-       "2537                                            NaN   \n",
-       "2538                                            NaN   \n",
-       "2539                                            NaN   \n",
-       "2540                                            NaN   \n",
-       "2541                                            NaN   \n",
-       "2542                                            NaN   \n",
-       "2543                                            NaN   \n",
-       "2544                                            NaN   \n",
-       "2545                                            NaN   \n",
-       "2546                                            NaN   \n",
-       "2547                                            NaN   \n",
-       "2548                                            NaN   \n",
-       "2549                                            NaN   \n",
-       "2550                                            NaN   \n",
-       "2551                                            NaN   \n",
-       "2552                                            NaN   \n",
-       "2553                                            NaN   \n",
-       "2554                                            NaN   \n",
-       "2555                                            NaN   \n",
-       "2556                                            NaN   \n",
-       "2557                                            NaN   \n",
-       "2558                                            NaN   \n",
-       "2559                                            NaN   \n",
-       "2560                                            NaN   \n",
-       "2561                                            NaN   \n",
-       "2562                                            NaN   \n",
-       "2563                                            NaN   \n",
-       "2564                                            NaN   \n",
-       "2565                                            NaN   \n",
-       "2567                                            NaN   \n",
-       "2568                                            NaN   \n",
-       "2569                                            NaN   \n",
-       "2570                                            NaN   \n",
-       "2571                                            NaN   \n",
-       "2572                                            NaN   \n",
-       "2573                                            NaN   \n",
-       "2574                                            NaN   \n",
-       "2575                                            NaN   \n",
-       "2576                                            NaN   \n",
-       "2577                                            NaN   \n",
-       "2578                                            NaN   \n",
-       "2579                                            NaN   \n",
-       "2580                                            NaN   \n",
-       "2581                                            NaN   \n",
-       "2582                                            NaN   \n",
-       "2583                                            NaN   \n",
-       "2584                                            NaN   \n",
-       "2586                                            NaN   \n",
-       "2587                                            NaN   \n",
-       "2588                                            NaN   \n",
-       "2589                                            NaN   \n",
-       "2590                                            NaN   \n",
-       "2591                                            NaN   \n",
-       "2592                                            NaN   \n",
-       "2593                                            NaN   \n",
-       "2594                                            NaN   \n",
-       "2595                                            NaN   \n",
-       "2596                                            NaN   \n",
-       "2597                                            NaN   \n",
-       "2598                                            NaN   \n",
-       "2599                                            NaN   \n",
-       "\n",
-       "     callbacks.model_checkpoint.train_time_interval  \\\n",
-       "2501                                            NaN   \n",
-       "2502                                            NaN   \n",
-       "2503                                            NaN   \n",
-       "2504                                            NaN   \n",
-       "2505                                            NaN   \n",
-       "2506                                            NaN   \n",
-       "2508                                            NaN   \n",
-       "2509                                            NaN   \n",
-       "2510                                            NaN   \n",
-       "2511                                            NaN   \n",
-       "2512                                            NaN   \n",
-       "2513                                            NaN   \n",
-       "2514                                            NaN   \n",
-       "2515                                            NaN   \n",
-       "2516                                            NaN   \n",
-       "2517                                            NaN   \n",
-       "2518                                            NaN   \n",
-       "2519                                            NaN   \n",
-       "2520                                            NaN   \n",
-       "2521                                            NaN   \n",
-       "2522                                            NaN   \n",
-       "2523                                            NaN   \n",
-       "2524                                            NaN   \n",
-       "2525                                            NaN   \n",
-       "2526                                            NaN   \n",
-       "2527                                            NaN   \n",
-       "2528                                            NaN   \n",
-       "2529                                            NaN   \n",
-       "2530                                            NaN   \n",
-       "2531                                            NaN   \n",
-       "2532                                            NaN   \n",
-       "2533                                            NaN   \n",
-       "2534                                            NaN   \n",
-       "2535                                            NaN   \n",
-       "2536                                            NaN   \n",
-       "2537                                            NaN   \n",
-       "2538                                            NaN   \n",
-       "2539                                            NaN   \n",
-       "2540                                            NaN   \n",
-       "2541                                            NaN   \n",
-       "2542                                            NaN   \n",
-       "2543                                            NaN   \n",
-       "2544                                            NaN   \n",
-       "2545                                            NaN   \n",
-       "2546                                            NaN   \n",
-       "2547                                            NaN   \n",
-       "2548                                            NaN   \n",
-       "2549                                            NaN   \n",
-       "2550                                            NaN   \n",
-       "2551                                            NaN   \n",
-       "2552                                            NaN   \n",
-       "2553                                            NaN   \n",
-       "2554                                            NaN   \n",
-       "2555                                            NaN   \n",
-       "2556                                            NaN   \n",
-       "2557                                            NaN   \n",
-       "2558                                            NaN   \n",
-       "2559                                            NaN   \n",
-       "2560                                            NaN   \n",
-       "2561                                            NaN   \n",
-       "2562                                            NaN   \n",
-       "2563                                            NaN   \n",
-       "2564                                            NaN   \n",
-       "2565                                            NaN   \n",
-       "2567                                            NaN   \n",
-       "2568                                            NaN   \n",
-       "2569                                            NaN   \n",
-       "2570                                            NaN   \n",
-       "2571                                            NaN   \n",
-       "2572                                            NaN   \n",
-       "2573                                            NaN   \n",
-       "2574                                            NaN   \n",
-       "2575                                            NaN   \n",
-       "2576                                            NaN   \n",
-       "2577                                            NaN   \n",
-       "2578                                            NaN   \n",
-       "2579                                            NaN   \n",
-       "2580                                            NaN   \n",
-       "2581                                            NaN   \n",
-       "2582                                            NaN   \n",
-       "2583                                            NaN   \n",
-       "2584                                            NaN   \n",
-       "2586                                            NaN   \n",
-       "2587                                            NaN   \n",
-       "2588                                            NaN   \n",
-       "2589                                            NaN   \n",
-       "2590                                            NaN   \n",
-       "2591                                            NaN   \n",
-       "2592                                            NaN   \n",
-       "2593                                            NaN   \n",
-       "2594                                            NaN   \n",
-       "2595                                            NaN   \n",
-       "2596                                            NaN   \n",
-       "2597                                            NaN   \n",
-       "2598                                            NaN   \n",
-       "2599                                            NaN   \n",
-       "\n",
-       "      callbacks.model_checkpoint.auto_insert_metric_name  \\\n",
-       "2501                                              False    \n",
-       "2502                                              False    \n",
-       "2503                                              False    \n",
-       "2504                                              False    \n",
-       "2505                                              False    \n",
-       "2506                                              False    \n",
-       "2508                                              False    \n",
-       "2509                                              False    \n",
-       "2510                                              False    \n",
-       "2511                                              False    \n",
-       "2512                                              False    \n",
-       "2513                                              False    \n",
-       "2514                                              False    \n",
-       "2515                                              False    \n",
-       "2516                                              False    \n",
-       "2517                                              False    \n",
-       "2518                                              False    \n",
-       "2519                                              False    \n",
-       "2520                                              False    \n",
-       "2521                                              False    \n",
-       "2522                                              False    \n",
-       "2523                                              False    \n",
-       "2524                                              False    \n",
-       "2525                                              False    \n",
-       "2526                                              False    \n",
-       "2527                                              False    \n",
-       "2528                                              False    \n",
-       "2529                                              False    \n",
-       "2530                                              False    \n",
-       "2531                                              False    \n",
-       "2532                                              False    \n",
-       "2533                                              False    \n",
-       "2534                                              False    \n",
-       "2535                                              False    \n",
-       "2536                                              False    \n",
-       "2537                                              False    \n",
-       "2538                                              False    \n",
-       "2539                                              False    \n",
-       "2540                                              False    \n",
-       "2541                                              False    \n",
-       "2542                                              False    \n",
-       "2543                                              False    \n",
-       "2544                                              False    \n",
-       "2545                                              False    \n",
-       "2546                                              False    \n",
-       "2547                                              False    \n",
-       "2548                                              False    \n",
-       "2549                                              False    \n",
-       "2550                                              False    \n",
-       "2551                                              False    \n",
-       "2552                                              False    \n",
-       "2553                                              False    \n",
-       "2554                                              False    \n",
-       "2555                                              False    \n",
-       "2556                                              False    \n",
-       "2557                                              False    \n",
-       "2558                                              False    \n",
-       "2559                                              False    \n",
-       "2560                                              False    \n",
-       "2561                                              False    \n",
-       "2562                                              False    \n",
-       "2563                                              False    \n",
-       "2564                                              False    \n",
-       "2565                                              False    \n",
-       "2567                                              False    \n",
-       "2568                                              False    \n",
-       "2569                                              False    \n",
-       "2570                                              False    \n",
-       "2571                                              False    \n",
-       "2572                                              False    \n",
-       "2573                                              False    \n",
-       "2574                                              False    \n",
-       "2575                                              False    \n",
-       "2576                                              False    \n",
-       "2577                                              False    \n",
-       "2578                                              False    \n",
-       "2579                                              False    \n",
-       "2580                                              False    \n",
-       "2581                                              False    \n",
-       "2582                                              False    \n",
-       "2583                                              False    \n",
-       "2584                                              False    \n",
-       "2586                                              False    \n",
-       "2587                                              False    \n",
-       "2588                                              False    \n",
-       "2589                                              False    \n",
-       "2590                                              False    \n",
-       "2591                                              False    \n",
-       "2592                                              False    \n",
-       "2593                                              False    \n",
-       "2594                                              False    \n",
-       "2595                                              False    \n",
-       "2596                                              False    \n",
-       "2597                                              False    \n",
-       "2598                                              False    \n",
-       "2599                                              False    \n",
-       "\n",
-       "     callbacks.model_checkpoint.save_on_train_epoch_end  \\\n",
-       "2501                                                NaN   \n",
-       "2502                                                NaN   \n",
-       "2503                                                NaN   \n",
-       "2504                                                NaN   \n",
-       "2505                                                NaN   \n",
-       "2506                                                NaN   \n",
-       "2508                                                NaN   \n",
-       "2509                                                NaN   \n",
-       "2510                                                NaN   \n",
-       "2511                                                NaN   \n",
-       "2512                                                NaN   \n",
-       "2513                                                NaN   \n",
-       "2514                                                NaN   \n",
-       "2515                                                NaN   \n",
-       "2516                                                NaN   \n",
-       "2517                                                NaN   \n",
-       "2518                                                NaN   \n",
-       "2519                                                NaN   \n",
-       "2520                                                NaN   \n",
-       "2521                                                NaN   \n",
-       "2522                                                NaN   \n",
-       "2523                                                NaN   \n",
-       "2524                                                NaN   \n",
-       "2525                                                NaN   \n",
-       "2526                                                NaN   \n",
-       "2527                                                NaN   \n",
-       "2528                                                NaN   \n",
-       "2529                                                NaN   \n",
-       "2530                                                NaN   \n",
-       "2531                                                NaN   \n",
-       "2532                                                NaN   \n",
-       "2533                                                NaN   \n",
-       "2534                                                NaN   \n",
-       "2535                                                NaN   \n",
-       "2536                                                NaN   \n",
-       "2537                                                NaN   \n",
-       "2538                                                NaN   \n",
-       "2539                                                NaN   \n",
-       "2540                                                NaN   \n",
-       "2541                                                NaN   \n",
-       "2542                                                NaN   \n",
-       "2543                                                NaN   \n",
-       "2544                                                NaN   \n",
-       "2545                                                NaN   \n",
-       "2546                                                NaN   \n",
-       "2547                                                NaN   \n",
-       "2548                                                NaN   \n",
-       "2549                                                NaN   \n",
-       "2550                                                NaN   \n",
-       "2551                                                NaN   \n",
-       "2552                                                NaN   \n",
-       "2553                                                NaN   \n",
-       "2554                                                NaN   \n",
-       "2555                                                NaN   \n",
-       "2556                                                NaN   \n",
-       "2557                                                NaN   \n",
-       "2558                                                NaN   \n",
-       "2559                                                NaN   \n",
-       "2560                                                NaN   \n",
-       "2561                                                NaN   \n",
-       "2562                                                NaN   \n",
-       "2563                                                NaN   \n",
-       "2564                                                NaN   \n",
-       "2565                                                NaN   \n",
-       "2567                                                NaN   \n",
-       "2568                                                NaN   \n",
-       "2569                                                NaN   \n",
-       "2570                                                NaN   \n",
-       "2571                                                NaN   \n",
-       "2572                                                NaN   \n",
-       "2573                                                NaN   \n",
-       "2574                                                NaN   \n",
-       "2575                                                NaN   \n",
-       "2576                                                NaN   \n",
-       "2577                                                NaN   \n",
-       "2578                                                NaN   \n",
-       "2579                                                NaN   \n",
-       "2580                                                NaN   \n",
-       "2581                                                NaN   \n",
-       "2582                                                NaN   \n",
-       "2583                                                NaN   \n",
-       "2584                                                NaN   \n",
-       "2586                                                NaN   \n",
-       "2587                                                NaN   \n",
-       "2588                                                NaN   \n",
-       "2589                                                NaN   \n",
-       "2590                                                NaN   \n",
-       "2591                                                NaN   \n",
-       "2592                                                NaN   \n",
-       "2593                                                NaN   \n",
-       "2594                                                NaN   \n",
-       "2595                                                NaN   \n",
-       "2596                                                NaN   \n",
-       "2597                                                NaN   \n",
-       "2598                                                NaN   \n",
-       "2599                                                NaN   \n",
-       "\n",
-       "             callbacks.rich_progress_bar._target_  \\\n",
-       "2501  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2502  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2503  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2504  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2505  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2506  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2508  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2509  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2510  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2511  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2512  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2513  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2514  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2515  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2516  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2517  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2518  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2519  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2520  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2521  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2522  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2523  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2524  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2525  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2526  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2527  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2528  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2529  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2530  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2531  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2532  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2533  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2534  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2535  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2536  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2537  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2538  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2539  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2540  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2541  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2542  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2543  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2544  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2545  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2546  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2547  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2548  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2549  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2550  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2551  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2552  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2553  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2554  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2555  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2556  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2557  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2558  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2559  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2560  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2561  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2562  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2563  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2564  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2565  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2567  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2568  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2569  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2570  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2571  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2572  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2573  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2574  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2575  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2576  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2577  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2578  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2579  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2580  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2581  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2582  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2583  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2584  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2586  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2587  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2588  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2589  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2590  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2591  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2592  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2593  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2594  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2595  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2596  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2597  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2598  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "2599  lightning.pytorch.callbacks.RichProgressBar   \n",
-       "\n",
-       "             callbacks.learning_rate_monitor._target_  \\\n",
-       "2501  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2502  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2503  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2504  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2505  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2506  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2508  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2509  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2510  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2511  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2512  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2513  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2514  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2515  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2516  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2517  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2518  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2519  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2520  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2521  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2522  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2523  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2524  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2525  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2526  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2527  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2528  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2529  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2530  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2531  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2532  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2533  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2534  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2535  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2536  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2537  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2538  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2539  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2540  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2541  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2542  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2543  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2544  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2545  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2546  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2547  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2548  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2549  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2550  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2551  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2552  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2553  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2554  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2555  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2556  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2557  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2558  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2559  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2560  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2561  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2562  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2563  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2564  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2565  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2567  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2568  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2569  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2570  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2571  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2572  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2573  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2574  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2575  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2576  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2577  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2578  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2579  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2580  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2581  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2582  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2583  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2584  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2586  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2587  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2588  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2589  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2590  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2591  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2592  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2593  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2594  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2595  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2596  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2597  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2598  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "2599  lightning.pytorch.callbacks.LearningRateMonitor   \n",
-       "\n",
-       "      callbacks.learning_rate_monitor.logging_interval Model  \n",
-       "2501                                             epoch  SCCN  \n",
-       "2502                                             epoch  SCCN  \n",
-       "2503                                             epoch  SCCN  \n",
-       "2504                                             epoch  SCCN  \n",
-       "2505                                             epoch  SCCN  \n",
-       "2506                                             epoch  SCCN  \n",
-       "2508                                             epoch  SCCN  \n",
-       "2509                                             epoch  SCCN  \n",
-       "2510                                             epoch  SCCN  \n",
-       "2511                                             epoch  SCCN  \n",
-       "2512                                             epoch  SCCN  \n",
-       "2513                                             epoch  SCCN  \n",
-       "2514                                             epoch  SCCN  \n",
-       "2515                                             epoch  SCCN  \n",
-       "2516                                             epoch  SCCN  \n",
-       "2517                                             epoch  SCCN  \n",
-       "2518                                             epoch  SCCN  \n",
-       "2519                                             epoch  SCCN  \n",
-       "2520                                             epoch  SCCN  \n",
-       "2521                                             epoch  SCCN  \n",
-       "2522                                             epoch  SCCN  \n",
-       "2523                                             epoch  SCCN  \n",
-       "2524                                             epoch  SCCN  \n",
-       "2525                                             epoch  SCCN  \n",
-       "2526                                             epoch  SCCN  \n",
-       "2527                                             epoch  SCCN  \n",
-       "2528                                             epoch  SCCN  \n",
-       "2529                                             epoch  SCCN  \n",
-       "2530                                             epoch  SCCN  \n",
-       "2531                                             epoch  SCCN  \n",
-       "2532                                             epoch  SCCN  \n",
-       "2533                                             epoch  SCCN  \n",
-       "2534                                             epoch  SCCN  \n",
-       "2535                                             epoch  SCCN  \n",
-       "2536                                             epoch  SCCN  \n",
-       "2537                                             epoch  SCCN  \n",
-       "2538                                             epoch  SCCN  \n",
-       "2539                                             epoch  SCCN  \n",
-       "2540                                             epoch  SCCN  \n",
-       "2541                                             epoch  SCCN  \n",
-       "2542                                             epoch  SCCN  \n",
-       "2543                                             epoch  SCCN  \n",
-       "2544                                             epoch  SCCN  \n",
-       "2545                                             epoch  SCCN  \n",
-       "2546                                             epoch  SCCN  \n",
-       "2547                                             epoch  SCCN  \n",
-       "2548                                             epoch  SCCN  \n",
-       "2549                                             epoch  SCCN  \n",
-       "2550                                             epoch  SCCN  \n",
-       "2551                                             epoch  SCCN  \n",
-       "2552                                             epoch  SCCN  \n",
-       "2553                                             epoch  SCCN  \n",
-       "2554                                             epoch  SCCN  \n",
-       "2555                                             epoch  SCCN  \n",
-       "2556                                             epoch  SCCN  \n",
-       "2557                                             epoch  SCCN  \n",
-       "2558                                             epoch  SCCN  \n",
-       "2559                                             epoch  SCCN  \n",
-       "2560                                             epoch  SCCN  \n",
-       "2561                                             epoch  SCCN  \n",
-       "2562                                             epoch  SCCN  \n",
-       "2563                                             epoch  SCCN  \n",
-       "2564                                             epoch  SCCN  \n",
-       "2565                                             epoch  SCCN  \n",
-       "2567                                             epoch  SCCN  \n",
-       "2568                                             epoch  SCCN  \n",
-       "2569                                             epoch  SCCN  \n",
-       "2570                                             epoch  SCCN  \n",
-       "2571                                             epoch  SCCN  \n",
-       "2572                                             epoch  SCCN  \n",
-       "2573                                             epoch  SCCN  \n",
-       "2574                                             epoch  SCCN  \n",
-       "2575                                             epoch  SCCN  \n",
-       "2576                                             epoch  SCCN  \n",
-       "2577                                             epoch  SCCN  \n",
-       "2578                                             epoch  SCCN  \n",
-       "2579                                             epoch  SCCN  \n",
-       "2580                                             epoch  SCCN  \n",
-       "2581                                             epoch  SCCN  \n",
-       "2582                                             epoch  SCCN  \n",
-       "2583                                             epoch  SCCN  \n",
-       "2584                                             epoch  SCCN  \n",
-       "2586                                             epoch  SCCN  \n",
-       "2587                                             epoch  SCCN  \n",
-       "2588                                             epoch  SCCN  \n",
-       "2589                                             epoch  SCCN  \n",
-       "2590                                             epoch  SCCN  \n",
-       "2591                                             epoch  SCCN  \n",
-       "2592                                             epoch  SCCN  \n",
-       "2593                                             epoch  SCCN  \n",
-       "2594                                             epoch  SCCN  \n",
-       "2595                                             epoch  SCCN  \n",
-       "2596                                             epoch  SCCN  \n",
-       "2597                                             epoch  SCCN  \n",
-       "2598                                             epoch  SCCN  \n",
-       "2599                                             epoch  SCCN  \n",
-       "\n",
-       "[96 rows x 179 columns]"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/tmp/ipykernel_1237364/1100605474.py:11: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n",
-      "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n",
-      "A typical example is when you are setting values in a column of a DataFrame, like:\n",
-      "\n",
-      "df[\"col\"][row_indexer] = value\n",
-      "\n",
-      "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n",
-      "\n",
-      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
-      "\n",
-      "  a[\"dataset.transforms.graph2simplicial_lifting.feature_lifting\"][\n",
-      "/tmp/ipykernel_1237364/1100605474.py:11: SettingWithCopyWarning: \n",
-      "A value is trying to be set on a copy of a slice from a DataFrame\n",
-      "\n",
-      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
-      "  a[\"dataset.transforms.graph2simplicial_lifting.feature_lifting\"][\n"
-     ]
-    },
-    {
-     "ename": "KeyError",
-     "evalue": "('test/mae', 'mean')",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
-      "\u001b[0;32m/tmp/ipykernel_1237364/1100605474.py\u001b[0m in \u001b[0;36m?\u001b[0;34m()\u001b[0m\n\u001b[1;32m     30\u001b[0m     \u001b[0mascending\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     31\u001b[0m     \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msort_values\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mby\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"test/mae\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"mean\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mascending\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mascending\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     32\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     33\u001b[0m     \u001b[0mascending\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 34\u001b[0;31m     \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msort_values\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mby\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"test/mae\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"mean\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mascending\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mascending\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     35\u001b[0m \u001b[0;31m# Show all rows\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     36\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_option\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"display.max_rows\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     37\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/miniconda3/envs/topox/lib/python3.11/site-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, by, axis, ascending, inplace, kind, na_position, ignore_index, key)\u001b[0m\n\u001b[1;32m   7185\u001b[0m             )\n\u001b[1;32m   7186\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mby\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   7187\u001b[0m             \u001b[0;31m# len(by) == 1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   7188\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 7189\u001b[0;31m             \u001b[0mk\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_label_or_level_values\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mby\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   7190\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   7191\u001b[0m             \u001b[0;31m# need to rewrap column in Series to apply key function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   7192\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mkey\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/miniconda3/envs/topox/lib/python3.11/site-packages/pandas/core/generic.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, key, axis)\u001b[0m\n\u001b[1;32m   1907\u001b[0m             \u001b[0mvalues\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mother_axes\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_values\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1908\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_is_level_reference\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1909\u001b[0m             \u001b[0mvalues\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_level_values\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_values\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1910\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1911\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1912\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1913\u001b[0m         \u001b[0;31m# Check for duplicates\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1914\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mKeyError\u001b[0m: ('test/mae', 'mean')"
-     ]
-    }
-   ],
-   "source": [
-    "# collected_aggregated_results['ZINC']['SCCN']\n",
-    "dataset = \"Cora\"\n",
-    "model = \"SCCNN\"\n",
-    "a = collected_non_aggregated_results[dataset][model][\"df\"]\n",
-    "aggregation_columns = collected_non_aggregated_results[dataset][model][\n",
-    "    \"aggregation_columns\"\n",
-    "]\n",
-    "performance_cols = collected_non_aggregated_results[dataset][model][\"performance_cols\"]\n",
-    "\n",
-    "# a = a[(a['dataset.transforms.graph2simplicial_lifting.feature_lifting'] =='set') | (a['dataset.transforms.graph2simplicial_lifting.feature_lifting'] =='concatenation')]\n",
-    "a[\"dataset.transforms.graph2simplicial_lifting.feature_lifting\"][\n",
-    "    a[\"dataset.transforms.graph2simplicial_lifting.feature_lifting\"].isna()\n",
-    "] = \"projection\"\n",
-    "\n",
-    "if \"mae\" in performance_cols:\n",
-    "    a = a[~a[\"test/mae\"].isna()]\n",
-    "else:\n",
-    "    pass\n",
-    "\n",
-    "a = a.groupby(\n",
-    "    aggregation_columns\n",
-    "    + [\n",
-    "        \"dataset.transforms.graph2simplicial_lifting.feature_lifting\",\n",
-    "        \"model.feature_encoder._target_\",\n",
-    "        \"model.backbone_wrapper.wrapper_readout\",\n",
-    "    ]\n",
-    ").agg({col: [\"mean\", \"std\"] for col in performance_cols})\n",
-    "\n",
-    "if \"mae\" in performance_cols:\n",
-    "    ascending = True\n",
-    "    a = a.sort_values(by=(\"test/mae\", \"mean\"), ascending=ascending)\n",
-    "else:\n",
-    "    ascending = False\n",
-    "    a = a.sort_values(by=(\"test/mae\", \"mean\"), ascending=ascending)\n",
-    "# Show all rows\n",
-    "pd.set_option(\"display.max_rows\", None)\n",
-    "\n",
-    "a"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['Model',\n",
-       " 'model.readout.in_channels',\n",
-       " 'model.readout.pooling_type',\n",
-       " 'model.backbone.n_layers',\n",
-       " 'model.feature_encoder.out_channels',\n",
-       " 'model.backbone_wrapper.out_channels',\n",
-       " 'model.backbone_wrapper.wrapper_readout',\n",
-       " 'dataset.transforms.graph2simplicial_lifting.signed']"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "aggregation_columns"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# a = list(collected_aggregated_results['ZINC']['SCCNN']['dataset.parameters.batch_size'])[:10]\n",
-    "# # Print the proportion of unique values\n",
-    "# a, b = np.unique(a, return_counts=True)\n",
-    "# print(f'Lr values:{a[0]}, prop_counts: {b[0]/sum(b)}',)\n",
-    "# print(f'Lr values:{a[1]}, prop_counts: {b[1]/sum(b)}',)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# collected_aggregated_results['ZINC']['SCCN']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Convert nested dictionary to DataFrame\n",
-    "nested_dict = dict(collected_results)\n",
-    "result_dict = pd.DataFrame.from_dict(\n",
-    "    {\n",
-    "        (i, j): nested_dict[i][j]\n",
-    "        for i in nested_dict\n",
-    "        for j in nested_dict[i].keys()\n",
-    "    },\n",
-    "    orient=\"index\",\n",
-    ")\n",
-    "\n",
-    "\n",
-    "result_dict = result_dict.round(2)\n",
-    "result_dict[\"performance\"] = result_dict.apply(\n",
-    "    lambda x: f\"{x['mean']} ± {x['std']}\", axis=1\n",
-    ")\n",
-    "result_dict = result_dict.drop([\"mean\", \"std\"], axis=1)\n",
-    "\n",
-    "# Reset multiindex\n",
-    "result_dict = result_dict.reset_index()\n",
-    "# rename columns\n",
-    "result_dict.columns = [\"Dataset\", \"Model\", \"Performance\"]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "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>Dataset</th>\n",
-       "      <th>Cora</th>\n",
-       "      <th>IMDB-BINARY</th>\n",
-       "      <th>IMDB-MULTI</th>\n",
-       "      <th>MUTAG</th>\n",
-       "      <th>NCI1</th>\n",
-       "      <th>PROTEINS</th>\n",
-       "      <th>PubMed</th>\n",
-       "      <th>REDDIT-BINARY</th>\n",
-       "      <th>ZINC</th>\n",
-       "      <th>citeseer</th>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>Model</th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>AllSet</th>\n",
-       "      <td>89.05 ± 0.56</td>\n",
-       "      <td>80.0 ± 2.65</td>\n",
-       "      <td>52.89 ± 2.04</td>\n",
-       "      <td>92.59 ± 3.21</td>\n",
-       "      <td>80.7 ± 0.85</td>\n",
-       "      <td>81.6 ± 4.56</td>\n",
-       "      <td>88.12 ± 0.2</td>\n",
-       "      <td>75.0 ± 1.41</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>75.28 ± 1.83</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>CWN</th>\n",
-       "      <td>88.56 ± 1.95</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>nan ± nan</td>\n",
-       "      <td>77.86 ± nan</td>\n",
-       "      <td>78.73 ± 4.32</td>\n",
-       "      <td>87.53 ± 0.5</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.45 ± nan</td>\n",
-       "      <td>75.48 ± 1.76</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>CWNDCM</th>\n",
-       "      <td>89.42 ± 1.89</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>85.19 ± 8.49</td>\n",
-       "      <td>75.51 ± 1.62</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>87.61 ± 0.72</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.79 ± nan</td>\n",
-       "      <td>75.58 ± 0.46</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>EDGNN</th>\n",
-       "      <td>90.16 ± 0.43</td>\n",
-       "      <td>78.33 ± 1.15</td>\n",
-       "      <td>53.33 ± 0.67</td>\n",
-       "      <td>92.59 ± 3.21</td>\n",
-       "      <td>80.05 ± nan</td>\n",
-       "      <td>81.61 ± 2.02</td>\n",
-       "      <td>90.38 ± 0.47</td>\n",
-       "      <td>83.5 ± 0.87</td>\n",
-       "      <td>0.44 ± nan</td>\n",
-       "      <td>77.38 ± 0.87</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>GCN</th>\n",
-       "      <td>89.85 ± 1.83</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>90.74 ± 3.21</td>\n",
-       "      <td>80.37 ± 0.37</td>\n",
-       "      <td>79.93 ± 4.68</td>\n",
-       "      <td>88.54 ± 0.13</td>\n",
-       "      <td>78.17 ± 2.25</td>\n",
-       "      <td>0.66 ± nan</td>\n",
-       "      <td>76.38 ± 1.35</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>GIN</th>\n",
-       "      <td>89.79 ± 0.93</td>\n",
-       "      <td>78.67 ± 1.53</td>\n",
-       "      <td>52.22 ± 1.39</td>\n",
-       "      <td>94.44 ± 5.56</td>\n",
-       "      <td>81.75 ± 0.84</td>\n",
-       "      <td>80.23 ± 5.08</td>\n",
-       "      <td>87.54 ± 0.57</td>\n",
-       "      <td>86.5 ± 2.78</td>\n",
-       "      <td>0.4 ± nan</td>\n",
-       "      <td>76.08 ± 1.81</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>SCCN</th>\n",
-       "      <td>89.18 ± 1.13</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>94.44 ± 5.56</td>\n",
-       "      <td>81.83 ± 0.51</td>\n",
-       "      <td>81.12 ± 5.96</td>\n",
-       "      <td>88.78 ± 0.3</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.52 ± nan</td>\n",
-       "      <td>76.88 ± 2.17</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>SCCNN</th>\n",
-       "      <td>88.44 ± 2.25</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>94.44 ± 5.56</td>\n",
-       "      <td>81.35 ± 4.19</td>\n",
-       "      <td>80.23 ± 3.96</td>\n",
-       "      <td>89.82 ± 0.65</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.55 ± nan</td>\n",
-       "      <td>77.08 ± 1.54</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>SCCNNCustom</th>\n",
-       "      <td>88.93 ± 2.58</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>79.32 ± 3.18</td>\n",
-       "      <td>80.82 ± 5.02</td>\n",
-       "      <td>89.38 ± 0.49</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.58 ± nan</td>\n",
-       "      <td>76.88 ± 0.3</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>UniGCNII</th>\n",
-       "      <td>90.65 ± 0.85</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>77.94 ± 1.84</td>\n",
-       "      <td>81.13 ± 5.53</td>\n",
-       "      <td>89.49 ± 0.16</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>77.48 ± 0.52</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "Dataset               Cora   IMDB-BINARY    IMDB-MULTI         MUTAG  \\\n",
-       "Model                                                                  \n",
-       "AllSet        89.05 ± 0.56   80.0 ± 2.65  52.89 ± 2.04  92.59 ± 3.21   \n",
-       "CWN           88.56 ± 1.95           NaN           NaN     nan ± nan   \n",
-       "CWNDCM        89.42 ± 1.89           NaN           NaN  85.19 ± 8.49   \n",
-       "EDGNN         90.16 ± 0.43  78.33 ± 1.15  53.33 ± 0.67  92.59 ± 3.21   \n",
-       "GCN           89.85 ± 1.83           NaN           NaN  90.74 ± 3.21   \n",
-       "GIN           89.79 ± 0.93  78.67 ± 1.53  52.22 ± 1.39  94.44 ± 5.56   \n",
-       "SCCN          89.18 ± 1.13           NaN           NaN  94.44 ± 5.56   \n",
-       "SCCNN         88.44 ± 2.25           NaN           NaN  94.44 ± 5.56   \n",
-       "SCCNNCustom  88.93 ± 2.58           NaN           NaN           NaN   \n",
-       "UniGCNII      90.65 ± 0.85           NaN           NaN           NaN   \n",
-       "\n",
-       "Dataset               NCI1      PROTEINS        PubMed REDDIT-BINARY  \\\n",
-       "Model                                                                  \n",
-       "AllSet         80.7 ± 0.85   81.6 ± 4.56   88.12 ± 0.2   75.0 ± 1.41   \n",
-       "CWN            77.86 ± nan  78.73 ± 4.32   87.53 ± 0.5           NaN   \n",
-       "CWNDCM        75.51 ± 1.62           NaN  87.61 ± 0.72           NaN   \n",
-       "EDGNN          80.05 ± nan  81.61 ± 2.02  90.38 ± 0.47   83.5 ± 0.87   \n",
-       "GCN           80.37 ± 0.37  79.93 ± 4.68  88.54 ± 0.13  78.17 ± 2.25   \n",
-       "GIN           81.75 ± 0.84  80.23 ± 5.08  87.54 ± 0.57   86.5 ± 2.78   \n",
-       "SCCN          81.83 ± 0.51  81.12 ± 5.96   88.78 ± 0.3           NaN   \n",
-       "SCCNN         81.35 ± 4.19  80.23 ± 3.96  89.82 ± 0.65           NaN   \n",
-       "SCCNNCustom  79.32 ± 3.18  80.82 ± 5.02  89.38 ± 0.49           NaN   \n",
-       "UniGCNII      77.94 ± 1.84  81.13 ± 5.53  89.49 ± 0.16           NaN   \n",
-       "\n",
-       "Dataset             ZINC      citeseer  \n",
-       "Model                                   \n",
-       "AllSet               NaN  75.28 ± 1.83  \n",
-       "CWN           0.45 ± nan  75.48 ± 1.76  \n",
-       "CWNDCM        0.79 ± nan  75.58 ± 0.46  \n",
-       "EDGNN         0.44 ± nan  77.38 ± 0.87  \n",
-       "GCN           0.66 ± nan  76.38 ± 1.35  \n",
-       "GIN            0.4 ± nan  76.08 ± 1.81  \n",
-       "SCCN          0.52 ± nan  76.88 ± 2.17  \n",
-       "SCCNN         0.55 ± nan  77.08 ± 1.54  \n",
-       "SCCNNCustom  0.58 ± nan   76.88 ± 0.3  \n",
-       "UniGCNII             NaN  77.48 ± 0.52  "
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "result_dict.pivot_table(\n",
-    "    index=\"Model\", columns=\"Dataset\", values=\"Performance\", aggfunc=\"first\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Curl and divergence operators applied to vector field"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 800x600 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 800x600 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "\n",
-    "# Define the vector field function\n",
-    "def vector_field(x, y):\n",
-    "    Fx = np.cos(x + 2 * y)\n",
-    "    Fy = np.sin(x - 2 * y)\n",
-    "    return Fx, Fy\n",
-    "\n",
-    "\n",
-    "# Define the curl of the vector field\n",
-    "def curl(x, y):\n",
-    "    curl_x = np.gradient(vector_field(x, y)[1], axis=1)\n",
-    "    curl_y = -np.gradient(vector_field(x, y)[0], axis=0)\n",
-    "    return curl_x, curl_y\n",
-    "\n",
-    "\n",
-    "# Define the divergence of the vector field\n",
-    "def divergence(x, y):\n",
-    "    div_x = np.gradient(vector_field(x, y)[0], axis=1)\n",
-    "    div_y = np.gradient(vector_field(x, y)[1], axis=0)\n",
-    "    return div_x + div_y\n",
-    "\n",
-    "\n",
-    "# Generate 2D grid for visualization\n",
-    "x = np.linspace(-2, 2, 20)\n",
-    "y = np.linspace(-2, 2, 20)\n",
-    "X, Y = np.meshgrid(x, y)\n",
-    "\n",
-    "# Plot vector field\n",
-    "plt.figure(figsize=(8, 6))\n",
-    "\n",
-    "\n",
-    "# Plot curl magnitude\n",
-    "curl_x, curl_y = curl(X, Y)\n",
-    "curl_mag = np.sqrt(curl_x**2 + curl_y**2)\n",
-    "\n",
-    "plt.contourf(X, Y, curl_mag, cmap=\"coolwarm\")\n",
-    "plt.quiver(X, Y, np.cos(X + 2 * Y), np.sin(X - 2 * Y), scale=20)\n",
-    "plt.quiver(X, Y, curl_x, curl_y, color=\"red\", scale=20)\n",
-    "plt.colorbar(label=\"Curl Magnitude\")\n",
-    "plt.title(\"Curl Magnitude\")\n",
-    "plt.xlabel(\"X\")\n",
-    "plt.ylabel(\"Y\")\n",
-    "\n",
-    "plt.show()\n",
-    "\n",
-    "\n",
-    "# Plot vector field\n",
-    "plt.figure(figsize=(8, 6))\n",
-    "\n",
-    "\n",
-    "div = divergence(X, Y)\n",
-    "\n",
-    "plt.contourf(X, Y, div, cmap=\"coolwarm\")\n",
-    "plt.quiver(X, Y, np.cos(X + 2 * Y), np.sin(X - 2 * Y), scale=20)\n",
-    "plt.quiver(X, Y, curl_x, curl_y, color=\"red\", scale=20)\n",
-    "plt.colorbar(label=\"Divergence\")\n",
-    "plt.title(\"Divergence\")\n",
-    "plt.xlabel(\"X\")\n",
-    "plt.ylabel(\"Y\")\n",
-    "\n",
-    "plt.show()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "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.11.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/notebooks/test_cellular_lifting_dev.ipynb b/notebooks/test_cellular_lifting_dev.ipynb
deleted file mode 100644
index d4c4f52e..00000000
--- a/notebooks/test_cellular_lifting_dev.ipynb
+++ /dev/null
@@ -1,123 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%load_ext autoreload\n",
-    "%autoreload 2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\"\"\"Test the message passing module.\"\"\"\n",
-    "\n",
-    "import rootutils\n",
-    "import torch\n",
-    "\n",
-    "rootutils.setup_root(\"./\", indicator=\".project-root\", pythonpath=True)\n",
-    "from topobenchmarkx.data.load.loaders import manual_simple_graph\n",
-    "from topobenchmarkx.transforms.liftings.graph2cell import CellCycleLifting\n",
-    "\n",
-    "\n",
-    "class TestCellCycleLifting:\n",
-    "    \"\"\"Test the CellCycleLifting class.\"\"\"\n",
-    "\n",
-    "    def setup_method(self):\n",
-    "        # Load the graph\n",
-    "        self.data = manual_simple_graph()\n",
-    "\n",
-    "        # Initialise the CellCycleLifting class\n",
-    "        self.lifting = CellCycleLifting()\n",
-    "\n",
-    "    def test_lift_topology(self):\n",
-    "        # Test the lift_topology method\n",
-    "        lifted_data = self.lifting.forward(self.data.clone())\n",
-    "\n",
-    "        expected_incidence_1 = torch.tensor(\n",
-    "            [\n",
-    "                [1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            expected_incidence_1 == lifted_data.incidence_1.to_dense()\n",
-    "        ).all(), \"Something is wrong with incidence_1.\"\n",
-    "\n",
-    "        expected_incidence_2 = torch.tensor(\n",
-    "            [\n",
-    "                [0.0, 0.0, 0.0, 1.0, 0.0, 1.0],\n",
-    "                [1.0, 0.0, 0.0, 0.0, 1.0, 1.0],\n",
-    "                [0.0, 0.0, 0.0, 1.0, 1.0, 0.0],\n",
-    "                [1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 1.0],\n",
-    "                [0.0, 0.0, 0.0, 1.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 1.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 1.0, 0.0],\n",
-    "                [0.0, 1.0, 1.0, 0.0, 0.0, 0.0],\n",
-    "                [1.0, 1.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 1.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 1.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 1.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            expected_incidence_2 == lifted_data.incidence_2.to_dense()\n",
-    "        ).all(), \"Something is wrong with incidence_2.\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test = TestCellCycleLifting()\n",
-    "test.setup_method()\n",
-    "test.test_lift_topology()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "topo",
-   "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.11.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/notebooks/test_feature_lifting_dev.ipynb b/notebooks/test_feature_lifting_dev.ipynb
deleted file mode 100644
index 3568bd53..00000000
--- a/notebooks/test_feature_lifting_dev.ipynb
+++ /dev/null
@@ -1,358 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%load_ext autoreload\n",
-    "%autoreload 2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "PosixPath('/TopoBenchmarkX/TopoBenchmarkX')"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import rootutils\n",
-    "\n",
-    "rootutils.setup_root(\"./\", indicator=\".project-root\", pythonpath=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\"\"\"Test the message passing module.\"\"\"\n",
-    "\n",
-    "import rootutils\n",
-    "import torch\n",
-    "\n",
-    "from topobenchmarkx.data.load.loaders import manual_simple_graph\n",
-    "from topobenchmarkx.transforms.feature_liftings.feature_liftings import (\n",
-    "    ProjectionLifting,\n",
-    ")\n",
-    "from topobenchmarkx.transforms.liftings.graph2simplicial import (\n",
-    "    SimplicialCliqueLifting,\n",
-    ")\n",
-    "\n",
-    "\n",
-    "class TestProjectionLifting:\n",
-    "    \"\"\"Test the ProjectionLifting class.\"\"\"\n",
-    "\n",
-    "    def setup_method(self):\n",
-    "        # Load the graph\n",
-    "        self.data = manual_simple_graph()\n",
-    "\n",
-    "        # Initialize a lifting class\n",
-    "        self.lifting = SimplicialCliqueLifting(complex_dim=3)\n",
-    "        # Initialize the ProjectionLifting class\n",
-    "        self.feature_lifting = ProjectionLifting()\n",
-    "\n",
-    "    def test_lift_features(self):\n",
-    "        # Test the lift_features method\n",
-    "        lifted_data = self.lifting.forward(self.data.clone())\n",
-    "        del lifted_data.x_1\n",
-    "        del lifted_data.x_2\n",
-    "        del lifted_data.x_3\n",
-    "        lifted_data = self.feature_lifting.forward(lifted_data)\n",
-    "\n",
-    "        expected_x1 = torch.tensor(\n",
-    "            [\n",
-    "                [6.0],\n",
-    "                [11.0],\n",
-    "                [101.0],\n",
-    "                [5001.0],\n",
-    "                [15.0],\n",
-    "                [105.0],\n",
-    "                [60.0],\n",
-    "                [110.0],\n",
-    "                [510.0],\n",
-    "                [5010.0],\n",
-    "                [1050.0],\n",
-    "                [1500.0],\n",
-    "                [5500.0],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        expected_x2 = torch.tensor(\n",
-    "            [[32.0], [212.0], [222.0], [10022.0], [230.0], [11020.0]]\n",
-    "        )\n",
-    "\n",
-    "        expected_x3 = torch.tensor([[696.0]])\n",
-    "\n",
-    "        assert (\n",
-    "            expected_x1 == lifted_data.x_1\n",
-    "        ).all(), \"Something is wrong with the lifted features x_1.\"\n",
-    "        assert (\n",
-    "            expected_x2 == lifted_data.x_2\n",
-    "        ).all(), \"Something is wrong with the lifted features x_2.\"\n",
-    "        assert (\n",
-    "            expected_x3 == lifted_data.x_3\n",
-    "        ).all(), \"Something is wrong with the lifted features x_3.\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/usr/local/lib/python3.11/site-packages/scipy/sparse/_index.py:145: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil_matrix is more efficient.\n",
-      "  self._set_arrayXarray(i, j, x)\n"
-     ]
-    }
-   ],
-   "source": [
-    "test = TestProjectionLifting()\n",
-    "test.setup_method()\n",
-    "test.test_lift_features()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\"\"\"Test the message passing module.\"\"\"\n",
-    "\n",
-    "import rootutils\n",
-    "\n",
-    "from topobenchmarkx.transforms.feature_liftings.feature_liftings import (\n",
-    "    ConcatentionLifting,\n",
-    ")\n",
-    "\n",
-    "\n",
-    "class TestConcatentionLifting:\n",
-    "    \"\"\"Test the ConcatentionLifting class.\"\"\"\n",
-    "\n",
-    "    def setup_method(self):\n",
-    "        # Load the graph\n",
-    "        self.data = manual_simple_graph()\n",
-    "\n",
-    "        # Initialize a lifting class\n",
-    "        self.lifting = SimplicialCliqueLifting(complex_dim=3)\n",
-    "        # Initialize the ConcatentionLifting class\n",
-    "        self.feature_lifting = ConcatentionLifting()\n",
-    "\n",
-    "    def test_lift_features(self):\n",
-    "        # Test the lift_features method\n",
-    "        lifted_data = self.lifting.forward(self.data.clone())\n",
-    "        del lifted_data.x_1\n",
-    "        del lifted_data.x_2\n",
-    "        del lifted_data.x_3\n",
-    "        lifted_data = self.feature_lifting.forward(lifted_data)\n",
-    "\n",
-    "        expected_x1 = torch.tensor(\n",
-    "            [\n",
-    "                [1.0, 5.0],\n",
-    "                [1.0, 10.0],\n",
-    "                [1.0, 100.0],\n",
-    "                [1.0, 5000.0],\n",
-    "                [5.0, 10.0],\n",
-    "                [5.0, 100.0],\n",
-    "                [10.0, 50.0],\n",
-    "                [10.0, 100.0],\n",
-    "                [10.0, 500.0],\n",
-    "                [10.0, 5000.0],\n",
-    "                [50.0, 1000.0],\n",
-    "                [500.0, 1000.0],\n",
-    "                [500.0, 5000.0],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        expected_x2 = torch.tensor(\n",
-    "            [\n",
-    "                [1.0, 5.0, 1.0, 10.0, 5.0, 10.0],\n",
-    "                [1.0, 5.0, 1.0, 100.0, 5.0, 100.0],\n",
-    "                [1.0, 10.0, 1.0, 100.0, 10.0, 100.0],\n",
-    "                [1.0, 10.0, 1.0, 5000.0, 10.0, 5000.0],\n",
-    "                [5.0, 10.0, 5.0, 100.0, 10.0, 100.0],\n",
-    "                [10.0, 500.0, 10.0, 5000.0, 500.0, 5000.0],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        expected_x3 = torch.tensor(\n",
-    "            [\n",
-    "                [\n",
-    "                    1.0,\n",
-    "                    5.0,\n",
-    "                    1.0,\n",
-    "                    10.0,\n",
-    "                    5.0,\n",
-    "                    10.0,\n",
-    "                    1.0,\n",
-    "                    5.0,\n",
-    "                    1.0,\n",
-    "                    100.0,\n",
-    "                    5.0,\n",
-    "                    100.0,\n",
-    "                    1.0,\n",
-    "                    10.0,\n",
-    "                    1.0,\n",
-    "                    100.0,\n",
-    "                    10.0,\n",
-    "                    100.0,\n",
-    "                    5.0,\n",
-    "                    10.0,\n",
-    "                    5.0,\n",
-    "                    100.0,\n",
-    "                    10.0,\n",
-    "                    100.0,\n",
-    "                ]\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            expected_x1 == lifted_data.x_1\n",
-    "        ).all(), \"Something is wrong with the lifted features x_1.\"\n",
-    "        assert (\n",
-    "            expected_x2 == lifted_data.x_2\n",
-    "        ).all(), \"Something is wrong with the lifted features x_2.\"\n",
-    "        assert (\n",
-    "            expected_x3 == lifted_data.x_3\n",
-    "        ).all(), \"Something is wrong with the lifted features x_3.\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test = TestConcatentionLifting()\n",
-    "test.setup_method()\n",
-    "test.test_lift_features()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\"\"\"Test the message passing module.\"\"\"\n",
-    "\n",
-    "import rootutils\n",
-    "\n",
-    "from topobenchmarkx.transforms.feature_liftings.feature_liftings import (\n",
-    "    SetLifting,\n",
-    ")\n",
-    "\n",
-    "\n",
-    "class TestSetLifting:\n",
-    "    \"\"\"Test the SetLifting class.\"\"\"\n",
-    "\n",
-    "    def setup_method(self):\n",
-    "        # Load the graph\n",
-    "        self.data = manual_simple_graph()\n",
-    "\n",
-    "        # Initialize a lifting class\n",
-    "        self.lifting = SimplicialCliqueLifting(complex_dim=3)\n",
-    "        # Initialize the SetLifting class\n",
-    "        self.feature_lifting = SetLifting()\n",
-    "\n",
-    "    def test_lift_features(self):\n",
-    "        # Test the lift_features method\n",
-    "        lifted_data = self.lifting.forward(self.data.clone())\n",
-    "        del lifted_data.x_1\n",
-    "        del lifted_data.x_2\n",
-    "        del lifted_data.x_3\n",
-    "        lifted_data = self.feature_lifting.forward(lifted_data)\n",
-    "\n",
-    "        expected_x1 = torch.tensor(\n",
-    "            [\n",
-    "                [0, 1],\n",
-    "                [0, 2],\n",
-    "                [0, 4],\n",
-    "                [0, 7],\n",
-    "                [1, 2],\n",
-    "                [1, 4],\n",
-    "                [2, 3],\n",
-    "                [2, 4],\n",
-    "                [2, 5],\n",
-    "                [2, 7],\n",
-    "                [3, 6],\n",
-    "                [5, 6],\n",
-    "                [5, 7],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        expected_x2 = torch.tensor(\n",
-    "            [[0, 1, 2], [0, 1, 4], [0, 2, 4], [0, 2, 7], [1, 2, 4], [2, 5, 7]]\n",
-    "        )\n",
-    "\n",
-    "        expected_x3 = torch.tensor([[0, 1, 2, 4]])\n",
-    "\n",
-    "        assert (\n",
-    "            expected_x1 == lifted_data.x_1\n",
-    "        ).all(), \"Something is wrong with the lifted features x_1.\"\n",
-    "        assert (\n",
-    "            expected_x2 == lifted_data.x_2\n",
-    "        ).all(), \"Something is wrong with the lifted features x_2.\"\n",
-    "        assert (\n",
-    "            expected_x3 == lifted_data.x_3\n",
-    "        ).all(), \"Something is wrong with the lifted features x_3.\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test = TestSetLifting()\n",
-    "test.setup_method()\n",
-    "test.test_lift_features()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "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.11.3"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/notebooks/test_hypergraph_lifting_dev.ipynb b/notebooks/test_hypergraph_lifting_dev.ipynb
deleted file mode 100644
index d8d59e26..00000000
--- a/notebooks/test_hypergraph_lifting_dev.ipynb
+++ /dev/null
@@ -1,224 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%load_ext autoreload\n",
-    "%autoreload 2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\"\"\"Test the message passing module.\"\"\"\n",
-    "\n",
-    "import rootutils\n",
-    "import torch\n",
-    "\n",
-    "rootutils.setup_root(\"./\", indicator=\".project-root\", pythonpath=True)\n",
-    "from topobenchmarkx.data.load.loaders import manual_graph\n",
-    "from topobenchmarkx.transforms.liftings.graph2hypergraph import (\n",
-    "    HypergraphKHopLifting,\n",
-    "    HypergraphKNNLifting,\n",
-    ")\n",
-    "\n",
-    "\n",
-    "class TestHypergraphKHopLifting:\n",
-    "    \"\"\"Test the HypergraphKHopLifting class.\"\"\"\n",
-    "\n",
-    "    def setup_method(self):\n",
-    "        # Load the graph\n",
-    "        self.data = manual_graph()\n",
-    "\n",
-    "        # Initialise the HypergraphKHopLifting class\n",
-    "        self.lifting_k1 = HypergraphKHopLifting(k_value=1)\n",
-    "        self.lifting_k2 = HypergraphKHopLifting(k_value=2)\n",
-    "\n",
-    "    def test_lift_topology(self):\n",
-    "        # Test the lift_topology method\n",
-    "        lifted_data_k1 = self.lifting_k1.forward(self.data.clone())\n",
-    "\n",
-    "        expected_n_hyperedges = 9\n",
-    "\n",
-    "        expected_incidence_1 = torch.tensor(\n",
-    "            [\n",
-    "                [1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0],\n",
-    "                [1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0],\n",
-    "                [1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0],\n",
-    "                [1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0],\n",
-    "                [0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0],\n",
-    "                [1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            expected_incidence_1 == lifted_data_k1.incidence_hyperedges.to_dense()\n",
-    "        ).all(), \"Something is wrong with incidence_hyperedges (k=1).\"\n",
-    "        assert (\n",
-    "            expected_n_hyperedges == lifted_data_k1.num_hyperedges\n",
-    "        ), \"Something is wrong with the number of hyperedges (k=1).\"\n",
-    "\n",
-    "        lifted_data_k2 = self.lifting_k2.forward(self.data.clone())\n",
-    "\n",
-    "        expected_n_hyperedges = 9\n",
-    "\n",
-    "        expected_incidence_1 = torch.tensor(\n",
-    "            [\n",
-    "                [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0],\n",
-    "                [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0],\n",
-    "                [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],\n",
-    "                [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0],\n",
-    "                [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0],\n",
-    "                [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],\n",
-    "                [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],\n",
-    "                [0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0],\n",
-    "                [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            expected_incidence_1 == lifted_data_k2.incidence_hyperedges.to_dense()\n",
-    "        ).all(), \"Something is wrong with incidence_hyperedges (k=2).\"\n",
-    "        assert (\n",
-    "            expected_n_hyperedges == lifted_data_k2.num_hyperedges\n",
-    "        ), \"Something is wrong with the number of hyperedges (k=2).\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test = TestHypergraphKHopLifting()\n",
-    "test.setup_method()\n",
-    "test.test_lift_topology()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\"\"\"Test the message passing module.\"\"\"\n",
-    "\n",
-    "import rootutils\n",
-    "\n",
-    "rootutils.setup_root(\"./\", indicator=\".project-root\", pythonpath=True)\n",
-    "\n",
-    "\n",
-    "class TestHypergraphKNNLifting:\n",
-    "    \"\"\"Test the HypergraphKNNLifting class.\"\"\"\n",
-    "\n",
-    "    def setup_method(self):\n",
-    "        # Load the graph\n",
-    "        self.data = manual_graph()\n",
-    "\n",
-    "        # Initialise the HypergraphKNNLifting class\n",
-    "        self.lifting_k2 = HypergraphKNNLifting(k_value=2, loop=True)\n",
-    "        self.lifting_k3 = HypergraphKNNLifting(k_value=3, loop=True)\n",
-    "\n",
-    "    def test_lift_topology(self):\n",
-    "        # Test the lift_topology method\n",
-    "        lifted_data_k2 = self.lifting_k2.forward(self.data.clone())\n",
-    "\n",
-    "        expected_n_hyperedges = 9\n",
-    "\n",
-    "        expected_incidence_1 = torch.tensor(\n",
-    "            [\n",
-    "                [1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            expected_incidence_1 == lifted_data_k2.incidence_hyperedges.to_dense()\n",
-    "        ).all(), \"Something is wrong with incidence_hyperedges (k=2).\"\n",
-    "        assert (\n",
-    "            expected_n_hyperedges == lifted_data_k2.num_hyperedges\n",
-    "        ), \"Something is wrong with the number of hyperedges (k=2).\"\n",
-    "\n",
-    "        lifted_data_k3 = self.lifting_k3.forward(self.data.clone())\n",
-    "\n",
-    "        expected_n_hyperedges = 9\n",
-    "\n",
-    "        expected_incidence_1 = torch.tensor(\n",
-    "            [\n",
-    "                [1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            expected_incidence_1 == lifted_data_k3.incidence_hyperedges.to_dense()\n",
-    "        ).all(), \"Something is wrong with incidence_hyperedges (k=3).\"\n",
-    "        assert (\n",
-    "            expected_n_hyperedges == lifted_data_k3.num_hyperedges\n",
-    "        ), \"Something is wrong with the number of hyperedges (k=3).\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test = TestHypergraphKNNLifting()\n",
-    "test.setup_method()\n",
-    "test.test_lift_topology()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "topo",
-   "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.11.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/notebooks/test_simplicialclique_dev.ipynb b/notebooks/test_simplicialclique_dev.ipynb
deleted file mode 100644
index 5f391b61..00000000
--- a/notebooks/test_simplicialclique_dev.ipynb
+++ /dev/null
@@ -1,1982 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%load_ext autoreload\n",
-    "%autoreload 2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\"\"\"Test the message passing module.\"\"\"\n",
-    "\n",
-    "import rootutils\n",
-    "import torch\n",
-    "\n",
-    "rootutils.setup_root(\"./\", indicator=\".project-root\", pythonpath=True)\n",
-    "from topobenchmarkx.data.load.loaders import manual_simple_graph\n",
-    "from topobenchmarkx.transforms.liftings.graph2simplicial import (\n",
-    "    SimplicialCliqueLifting,\n",
-    ")\n",
-    "\n",
-    "\n",
-    "class TestSimplicialCliqueLifting:\n",
-    "    \"\"\"Test the SimplicialCliqueLifting class.\"\"\"\n",
-    "\n",
-    "    def setup_method(self):\n",
-    "        # Load the graph\n",
-    "        self.data = manual_simple_graph()\n",
-    "\n",
-    "        # Initialise the SimplicialCliqueLifting class\n",
-    "        self.lifting_signed = SimplicialCliqueLifting(complex_dim=3, signed=True)\n",
-    "        self.lifting_unsigned = SimplicialCliqueLifting(complex_dim=3, signed=False)\n",
-    "\n",
-    "    def test_lift_topology(self):\n",
-    "        # Test the lift_topology method\n",
-    "        lifted_data_signed = self.lifting_signed.forward(self.data.clone())\n",
-    "        lifted_data_unsigned = self.lifting_unsigned.forward(self.data.clone())\n",
-    "\n",
-    "        expected_incidence_1 = torch.tensor(\n",
-    "            [\n",
-    "                [-1.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [1.0, 0.0, 0.0, 0.0, -1.0, -1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 1.0, 0.0, 0.0, 1.0, 0.0, -1.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, -1.0, -1.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            abs(expected_incidence_1) == lifted_data_unsigned.incidence_1.to_dense()\n",
-    "        ).all(), \"Something is wrong with unsigned incidence_1 (nodes to edges).\"\n",
-    "        assert (\n",
-    "            expected_incidence_1 == lifted_data_signed.incidence_1.to_dense()\n",
-    "        ).all(), \"Something is wrong with signed incidence_1 (nodes to edges).\"\n",
-    "\n",
-    "        expected_incidence_2 = torch.tensor(\n",
-    "            [\n",
-    "                [1.0, 1.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [-1.0, 0.0, 1.0, 1.0, 0.0, 0.0],\n",
-    "                [0.0, -1.0, -1.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, -1.0, 0.0, 0.0],\n",
-    "                [1.0, 0.0, 0.0, 0.0, 1.0, 0.0],\n",
-    "                [0.0, 1.0, 0.0, 0.0, -1.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 1.0, 0.0, 1.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 1.0],\n",
-    "                [0.0, 0.0, 0.0, 1.0, 0.0, -1.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
-    "                [0.0, 0.0, 0.0, 0.0, 0.0, 1.0],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            abs(expected_incidence_2) == lifted_data_unsigned.incidence_2.to_dense()\n",
-    "        ).all(), \"Something is wrong with unsigned incidence_2 (edges to triangles).\"\n",
-    "        assert (\n",
-    "            expected_incidence_2 == lifted_data_signed.incidence_2.to_dense()\n",
-    "        ).all(), \"Something is wrong with signed incidence_2 (edges to triangles).\"\n",
-    "\n",
-    "        expected_incidence_3 = torch.tensor(\n",
-    "            [[-1.0], [1.0], [-1.0], [0.0], [1.0], [0.0]]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            abs(expected_incidence_3) == lifted_data_unsigned.incidence_3.to_dense()\n",
-    "        ).all(), (\n",
-    "            \"Something is wrong with unsigned incidence_3 (triangles to tetrahedrons).\"\n",
-    "        )\n",
-    "        assert (\n",
-    "            expected_incidence_3 == lifted_data_signed.incidence_3.to_dense()\n",
-    "        ).all(), (\n",
-    "            \"Something is wrong with signed incidence_3 (triangles to tetrahedrons).\"\n",
-    "        )\n",
-    "\n",
-    "    def test_lifted_features_signed(self):\n",
-    "        # Test the lift_features method for signed case\n",
-    "        lifted_data = self.lifting_signed.forward(self.data)\n",
-    "\n",
-    "        expected_features_1 = torch.tensor(\n",
-    "            [\n",
-    "                [4],\n",
-    "                [9],\n",
-    "                [99],\n",
-    "                [4999],\n",
-    "                [5],\n",
-    "                [95],\n",
-    "                [40],\n",
-    "                [90],\n",
-    "                [490],\n",
-    "                [4990],\n",
-    "                [950],\n",
-    "                [500],\n",
-    "                [4500],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            expected_features_1 == lifted_data.x_1\n",
-    "        ).all(), \"Something is wrong with x_1 features.\"\n",
-    "\n",
-    "        expected_features_2 = torch.tensor([[0.0], [0.0], [0.0], [0.0], [0.0], [0.0]])\n",
-    "\n",
-    "        assert (\n",
-    "            expected_features_2 == lifted_data.x_2\n",
-    "        ).all(), \"Something is wrong with x_2 features.\"\n",
-    "\n",
-    "        excepted_features_3 = torch.tensor([[0.0]])\n",
-    "\n",
-    "        assert (\n",
-    "            excepted_features_3 == lifted_data.x_3\n",
-    "        ).all(), \"Something is wrong with x_3 features.\"\n",
-    "\n",
-    "    def test_lifted_features_unsigned(self):\n",
-    "        # Test the lift_features method for unsigned case\n",
-    "        lifted_data = self.lifting_unsigned.forward(self.data)\n",
-    "\n",
-    "        expected_features_1 = torch.tensor(\n",
-    "            [\n",
-    "                [6.0],\n",
-    "                [11.0],\n",
-    "                [101.0],\n",
-    "                [5001.0],\n",
-    "                [15.0],\n",
-    "                [105.0],\n",
-    "                [60.0],\n",
-    "                [110.0],\n",
-    "                [510.0],\n",
-    "                [5010.0],\n",
-    "                [1050.0],\n",
-    "                [1500.0],\n",
-    "                [5500.0],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            expected_features_1 == lifted_data.x_1\n",
-    "        ).all(), \"Something is wrong with x_1 features.\"\n",
-    "\n",
-    "        expected_features_2 = torch.tensor(\n",
-    "            [[32.0], [212.0], [222.0], [10022.0], [230.0], [11020.0]]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            expected_features_2 == lifted_data.x_2\n",
-    "        ).all(), \"Something is wrong with x_2 features.\"\n",
-    "\n",
-    "        excepted_features_3 = torch.tensor([[696.0]])\n",
-    "\n",
-    "        assert (\n",
-    "            excepted_features_3 == lifted_data.x_3\n",
-    "        ).all(), \"Something is wrong with x_3 features.\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/lev/miniconda3/envs/topo/lib/python3.11/site-packages/scipy/sparse/_index.py:145: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil_matrix is more efficient.\n",
-      "  self._set_arrayXarray(i, j, x)\n"
-     ]
-    }
-   ],
-   "source": [
-    "test = TestSimplicialCliqueLifting()\n",
-    "test.setup_method()\n",
-    "test.test_lift_topology()\n",
-    "test.test_lifted_features_signed()\n",
-    "test.test_lifted_features_unsigned()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\"\"\"Test the message passing module.\"\"\"\n",
-    "\n",
-    "import rootutils\n",
-    "\n",
-    "rootutils.setup_root(\"./\", indicator=\".project-root\", pythonpath=True)\n",
-    "from topobenchmarkx.transforms.liftings.graph2simplicial import (\n",
-    "    SimplicialKHopLifting,\n",
-    ")\n",
-    "\n",
-    "\n",
-    "class TestSimplicialKHopLifting:\n",
-    "    \"\"\"Test the SimplicialKHopLifting class.\"\"\"\n",
-    "\n",
-    "    def setup_method(self):\n",
-    "        # Load the graph\n",
-    "        self.data = manual_simple_graph()\n",
-    "\n",
-    "        # Initialise the SimplicialKHopLifting class\n",
-    "        self.lifting_signed = SimplicialKHopLifting(complex_dim=4, signed=True)\n",
-    "        self.lifting_unsigned = SimplicialKHopLifting(\n",
-    "            complex_dim=4, signed=False\n",
-    "        )\n",
-    "\n",
-    "    def test_lift_topology(self):\n",
-    "        # Test the lift_topology method\n",
-    "        lifted_data_signed = self.lifting_signed.forward(self.data.clone())\n",
-    "        lifted_data_unsigned = self.lifting_unsigned.forward(self.data.clone())\n",
-    "        expected_incidence_1 = torch.tensor(\n",
-    "            [\n",
-    "                [\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                ],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            abs(expected_incidence_1) == lifted_data_unsigned.incidence_1.to_dense()\n",
-    "        ).all(), \"Something is wrong with unsigned incidence_1 (nodes to edges).\"\n",
-    "        assert (\n",
-    "            expected_incidence_1 == lifted_data_signed.incidence_1.to_dense()\n",
-    "        ).all(), \"Something is wrong with signed incidence_1 (nodes to edges).\"\n",
-    "\n",
-    "        expected_incidence_2 = torch.tensor(\n",
-    "            [\n",
-    "                [\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    -1.0,\n",
-    "                    0.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    1.0,\n",
-    "                    -1.0,\n",
-    "                ],\n",
-    "                [\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    0.0,\n",
-    "                    1.0,\n",
-    "                ],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            abs(expected_incidence_2) == lifted_data_unsigned.incidence_2.to_dense()\n",
-    "        ).all(), \"Something is wrong with unsigned incidence_2 (edges to triangles).\"\n",
-    "        assert (\n",
-    "            expected_incidence_2 == lifted_data_signed.incidence_2.to_dense()\n",
-    "        ).all(), \"Something is wrong with signed incidence_2 (edges to triangles).\"\n",
-    "\n",
-    "    def test_lifted_features_signed(self):\n",
-    "        # Test the lift_features method for signed case\n",
-    "        lifted_data = self.lifting_signed.forward(self.data)\n",
-    "\n",
-    "        expected_features_1 = torch.tensor(\n",
-    "            [\n",
-    "                [4.0000e00],\n",
-    "                [9.0000e00],\n",
-    "                [4.9000e01],\n",
-    "                [9.9000e01],\n",
-    "                [4.9900e02],\n",
-    "                [4.9990e03],\n",
-    "                [5.0000e00],\n",
-    "                [4.5000e01],\n",
-    "                [9.5000e01],\n",
-    "                [4.9500e02],\n",
-    "                [4.9950e03],\n",
-    "                [4.0000e01],\n",
-    "                [9.0000e01],\n",
-    "                [4.9000e02],\n",
-    "                [9.9000e02],\n",
-    "                [4.9900e03],\n",
-    "                [5.0000e01],\n",
-    "                [4.5000e02],\n",
-    "                [9.5000e02],\n",
-    "                [4.9500e03],\n",
-    "                [4.0000e02],\n",
-    "                [4.9000e03],\n",
-    "                [5.0000e02],\n",
-    "                [4.5000e03],\n",
-    "                [4.0000e03],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            expected_features_1 == lifted_data.x_1\n",
-    "        ).all(), \"Something is wrong with x_1 features.\"\n",
-    "\n",
-    "        expected_features_2 = torch.tensor(\n",
-    "            [\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "                [0.0],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            expected_features_2 == lifted_data.x_2\n",
-    "        ).all(), \"Something is wrong with x_2 features.\"\n",
-    "\n",
-    "    def test_lifted_features_unsigned(self):\n",
-    "        # Test the lift_features method for unsigned case\n",
-    "        lifted_data = self.lifting_unsigned.forward(self.data)\n",
-    "\n",
-    "        expected_features_1 = torch.tensor(\n",
-    "            [\n",
-    "                [6.0],  # (0,1)\n",
-    "                [11.0],  # (0,2)\n",
-    "                [51.0],  # (0,3)\n",
-    "                [101.0],  # (0,4)\n",
-    "                [501.0],  # (0,5)\n",
-    "                [5001.0],  # (0,7)\n",
-    "                [15.0],  # (1,2)\n",
-    "                [55.0],  # (1,3)\n",
-    "                [105.0],  # ...\n",
-    "                [505.0],\n",
-    "                [5005.0],\n",
-    "                [60.0],\n",
-    "                [110.0],\n",
-    "                [510.0],\n",
-    "                [1010.0],\n",
-    "                [5010.0],\n",
-    "                [150.0],\n",
-    "                [550.0],\n",
-    "                [1050.0],\n",
-    "                [5050.0],\n",
-    "                [600.0],\n",
-    "                [5100.0],\n",
-    "                [1500.0],\n",
-    "                [5500.0],\n",
-    "                [6000.0],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            expected_features_1 == lifted_data.x_1\n",
-    "        ).all(), \"Something is wrong with x_1 features.\"\n",
-    "\n",
-    "        expected_features_2 = torch.tensor(\n",
-    "            [\n",
-    "                [32.0],  # (0,1,2)\n",
-    "                [112.0],  # (0,1,3)\n",
-    "                [212.0],  # ...\n",
-    "                [1012.0],\n",
-    "                [10012.0],\n",
-    "                [122.0],\n",
-    "                [222.0],\n",
-    "                [1022.0],\n",
-    "                [10022.0],\n",
-    "                [302.0],\n",
-    "                [1102.0],\n",
-    "                [10102.0],\n",
-    "                [1202.0],\n",
-    "                [10202.0],\n",
-    "                [11002.0],\n",
-    "                [130.0],\n",
-    "                [230.0],\n",
-    "                [1030.0],\n",
-    "                [10030.0],\n",
-    "                [310.0],\n",
-    "                [1110.0],\n",
-    "                [10110.0],\n",
-    "                [1210.0],\n",
-    "                [10210.0],\n",
-    "                [11010.0],\n",
-    "                [320.0],\n",
-    "                [1120.0],\n",
-    "                [2120.0],\n",
-    "                [10120.0],\n",
-    "                [1220.0],\n",
-    "                [10220.0],\n",
-    "                [3020.0],\n",
-    "                [11020.0],\n",
-    "                [12020.0],\n",
-    "                [1300.0],\n",
-    "                [10300.0],\n",
-    "                [3100.0],\n",
-    "                [11100.0],\n",
-    "                [11200.0],\n",
-    "                [13000.0],\n",
-    "            ]\n",
-    "        )\n",
-    "\n",
-    "        assert (\n",
-    "            expected_features_2 == lifted_data.x_2\n",
-    "        ).all(), \"Something is wrong with x_2 features.\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/lev/miniconda3/envs/topo/lib/python3.11/site-packages/scipy/sparse/_index.py:145: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil_matrix is more efficient.\n",
-      "  self._set_arrayXarray(i, j, x)\n"
-     ]
-    }
-   ],
-   "source": [
-    "test = TestSimplicialKHopLifting()\n",
-    "test.setup_method()\n",
-    "test.test_lift_topology()\n",
-    "test.test_lifted_features_signed()\n",
-    "test.test_lifted_features_unsigned()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data = test.lifting_signed(test.data)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "torch.Size([36, 0])"
-      ]
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "data.incidence_4.to_dense().shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 800x800 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import networkx as nx\n",
-    "import numpy as np\n",
-    "from matplotlib.patches import Polygon\n",
-    "\n",
-    "# Collect vertices\n",
-    "vertices = [i for i in range(data.x.shape[0])]\n",
-    "\n",
-    "# Collect edges\n",
-    "edges = []\n",
-    "edge_mapper = {}\n",
-    "for edge_idx, edge in enumerate(abs(data.incidence_1.to_dense().T)):\n",
-    "    node_idxs = torch.where(edge != 0)[0].numpy()\n",
-    "\n",
-    "    edges.append(torch.where(edge != 0)[0].numpy())\n",
-    "    edge_mapper[edge_idx] = sorted(node_idxs)\n",
-    "\n",
-    "\n",
-    "# Collect triangles\n",
-    "triangles = []\n",
-    "triangle_mapper = {}\n",
-    "for triangle_idx, triangle in enumerate(abs(data.incidence_2.to_dense().T)):\n",
-    "    edge_idxs = torch.where(triangle != 0)[0].numpy()\n",
-    "\n",
-    "    nodes = []\n",
-    "    for edge_idx in edge_idxs:\n",
-    "        nodes += edge_mapper[edge_idx]\n",
-    "\n",
-    "    triangle_mapper[triangle_idx] = {\n",
-    "        \"edge_idxs\": sorted(edge_idxs),\n",
-    "        \"node_idxs\": sorted(list(set(nodes))),\n",
-    "    }\n",
-    "\n",
-    "    triangles.append(sorted(list(set(nodes))))\n",
-    "\n",
-    "# Collect tetraherdons\n",
-    "tetrahedrons = []\n",
-    "tetrahedron_mapper = {}\n",
-    "for tetrahedron_idx, tetrahedron in enumerate(abs(data.incidence_3.to_dense().T)):\n",
-    "    triangle_idxs = torch.where(tetrahedron != 0)[0].numpy()\n",
-    "\n",
-    "    nodes = []\n",
-    "    edges_in_tetrahedrons = []\n",
-    "    for triangle_idx in triangle_idxs:\n",
-    "        nodes += triangle_mapper[triangle_idx][\"node_idxs\"]\n",
-    "        edges_in_tetrahedrons += triangle_mapper[triangle_idx][\"edge_idxs\"]\n",
-    "\n",
-    "    tetrahedron_mapper[tetrahedron_idx] = {\n",
-    "        \"triangle_idxs\": sorted(triangle_idxs),\n",
-    "        \"edge_idxs\": sorted(list(set(edges_in_tetrahedrons))),\n",
-    "        \"node_idxs\": sorted(list(set(nodes))),\n",
-    "    }\n",
-    "\n",
-    "    tetrahedrons.append(sorted(list(set(nodes))))\n",
-    "\n",
-    "edges = np.array(edges)\n",
-    "triangles = np.array(triangles)\n",
-    "tetrahedrons = np.array(tetrahedrons)\n",
-    "\n",
-    "# Create a graph\n",
-    "G = nx.Graph()\n",
-    "\n",
-    "# Add vertices\n",
-    "G.add_nodes_from(vertices)\n",
-    "\n",
-    "# Add edges\n",
-    "G.add_edges_from(edges)\n",
-    "\n",
-    "# Plot the graph with edge indices using other layout\n",
-    "pos = nx.spring_layout(G, seed=42)\n",
-    "# pos[3] = np.array([0.15539556, 0.25])\n",
-    "\n",
-    "# Draw the graph with labels\n",
-    "nx.draw(\n",
-    "    G,\n",
-    "    pos,\n",
-    "    labels={i: f\"v_{i}\" for i in G.nodes()},\n",
-    "    node_size=500,\n",
-    "    node_color=\"skyblue\",\n",
-    "    font_size=12,\n",
-    "    edge_color=\"black\",\n",
-    "    width=1,\n",
-    "    linewidths=1,\n",
-    "    alpha=0.9,\n",
-    ")\n",
-    "\n",
-    "# Color the faces (triangles) of the graph\n",
-    "face_color_map = {\n",
-    "    0: \"pink\",\n",
-    "    1: \"gray\",\n",
-    "    2: \"blue\",\n",
-    "    3: \"blue\",\n",
-    "    4: \"orange\",\n",
-    "    5: \"purple\",\n",
-    "    6: \"red\",\n",
-    "    7: \"brown\",\n",
-    "    8: \"black\",\n",
-    "    9: \"gray\",\n",
-    "}\n",
-    "\n",
-    "for i, clique in enumerate(triangles):\n",
-    "    # Get the face color:\n",
-    "    # Calculate to how many tetrahedrons cique belongs\n",
-    "    # Then assign the color to the face\n",
-    "    counter = 0\n",
-    "    for tetrahedron in tetrahedrons:\n",
-    "        from itertools import combinations\n",
-    "\n",
-    "        for comb in combinations(tetrahedron, 3):\n",
-    "            if set(clique) == set(comb):\n",
-    "                counter += 1\n",
-    "\n",
-    "    polygon = [pos[v] for v in clique]\n",
-    "    poly = Polygon(\n",
-    "        polygon,\n",
-    "        closed=True,\n",
-    "        facecolor=face_color_map[counter],\n",
-    "        # edgecolor=\"pink\",\n",
-    "        alpha=0.3,\n",
-    "    )\n",
-    "    plt.gca().add_patch(poly)\n",
-    "\n",
-    "\n",
-    "# Draw edges with different color and thickness\n",
-    "nx.draw_networkx_edge_labels(\n",
-    "    G,\n",
-    "    pos,\n",
-    "    edge_labels={\n",
-    "        tuple(corr_nodes): f\"e_{edge_idx}\"\n",
-    "        for edge_idx, corr_nodes in edge_mapper.items()\n",
-    "    },\n",
-    "    font_color=\"red\",\n",
-    "    alpha=0.9,\n",
-    "    font_size=8,\n",
-    "    rotate=False,\n",
-    "    horizontalalignment=\"center\",\n",
-    "    verticalalignment=\"center\",\n",
-    ")\n",
-    "\n",
-    "\n",
-    "plt.title(\"Graph with cliques colored (9 vertices)\")\n",
-    "plt.axis(\"off\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{}"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "tetrahedron_mapper"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "topo",
-   "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.11.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}