molsim_ml.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ML for Gas Adsorption"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## -1. Only if you run this notebook on Colab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you use this notebook on Colab, please uncomment the lines below (remove the `#`) and execute the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import sys\n",
    "#!{sys.executable} -m pip install -U pandas-profiling[notebook]\n",
    "#!jupyter nbextension enable --py widgetsnbextension\n",
    "#!pip install --upgrade pandas sklearn holoviews bokeh plotly matplotlib\n",
    "#!wget https://raw.githubusercontent.com/kjappelbaum/ml_molsim/2022/descriptornames.py\n",
    "#!mkdir data\n",
    "#!cd data && wget https://github.com/kjappelbaum/ml_molsim/raw/2022/data/data.csv\n",
    "#!cd data && wget https://github.com/kjappelbaum/ml_molsim/raw/2022/data/features.csv\n",
    "# import os, holoviews as hv\n",
    "# os.environ['HV_DOC_HTML'] = 'true'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import packages we will need"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# basics\n",
    "import os\n",
    "import numpy as np\n",
    "import pprint as pp\n",
    "\n",
    "# pandas is used to read/process data\n",
    "import pandas as pd\n",
    "\n",
    "# machine learning dependencies\n",
    "# scaling of data\n",
    "from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler\n",
    "# train/test split\n",
    "from sklearn.model_selection import train_test_split\n",
    "# model selection\n",
    "from sklearn.model_selection import GridSearchCV, RandomizedSearchCV\n",
    "# the KRR model\n",
    "from sklearn.kernel_ridge import KernelRidge\n",
    "# linear model\n",
    "from sklearn.linear_model import LinearRegression\n",
    "# pipeline to streamline modeling pipelines\n",
    "from sklearn.pipeline import Pipeline\n",
    "# principal component analysis\n",
    "from sklearn.decomposition import PCA\n",
    "# polynomial kernel\n",
    "from sklearn.metrics.pairwise import polynomial_kernel\n",
    "# Dummy model as baseline\n",
    "from sklearn.dummy import DummyClassifier, DummyRegressor\n",
    "# Variance Threshold for feature selection\n",
    "from sklearn.feature_selection import VarianceThreshold, SelectFromModel\n",
    "# metrics to measure model performance\n",
    "from sklearn.metrics import (accuracy_score, precision_score, recall_score, f1_score,\n",
    "                             mean_absolute_error, mean_squared_error, max_error)\n",
    "\n",
    "# save/load models\n",
    "import joblib\n",
    "\n",
    "# For the permutation importance implementation\n",
    "from joblib import Parallel\n",
    "from joblib import delayed\n",
    "from sklearn.metrics import check_scoring\n",
    "from sklearn.utils import Bunch\n",
    "from sklearn.utils import check_random_state\n",
    "from sklearn.utils import check_array\n",
    "\n",
    "# plotting\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "from pymatviz.parity import hist_density\n",
    "\n",
    "RANDOM_SEED = 4242424242\n",
    "DATA_DIR = 'data'\n",
    "DATA_FILE = os.path.join(DATA_DIR, 'data.csv')\n",
    "\n",
    "np.random.seed(RANDOM_SEED)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "other_descriptors = [\"CellV [A^3]\"]\n",
    "\n",
    "geometric_descriptors = [\n",
    "    \"Di\",\n",
    "    \"Df\",\n",
    "    \"Dif\",\n",
    "    \"density [g/cm^3]\",\n",
    "    \"total_SA_volumetric\",\n",
    "    \"total_SA_gravimetric\",\n",
    "    \"total_POV_volumetric\",\n",
    "    \"total_POV_gravimetric\",\n",
    "]\n",
    "\n",
    "linker_descriptors = [\n",
    "    \"f-lig-chi-0\",\n",
    "    \"f-lig-chi-1\",\n",
    "    \"f-lig-chi-2\",\n",
    "    \"f-lig-chi-3\",\n",
    "    \"f-lig-Z-0\",\n",
    "    \"f-lig-Z-1\",\n",
    "    \"f-lig-Z-2\",\n",
    "    \"f-lig-Z-3\",\n",
    "    \"f-lig-I-0\",\n",
    "    \"f-lig-I-1\",\n",
    "    \"f-lig-I-2\",\n",
    "    \"f-lig-I-3\",\n",
    "    \"f-lig-T-0\",\n",
    "    \"f-lig-T-1\",\n",
    "    \"f-lig-T-2\",\n",
    "    \"f-lig-T-3\",\n",
    "    \"f-lig-S-0\",\n",
    "    \"f-lig-S-1\",\n",
    "    \"f-lig-S-2\",\n",
    "    \"f-lig-S-3\",\n",
    "    \"lc-chi-0-all\",\n",
    "    \"lc-chi-1-all\",\n",
    "    \"lc-chi-2-all\",\n",
    "    \"lc-chi-3-all\",\n",
    "    \"lc-Z-0-all\",\n",
    "    \"lc-Z-1-all\",\n",
    "    \"lc-Z-2-all\",\n",
    "    \"lc-Z-3-all\",\n",
    "    \"lc-I-0-all\",\n",
    "    \"lc-I-1-all\",\n",
    "    \"lc-I-2-all\",\n",
    "    \"lc-I-3-all\",\n",
    "    \"lc-T-0-all\",\n",
    "    \"lc-T-1-all\",\n",
    "    \"lc-T-2-all\",\n",
    "    \"lc-T-3-all\",\n",
    "    \"lc-S-0-all\",\n",
    "    \"lc-S-1-all\",\n",
    "    \"lc-S-2-all\",\n",
    "    \"lc-S-3-all\",\n",
    "    \"lc-alpha-0-all\",\n",
    "    \"lc-alpha-1-all\",\n",
    "    \"lc-alpha-2-all\",\n",
    "    \"lc-alpha-3-all\",\n",
    "    \"D_lc-chi-0-all\",\n",
    "    \"D_lc-chi-1-all\",\n",
    "    \"D_lc-chi-2-all\",\n",
    "    \"D_lc-chi-3-all\",\n",
    "    \"D_lc-Z-0-all\",\n",
    "    \"D_lc-Z-1-all\",\n",
    "    \"D_lc-Z-2-all\",\n",
    "    \"D_lc-Z-3-all\",\n",
    "    \"D_lc-I-0-all\",\n",
    "    \"D_lc-I-1-all\",\n",
    "    \"D_lc-I-2-all\",\n",
    "    \"D_lc-I-3-all\",\n",
    "    \"D_lc-T-0-all\",\n",
    "    \"D_lc-T-1-all\",\n",
    "    \"D_lc-T-2-all\",\n",
    "    \"D_lc-T-3-all\",\n",
    "    \"D_lc-S-0-all\",\n",
    "    \"D_lc-S-1-all\",\n",
    "    \"D_lc-S-2-all\",\n",
    "    \"D_lc-S-3-all\",\n",
    "    \"D_lc-alpha-0-all\",\n",
    "    \"D_lc-alpha-1-all\",\n",
    "    \"D_lc-alpha-2-all\",\n",
    "    \"D_lc-alpha-3-all\",\n",
    "]\n",
    "\n",
    "metalcenter_descriptors = [\n",
    "    \"mc_CRY-chi-0-all\",\n",
    "    \"mc_CRY-chi-1-all\",\n",
    "    \"mc_CRY-chi-2-all\",\n",
    "    \"mc_CRY-chi-3-all\",\n",
    "    \"mc_CRY-Z-0-all\",\n",
    "    \"mc_CRY-Z-1-all\",\n",
    "    \"mc_CRY-Z-2-all\",\n",
    "    \"mc_CRY-Z-3-all\",\n",
    "    \"mc_CRY-I-0-all\",\n",
    "    \"mc_CRY-I-1-all\",\n",
    "    \"mc_CRY-I-2-all\",\n",
    "    \"mc_CRY-I-3-all\",\n",
    "    \"mc_CRY-T-0-all\",\n",
    "    \"mc_CRY-T-1-all\",\n",
    "    \"mc_CRY-T-2-all\",\n",
    "    \"mc_CRY-T-3-all\",\n",
    "    \"mc_CRY-S-0-all\",\n",
    "    \"mc_CRY-S-1-all\",\n",
    "    \"mc_CRY-S-2-all\",\n",
    "    \"mc_CRY-S-3-all\",\n",
    "    \"D_mc_CRY-chi-0-all\",\n",
    "    \"D_mc_CRY-chi-1-all\",\n",
    "    \"D_mc_CRY-chi-2-all\",\n",
    "    \"D_mc_CRY-chi-3-all\",\n",
    "    \"D_mc_CRY-Z-0-all\",\n",
    "    \"D_mc_CRY-Z-1-all\",\n",
    "    \"D_mc_CRY-Z-2-all\",\n",
    "    \"D_mc_CRY-Z-3-all\",\n",
    "    \"D_mc_CRY-I-0-all\",\n",
    "    \"D_mc_CRY-I-1-all\",\n",
    "    \"D_mc_CRY-I-2-all\",\n",
    "    \"D_mc_CRY-I-3-all\",\n",
    "    \"D_mc_CRY-T-0-all\",\n",
    "    \"D_mc_CRY-T-1-all\",\n",
    "    \"D_mc_CRY-T-2-all\",\n",
    "    \"D_mc_CRY-T-3-all\",\n",
    "    \"D_mc_CRY-S-0-all\",\n",
    "    \"D_mc_CRY-S-1-all\",\n",
    "    \"D_mc_CRY-S-2-all\",\n",
    "    \"D_mc_CRY-S-3-all\",\n",
    "]\n",
    "\n",
    "functionalgroup_descriptors = [\n",
    "    \"func-chi-0-all\",\n",
    "    \"func-chi-1-all\",\n",
    "    \"func-chi-2-all\",\n",
    "    \"func-chi-3-all\",\n",
    "    \"func-Z-0-all\",\n",
    "    \"func-Z-1-all\",\n",
    "    \"func-Z-2-all\",\n",
    "    \"func-Z-3-all\",\n",
    "    \"func-I-0-all\",\n",
    "    \"func-I-1-all\",\n",
    "    \"func-I-2-all\",\n",
    "    \"func-I-3-all\",\n",
    "    \"func-T-0-all\",\n",
    "    \"func-T-1-all\",\n",
    "    \"func-T-2-all\",\n",
    "    \"func-T-3-all\",\n",
    "    \"func-S-0-all\",\n",
    "    \"func-S-1-all\",\n",
    "    \"func-S-2-all\",\n",
    "    \"func-S-3-all\",\n",
    "    \"func-alpha-0-all\",\n",
    "    \"func-alpha-1-all\",\n",
    "    \"func-alpha-2-all\",\n",
    "    \"func-alpha-3-all\",\n",
    "    \"D_func-chi-0-all\",\n",
    "    \"D_func-chi-1-all\",\n",
    "    \"D_func-chi-2-all\",\n",
    "    \"D_func-chi-3-all\",\n",
    "    \"D_func-Z-0-all\",\n",
    "    \"D_func-Z-1-all\",\n",
    "    \"D_func-Z-2-all\",\n",
    "    \"D_func-Z-3-all\",\n",
    "    \"D_func-I-0-all\",\n",
    "    \"D_func-I-1-all\",\n",
    "    \"D_func-I-2-all\",\n",
    "    \"D_func-I-3-all\",\n",
    "    \"D_func-T-0-all\",\n",
    "    \"D_func-T-1-all\",\n",
    "    \"D_func-T-2-all\",\n",
    "    \"D_func-T-3-all\",\n",
    "    \"D_func-S-0-all\",\n",
    "    \"D_func-S-1-all\",\n",
    "    \"D_func-S-2-all\",\n",
    "    \"D_func-S-3-all\",\n",
    "    \"D_func-alpha-0-all\",\n",
    "    \"D_func-alpha-1-all\",\n",
    "    \"D_func-alpha-2-all\",\n",
    "    \"D_func-alpha-3-all\",\n",
    "]\n",
    "\n",
    "\n",
    "summed_linker_descriptors = [\n",
    "    \"sum-f-lig-chi-0\",\n",
    "    \"sum-f-lig-chi-1\",\n",
    "    \"sum-f-lig-chi-2\",\n",
    "    \"sum-f-lig-chi-3\",\n",
    "    \"sum-f-lig-Z-0\",\n",
    "    \"sum-f-lig-Z-1\",\n",
    "    \"sum-f-lig-Z-2\",\n",
    "    \"sum-f-lig-Z-3\",\n",
    "    \"sum-f-lig-I-0\",\n",
    "    \"sum-f-lig-I-1\",\n",
    "    \"sum-f-lig-I-2\",\n",
    "    \"sum-f-lig-I-3\",\n",
    "    \"sum-f-lig-T-0\",\n",
    "    \"sum-f-lig-T-1\",\n",
    "    \"sum-f-lig-T-2\",\n",
    "    \"sum-f-lig-T-3\",\n",
    "    \"sum-f-lig-S-0\",\n",
    "    \"sum-f-lig-S-1\",\n",
    "    \"sum-f-lig-S-2\",\n",
    "    \"sum-f-lig-S-3\",\n",
    "    \"sum-lc-chi-0-all\",\n",
    "    \"sum-lc-chi-1-all\",\n",
    "    \"sum-lc-chi-2-all\",\n",
    "    \"sum-lc-chi-3-all\",\n",
    "    \"sum-lc-Z-0-all\",\n",
    "    \"sum-lc-Z-1-all\",\n",
    "    \"sum-lc-Z-2-all\",\n",
    "    \"sum-lc-Z-3-all\",\n",
    "    \"sum-lc-I-0-all\",\n",
    "    \"sum-lc-I-1-all\",\n",
    "    \"sum-lc-I-2-all\",\n",
    "    \"sum-lc-I-3-all\",\n",
    "    \"sum-lc-T-0-all\",\n",
    "    \"sum-lc-T-1-all\",\n",
    "    \"sum-lc-T-2-all\",\n",
    "    \"sum-lc-T-3-all\",\n",
    "    \"sum-lc-S-0-all\",\n",
    "    \"sum-lc-S-1-all\",\n",
    "    \"sum-lc-S-2-all\",\n",
    "    \"sum-lc-S-3-all\",\n",
    "    \"sum-lc-alpha-0-all\",\n",
    "    \"sum-lc-alpha-1-all\",\n",
    "    \"sum-lc-alpha-2-all\",\n",
    "    \"sum-lc-alpha-3-all\",\n",
    "    \"sum-D_lc-chi-0-all\",\n",
    "    \"sum-D_lc-chi-1-all\",\n",
    "    \"sum-D_lc-chi-2-all\",\n",
    "    \"sum-D_lc-chi-3-all\",\n",
    "    \"sum-D_lc-Z-0-all\",\n",
    "    \"sum-D_lc-Z-1-all\",\n",
    "    \"sum-D_lc-Z-2-all\",\n",
    "    \"sum-D_lc-Z-3-all\",\n",
    "    \"sum-D_lc-I-0-all\",\n",
    "    \"sum-D_lc-I-1-all\",\n",
    "    \"sum-D_lc-I-2-all\",\n",
    "    \"sum-D_lc-I-3-all\",\n",
    "    \"sum-D_lc-T-0-all\",\n",
    "    \"sum-D_lc-T-1-all\",\n",
    "    \"sum-D_lc-T-2-all\",\n",
    "    \"sum-D_lc-T-3-all\",\n",
    "    \"sum-D_lc-S-0-all\",\n",
    "    \"sum-D_lc-S-1-all\",\n",
    "    \"sum-D_lc-S-2-all\",\n",
    "    \"sum-D_lc-S-3-all\",\n",
    "    \"sum-D_lc-alpha-0-all\",\n",
    "    \"sum-D_lc-alpha-1-all\",\n",
    "    \"sum-D_lc-alpha-2-all\",\n",
    "    \"sum-D_lc-alpha-3-all\",\n",
    "]\n",
    "\n",
    "summed_metalcenter_descriptors = [\n",
    "    \"sum-mc_CRY-chi-0-all\",\n",
    "    \"sum-mc_CRY-chi-1-all\",\n",
    "    \"sum-mc_CRY-chi-2-all\",\n",
    "    \"sum-mc_CRY-chi-3-all\",\n",
    "    \"sum-mc_CRY-Z-0-all\",\n",
    "    \"sum-mc_CRY-Z-1-all\",\n",
    "    \"sum-mc_CRY-Z-2-all\",\n",
    "    \"sum-mc_CRY-Z-3-all\",\n",
    "    \"sum-mc_CRY-I-0-all\",\n",
    "    \"sum-mc_CRY-I-1-all\",\n",
    "    \"sum-mc_CRY-I-2-all\",\n",
    "    \"sum-mc_CRY-I-3-all\",\n",
    "    \"sum-mc_CRY-T-0-all\",\n",
    "    \"sum-mc_CRY-T-1-all\",\n",
    "    \"sum-mc_CRY-T-2-all\",\n",
    "    \"sum-mc_CRY-T-3-all\",\n",
    "    \"sum-mc_CRY-S-0-all\",\n",
    "    \"sum-mc_CRY-S-1-all\",\n",
    "    \"sum-mc_CRY-S-2-all\",\n",
    "    \"sum-mc_CRY-S-3-all\",\n",
    "    \"sum-D_mc_CRY-chi-0-all\",\n",
    "    \"sum-D_mc_CRY-chi-1-all\",\n",
    "    \"sum-D_mc_CRY-chi-2-all\",\n",
    "    \"sum-D_mc_CRY-chi-3-all\",\n",
    "    \"sum-D_mc_CRY-Z-0-all\",\n",
    "    \"sum-D_mc_CRY-Z-1-all\",\n",
    "    \"sum-D_mc_CRY-Z-2-all\",\n",
    "    \"sum-D_mc_CRY-Z-3-all\",\n",
    "    \"sum-D_mc_CRY-I-0-all\",\n",
    "    \"sum-D_mc_CRY-I-1-all\",\n",
    "    \"sum-D_mc_CRY-I-2-all\",\n",
    "    \"sum-D_mc_CRY-I-3-all\",\n",
    "    \"sum-D_mc_CRY-T-0-all\",\n",
    "    \"sum-D_mc_CRY-T-1-all\",\n",
    "    \"sum-D_mc_CRY-T-2-all\",\n",
    "    \"sum-D_mc_CRY-T-3-all\",\n",
    "    \"sum-D_mc_CRY-S-0-all\",\n",
    "    \"sum-D_mc_CRY-S-1-all\",\n",
    "    \"sum-D_mc_CRY-S-2-all\",\n",
    "    \"sum-D_mc_CRY-S-3-all\",\n",
    "]\n",
    "\n",
    "summed_functionalgroup_descriptors = [\n",
    "    \"sum-func-chi-0-all\",\n",
    "    \"sum-func-chi-1-all\",\n",
    "    \"sum-func-chi-2-all\",\n",
    "    \"sum-func-chi-3-all\",\n",
    "    \"sum-func-Z-0-all\",\n",
    "    \"sum-func-Z-1-all\",\n",
    "    \"sum-func-Z-2-all\",\n",
    "    \"sum-func-Z-3-all\",\n",
    "    \"sum-func-I-0-all\",\n",
    "    \"sum-func-I-1-all\",\n",
    "    \"sum-func-I-2-all\",\n",
    "    \"sum-func-I-3-all\",\n",
    "    \"sum-func-T-0-all\",\n",
    "    \"sum-func-T-1-all\",\n",
    "    \"sum-func-T-2-all\",\n",
    "    \"sum-func-T-3-all\",\n",
    "    \"sum-func-S-0-all\",\n",
    "    \"sum-func-S-1-all\",\n",
    "    \"sum-func-S-2-all\",\n",
    "    \"sum-func-S-3-all\",\n",
    "    \"sum-func-alpha-0-all\",\n",
    "    \"sum-func-alpha-1-all\",\n",
    "    \"sum-func-alpha-2-all\",\n",
    "    \"sum-func-alpha-3-all\",\n",
    "    \"sum-D_func-chi-0-all\",\n",
    "    \"sum-D_func-chi-1-all\",\n",
    "    \"sum-D_func-chi-2-all\",\n",
    "    \"sum-D_func-chi-3-all\",\n",
    "    \"sum-D_func-Z-0-all\",\n",
    "    \"sum-D_func-Z-1-all\",\n",
    "    \"sum-D_func-Z-2-all\",\n",
    "    \"sum-D_func-Z-3-all\",\n",
    "    \"sum-D_func-I-0-all\",\n",
    "    \"sum-D_func-I-1-all\",\n",
    "    \"sum-D_func-I-2-all\",\n",
    "    \"sum-D_func-I-3-all\",\n",
    "    \"sum-D_func-T-0-all\",\n",
    "    \"sum-D_func-T-1-all\",\n",
    "    \"sum-D_func-T-2-all\",\n",
    "    \"sum-D_func-T-3-all\",\n",
    "    \"sum-D_func-S-0-all\",\n",
    "    \"sum-D_func-S-1-all\",\n",
    "    \"sum-D_func-S-2-all\",\n",
    "    \"sum-D_func-S-3-all\",\n",
    "    \"sum-D_func-alpha-0-all\",\n",
    "    \"sum-D_func-alpha-1-all\",\n",
    "    \"sum-D_func-alpha-2-all\",\n",
    "    \"sum-D_func-alpha-3-all\",\n",
    "]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " $\\color{DarkBlue}{\\textsf{Short question}}$\n",
    "- We declared a global variable to fix the random seed (`RANDOM_SEED`). Why did we do this?  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hands-on Project: Carbon-dioxide uptake in MOFs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this exercise we will build a model that can predict the CO$_2$ uptake of metal-organic frameworks (MOFs), which are crystalline materials consisting of inorganic metal nodes linked by organic linkers.\n",
    "\n",
    "![MOF building principle](assets/mof_building_principle.png)\n",
    "\n",
    "There are two main **learning goals** for this exercise: \n",
    "\n",
    "1. Understand the typical workflow for machine learning in materials science. We will cover exploratory data analysis (EDA) and supervised learning (KRR).\n",
    "\n",
    "2. Get familiar with some Python packages that are useful for data analysis and visualization. \n",
    "\n",
    "At the end of the exercise, you will produce an interactive plot like the one below, comparing the predictions of your model against CO$_2$ computed with GCMC simulations.\n",
    "The histograms show the distributions of the errors on the training set (left) and on the test set (right).\n",
    "\n",
    "\n",
    "\n",
    "<img src=\"assets/result.gif\" alt=\"Parity interactive\" width=\"700\"/>\n",
    "\n",
    "This exercise requires a basic knowledge of Python, e.g. that you can write list comprehensions, and are able to read documentation of functions provided by Python packages.\n",
    "You will be asked to provide some function arguments (indicated by `#fillme` comments).\n",
    "\n",
    "You can execute all the following code cells by pressing SHIFT and ENTER and get informations about the functions by pressing TAB when you are between the parentheses (see the notes for more tips). \n",
    "\n",
    "Also the [sklearn documentation](https://scikit-learn.org/stable/user_guide.html) is a great source of reference with many explanations and examples.\n",
    "\n",
    "In pandas dataframe (df) you can select columns using their name by running `df[columnname]`. If at any point you think that the dataset is too large for your computer, you can select a subset using `df.sample()` or by making the test set larger in the train/test split (section 2). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Import the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(DATA_FILE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at the first few rows to see if everythings seems reasonable ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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>ASA [m^2/cm^3]</th>\n",
       "      <th>CellV [A^3]</th>\n",
       "      <th>Df</th>\n",
       "      <th>Di</th>\n",
       "      <th>Dif</th>\n",
       "      <th>NASA [m^2/cm^3]</th>\n",
       "      <th>POAV [cm^3/g]</th>\n",
       "      <th>POAVF</th>\n",
       "      <th>PONAV [cm^3/g]</th>\n",
       "      <th>PONAVF</th>\n",
       "      <th>...</th>\n",
       "      <th>pure_methane_widomHOA</th>\n",
       "      <th>pure_uptake_CO2_298.00_15000</th>\n",
       "      <th>pure_uptake_CO2_298.00_1600000</th>\n",
       "      <th>pure_uptake_methane_298.00_580000</th>\n",
       "      <th>pure_uptake_methane_298.00_6500000</th>\n",
       "      <th>logKH_CO2</th>\n",
       "      <th>logKH_CH4</th>\n",
       "      <th>CH4DC</th>\n",
       "      <th>CH4HPSTP</th>\n",
       "      <th>CH4LPSTP</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2329.01</td>\n",
       "      <td>1251.28</td>\n",
       "      <td>6.61256</td>\n",
       "      <td>8.87694</td>\n",
       "      <td>8.48668</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.818919</td>\n",
       "      <td>0.68874</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>-8.144317</td>\n",
       "      <td>0.111981</td>\n",
       "      <td>14.218595</td>\n",
       "      <td>1.680640</td>\n",
       "      <td>9.163066</td>\n",
       "      <td>-5.125451</td>\n",
       "      <td>-5.511444</td>\n",
       "      <td>175.569974</td>\n",
       "      <td>215.005044</td>\n",
       "      <td>39.435070</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1983.81</td>\n",
       "      <td>1254.01</td>\n",
       "      <td>5.80566</td>\n",
       "      <td>7.13426</td>\n",
       "      <td>7.13154</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.495493</td>\n",
       "      <td>0.58032</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>-10.208005</td>\n",
       "      <td>0.481625</td>\n",
       "      <td>9.312424</td>\n",
       "      <td>1.513152</td>\n",
       "      <td>5.908356</td>\n",
       "      <td>-4.502967</td>\n",
       "      <td>-5.505947</td>\n",
       "      <td>143.616349</td>\n",
       "      <td>193.059644</td>\n",
       "      <td>49.443295</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2259.13</td>\n",
       "      <td>1250.58</td>\n",
       "      <td>5.99131</td>\n",
       "      <td>8.01682</td>\n",
       "      <td>7.98933</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.728036</td>\n",
       "      <td>0.65710</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>-8.479801</td>\n",
       "      <td>0.401683</td>\n",
       "      <td>14.796071</td>\n",
       "      <td>1.569714</td>\n",
       "      <td>7.933198</td>\n",
       "      <td>-4.433968</td>\n",
       "      <td>-5.525707</td>\n",
       "      <td>160.238808</td>\n",
       "      <td>199.765744</td>\n",
       "      <td>39.526937</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1424.54</td>\n",
       "      <td>1249.27</td>\n",
       "      <td>4.73477</td>\n",
       "      <td>7.05822</td>\n",
       "      <td>7.05822</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.453157</td>\n",
       "      <td>0.47338</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>-12.615382</td>\n",
       "      <td>0.821747</td>\n",
       "      <td>10.816880</td>\n",
       "      <td>2.161833</td>\n",
       "      <td>6.710778</td>\n",
       "      <td>-4.135434</td>\n",
       "      <td>-5.297082</td>\n",
       "      <td>132.576623</td>\n",
       "      <td>195.582107</td>\n",
       "      <td>63.005483</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2228.31</td>\n",
       "      <td>1250.61</td>\n",
       "      <td>6.40783</td>\n",
       "      <td>8.35944</td>\n",
       "      <td>8.26946</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.700539</td>\n",
       "      <td>0.65092</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>-8.743404</td>\n",
       "      <td>0.258905</td>\n",
       "      <td>14.153999</td>\n",
       "      <td>1.653013</td>\n",
       "      <td>8.272621</td>\n",
       "      <td>-4.774301</td>\n",
       "      <td>-5.515219</td>\n",
       "      <td>171.601539</td>\n",
       "      <td>214.452966</td>\n",
       "      <td>42.851427</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 343 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   ASA [m^2/cm^3]  CellV [A^3]       Df       Di      Dif  NASA [m^2/cm^3]  \\\n",
       "0         2329.01      1251.28  6.61256  8.87694  8.48668              0.0   \n",
       "1         1983.81      1254.01  5.80566  7.13426  7.13154              0.0   \n",
       "2         2259.13      1250.58  5.99131  8.01682  7.98933              0.0   \n",
       "3         1424.54      1249.27  4.73477  7.05822  7.05822              0.0   \n",
       "4         2228.31      1250.61  6.40783  8.35944  8.26946              0.0   \n",
       "\n",
       "   POAV [cm^3/g]    POAVF  PONAV [cm^3/g]  PONAVF  ...  pure_methane_widomHOA  \\\n",
       "0       0.818919  0.68874             0.0     0.0  ...              -8.144317   \n",
       "1       0.495493  0.58032             0.0     0.0  ...             -10.208005   \n",
       "2       0.728036  0.65710             0.0     0.0  ...              -8.479801   \n",
       "3       0.453157  0.47338             0.0     0.0  ...             -12.615382   \n",
       "4       0.700539  0.65092             0.0     0.0  ...              -8.743404   \n",
       "\n",
       "  pure_uptake_CO2_298.00_15000  pure_uptake_CO2_298.00_1600000  \\\n",
       "0                     0.111981                       14.218595   \n",
       "1                     0.481625                        9.312424   \n",
       "2                     0.401683                       14.796071   \n",
       "3                     0.821747                       10.816880   \n",
       "4                     0.258905                       14.153999   \n",
       "\n",
       "   pure_uptake_methane_298.00_580000  pure_uptake_methane_298.00_6500000  \\\n",
       "0                           1.680640                            9.163066   \n",
       "1                           1.513152                            5.908356   \n",
       "2                           1.569714                            7.933198   \n",
       "3                           2.161833                            6.710778   \n",
       "4                           1.653013                            8.272621   \n",
       "\n",
       "   logKH_CO2  logKH_CH4       CH4DC    CH4HPSTP   CH4LPSTP  \n",
       "0  -5.125451  -5.511444  175.569974  215.005044  39.435070  \n",
       "1  -4.502967  -5.505947  143.616349  193.059644  49.443295  \n",
       "2  -4.433968  -5.525707  160.238808  199.765744  39.526937  \n",
       "3  -4.135434  -5.297082  132.576623  195.582107  63.005483  \n",
       "4  -4.774301  -5.515219  171.601539  214.452966  42.851427  \n",
       "\n",
       "[5 rows x 343 columns]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary> <font color='green'>Click here for a hint</font></summary>\n",
    "<ul>\n",
    "    <li>Use something like <code>pd.options.display.max_columns=100</code> to adjust how many columns are shown.<code>pd.options.display.max_columns=100</code>  would show at maximum 100 columns. </li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also get some basic information ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 17379 entries, 0 to 17378\n",
      "Columns: 343 entries, ASA [m^2/cm^3] to CH4LPSTP\n",
      "dtypes: float64(342), object(1)\n",
      "memory usage: 45.5+ MB\n"
     ]
    }
   ],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " $\\color{DarkBlue}{\\textsf{Short question}}$\n",
    "- How many materials are in the dataset? \n",
    "- Which datatypes do we deal with?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we define three global variables (hence upper case), which are the *names* of our feature and target columns. We will use the `TARGET` for the actual regression and the `TARGET_BINARY` only for the stratified train/test split. The `FEATURES` variable is a list of column names of our dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "TARGET = \"pure_uptake_CO2_298.00_1600000\"\n",
    "TARGET_BINARY = \"target_binned\"  # will be created later\n",
    "FEATURES = (\n",
    "    geometric_descriptors\n",
    "    + summed_functionalgroup_descriptors\n",
    "    + summed_linker_descriptors\n",
    "    + summed_metalcenter_descriptors\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As descriptors we will use geometric properties such as density, pore volume, etc. and [revised autocorrelation functions](https://pubs.acs.org/doi/abs/10.1021/acs.jpca.7b08750) (RACs) that have been optimized for describing inorganic compounds ([and recently adapated for MOFs](https://www.nature.com/articles/s41467-020-17755-8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Examples for pore geometry descriptors (in `geometric_descriptors`) include: $D_i$ (the size of the largest included sphere), $D_f$ (the largest free sphere), and $D_{if}$ (the largest included free sphere) along the pore $-$ three ways of characterizing pore size. \n",
    "\n",
    "![pore diameters](assets/spheres.png)\n",
    "\n",
    "Also included are the surface area (SA) of the pore, and the probe-occupiable pore volume (POV).\n",
    "More details on the description of pore geometries can be found in [Ongari et al.](https://pubs.acs.org/doi/abs/10.1021/acs.langmuir.7b01682)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "RACs (in the lists starting with `summed_...`) operate on the structure graph and encode information about the metal center, linkers and the functional groups as differences or products of heuristics that are relevant for inorganic chemistry, such as electronegativity ($\\chi$), connectivity ($T$), identity ($I$), covalent radii ($S$), and nuclear charge ($Z$)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<img src=\"assets/racs.png\" alt=\"RACs scheme from the lecture\" width=\"700\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number in the descriptornames shows the coordination shell that was considered in the calculation of the RACs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The target we use for this application is the high-pressure CO$_2$ uptake. This is the amount of CO$_2$ (mmol) the MOF can load per gram."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Split the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we split our data into a training set and a test set.\n",
    "\n",
    "In order to prevent *any* information of the test set from leaking into our model, we split *before* starting to analyze or transform our data. For more details on why this matters, see [chapter 7.10.2 of Elements of Statistical Learning](https://web.stanford.edu/~hastie/ElemStatLearn//printings/ESLII_print10.pdf)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1. Split with stratification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Stratification](https://en.wikipedia.org/wiki/Stratified_sampling) ensures that the class distributions (ratio of \"good\" to \"bad\" materials) are the same in the training and test set.\n",
    "\n",
    " $\\color{DarkBlue}{\\textsf{Short question}}$\n",
    "\n",
    "- Why is this important? What could happen if we would not do this? \n",
    " \n",
    "\n",
    "For stratification to work, we to define what makes a \"good\" or a \"bad\" material. We will use 15 mmol CO$_2$ / g as the threshold for the uptake, thus binarizing our continuous target variable. (You can choose it based on the histogram of the variables)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " $\\color{DarkBlue}{\\textsf{Short Exercise}}$\n",
    " - add a column 'target_binary' that encodes whether a material is low performing (`0`) or high perfoming (`1`) by comparing the uptake with the `THRESHOLD`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary> <font color='green'>Click here for a hint</font></summary>\n",
    "<ul>\n",
    "    <li> you can use <a href='https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.cut.html'>pd.cut</a>, \n",
    "    <a href='https://stackoverflow.com/questions/4406389/if-else-in-a-list-comprehension'>list comprehension</a>, the <a href='https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.Binarizer.html#sklearn.preprocessing.Binarizer'> binarizer in sklearn </a>...) </li>\n",
    "    <li> a list comprehension example: <code> [1 if value > THRESHOLD else 0 for value in df[TARGET]] </code> </li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "THRESHOLD = 15 # in units of mmol CO2/g\n",
    "df[TARGET_BINARY] = # add your code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can perform the actual split into training and test set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " $\\color{DarkBlue}{\\textsf{Short Exercise}}$\n",
    "- select reasonable values for `XX` and `XY` and then perform the test/train splits. What do you consider when making this decision (think about what you would do with really small and really big datasets, what happens if you have only one test point, what happens to the model performance if you have more test points than training points)? \n",
    "- why do we need to perform the split into a training and test set? \n",
    "- would we use the test set to tune the hyperparameters of our model?\n",
    "\n",
    "<details>\n",
    "<summary> <font color='green'>Click here for a hint</font></summary>\n",
    "<ul>\n",
    "    <li>The `size` arguments can either be integers or, often more convenient, decimals like 0.1</li>\n",
    "    <li>When you perform the split into training and test set you need to trade-off bias (pessimistic bias due to little training data) and variance (due to little test data) </li>\n",
    "    <li>A typical split cloud be 70/30, but for huge dataset the test set might be too big and for small datasets the training set might be too small in this way </li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train_stratified, df_test_stratified = train_test_split(\n",
    "    df,\n",
    "    train_size=XX,\n",
    "    test_size=XY,\n",
    "    random_state=RANDOM_SEED,\n",
    "    stratify=df[TARGET_BINARY],\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Exploratory data analysis (EDA) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After we have put the test set aside, we can give the training set a closer look."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1. Correlations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " $\\color{DarkBlue}{\\textsf{Short Exercise}}$\n",
    "- Plot some features against the target property and calculate the Pearson and Spearman correlation coefficient (what is the different between those correlation coefficients?) \n",
    "- What are the strongest correlations? Did you expect them? \n",
    "- What can be a problem when features are correlated?\n",
    "- *Optional:* Do they change if you switch from CO$_2$ to CH$_4$ uptake as the target instead? Explain your observation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the correlation matrices, you can use the `df.corr(method=)`method on your dataframe (`df`). You might want to calculate not the full correlation matrix but just the correlation of the features with the targets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary> <font color='green'>Click here for a hint</font></summary>\n",
    "<ul>\n",
    "    <li> To get the correlation with a target, you can use indexing. E.g. <code>df.corr(method='spearman')[TARGET]</code></li>\n",
    "    <li> use <code>.sort_values()</code> method on the output of `df.corr()` to sort by the value of the correlation coefficient  </li>\n",
    "      <li> You can use something like <code>scatter = hv.Scatter(df, 'Di', [TARGET,  'density [g/cm^3]']).opts(color='density [g/cm^3]', cmap='rainbow')</code> for plotting. Also consider the <a href=\"https://holoviews.org/reference/elements/matplotlib/Scatter.html\"> <code>holoviews</code> documentation</a>. In case <code>holoviews</code> is too new for you, you can of course just use <code>matplotlib</code> and something like <code>plt.scatter(x,y)</code> </li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Baselines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For machine learning, it is important to have some *baselines* to which one then compares the results of a model. Think of a classification model for some rare disease where we only have 1% postives. A classification model that only predictes the negatives *all the time* will still have a amazingly high accuracy. To be able to understand if our model is really better than such a simple prediction we need to make the simple prediction first. This is what we call a baseline.\n",
    "\n",
    "A baseline could be a really simple model, a basic heuristic or the current state of the art.\n",
    "this. We will use a heuristic.\n",
    "\n",
    "For this we use sklearn `Dummy` objects that simply calculate the mean, the median or the most frequent case of the training set, when you run the `fit()` method on them (which takes the features matrix $\\mathbf{X}$ and the labels $\\mathbf{y}$ as arguments.\n",
    "This is, the prediction of a `DummyRegressor` with `mean` strategy will always be the mean, independent of the input (it will not look at the feature matrix!). \n",
    "\n",
    "Instead of using those `sklearn` objects you could also just manually compute the the mean or median of the dataset. But we will use those objects as we can learn in this way how to use estimators in `sklearn` and it is also allows you to test your full pipeline with different (baseline) models. \n",
    "What does this mean? In practice this means that you can use all the regression and classification models shown in the figure below in the same way, they will all have a `fit()` method that accepts `X` and `y` and a predict method that accepts `X` and returns the predictions. \n",
    "\n",
    "\n",
    "<img src=\"https://scikit-learn.org/stable/assets/ml_map.png\" alt=\"ML Map\" width=\"800\"/>\n",
    "\n",
    "The estimator objects can be always used in the same way \n",
    "\n",
    "<img src=\"https://static.packt-cdn.com/products/9781789800265/graphics/d49a2e95-8f22-42ed-89f1-474b3d028787.png\" alt=\"ML Map\" width=\"400\"/>\n",
    "\n",
    "Using these objects, instead of the mean directly, allows you to easily swap them with other models in pipelines, where one chains many data transformation steps (see section 6)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1. Build dummy models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\color{DarkBlue}{\\textsf{Short Question}}$\n",
    "- If you call `.fit(X, y)` on a `DummyRegressor` does it actually use the `X`? If not, why is there still the place for the `X` in the function? If yes, how does it use it?\n",
    "\n",
    "$\\color{DarkBlue}{\\textsf{Short Exercise}}$\n",
    "- Create [`DummyRegressor`](https://scikit-learn.org/stable/modules/generated/sklearn.dummy.DummyRegressor.html) instances for  `mean`, `median`. (e.g. `dummyinstance = DummyRegressor(strategy='mean')`)\n",
    "- Train them on the training data (`dummyinstance.fit(df_train[FEATURES], df_train[TARGET])`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary> <font color='green'>Click here for hints</font></summary>\n",
    "<ul>\n",
    "    <li> to create <code>DummyRegressor</code> you can for example use <code> dummyregressor_mean = DummyRegressor(strategy='mean') </code> </li>\n",
    "    <li> to see the implementation of the <code>DummyRegressor</code> you can check out <a href=\"https://github.com/scikit-learn/scikit-learn/blob/73732e5a0bc9b72c7049dc699d69aaedbb70ef0a/sklearn/dummy.py#L391\"> the source code on GitHub</a> </li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build DummyRegressors\n",
    "dummyregressor_mean = DummyRegressor(strategy='mean')\n",
    "dummyregressor_median = DummyRegressor(#fillme)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fit Dummy Regressors\n",
    "dummyregressor_mean.fit(df_train_stratified[FEATURES], df_train_stratified[TARGET])\n",
    "dummyregressor_median.fit(#fillme)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Evaluate the performance of the dummy models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " $\\color{DarkBlue}{\\textsf{Short Exercise}}$\n",
    "- Calculate maximum error, mean absolute error and mean square error for the dummy regressors on training and test set. What would you expect those numbers to be?\n",
    "- Do the actual values surprise you? \n",
    "- What does this mean in practice for reporting of metrics/the reasoning behind using baseline models\n",
    "\n",
    "It can be handy to store our metrics of choice in a nested dictionary ([Python dictionaries are key-value pairs](https://www.tutorialspoint.com/python/python_dictionary.htm)): \n",
    "\n",
    "```python\n",
    "{\n",
    "    'dummyestimator1': {\n",
    "                        'metric_a_key': metric_a_value, \n",
    "                        'metric_b_key': metric_b_value\n",
    "                    },\n",
    "    'dummyestimator2': {\n",
    "                        'metric_a_key': metric_a_value, \n",
    "                        'metric_b_key': metric_b_value\n",
    "                    },\n",
    " }\n",
    "``` \n",
    "\n",
    "You will now write functions `get_regression_metrics(model, X, y_true)` that compute the metrics and return this dictionary for a given model. The `predict` method takes the feature matrix $\\mathbf{X}$ as input.\n",
    "\n",
    "In them, we calculate \n",
    "\n",
    "$\\mathrm {MAE} =\\frac{\\sum _{i=1}^{n}\\left|Y_{i}-\\hat{y}_{i}\\right|}{n}.$\n",
    "\n",
    "and \n",
    "\n",
    "$\\mathrm {MSE} = {\\frac {1}{n}}\\sum _{i=1}^{n}(Y_{i}-{\\hat {Y_{i}}})^{2}.$ \n",
    "\n",
    "where $\\hat{y}$ are the predictions and, $Y_{i}$ the true values.\n",
    "\n",
    "as well as the maximum error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary> <font color='green'>Click here for hints</font></summary>\n",
    "<ul>\n",
    "    <li> to perform a prediction using a estimator object, you can call <code> classifier.predict(X) </code> </li>\n",
    "    <li> to calculate metrics, you can for example call <code>accuracy_score(true_values, predicted_values) </code> </li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_regression_metrics(model, X, y_true):\n",
    "    \"\"\"\n",
    "    Get a dicionary with regression metrics:\n",
    "\n",
    "    model: sklearn model with predict method\n",
    "    X: feature matrix\n",
    "    y_true: ground truth labels\n",
    "    \"\"\"\n",
    "    y_predicted = model.predict(#fillme)\n",
    "\n",
    "    mae = mean_absolute_error(#fillme)\n",
    "    mse = mean_squared_error(#fillme)\n",
    "    maximum_error = max_error(#fillme)\n",
    "\n",
    "    metrics_dict = {\n",
    "        'mae': mae,\n",
    "        'mse': mse,\n",
    "        'max_error': maximum_error\n",
    "    }\n",
    "\n",
    "    return metrics_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dummy_regressors = [\n",
    "    ('mean', dummyregressor_mean),\n",
    "    ('median', dummyregressor_median)\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dummy_regressor_results_test = {} # initialize empty dictionary\n",
    "dummy_regressor_results_train = {}\n",
    "\n",
    "# loop over the dummy_regressor list\n",
    "# if you have a tuple regressorname, regressor = (a, b) that is automatically expanded into the variables\n",
    "# a = regressorname, b = regressor\n",
    "for regressorname, regressor in dummy_regressors:\n",
    "    print(f\"Calculating metrics for {regressorname}\")\n",
    "    dummy_regressor_results_test[regressorname] = get_regression_metrics(#fillme)\n",
    "    dummy_regressor_results_train[regressorname] = get_regression_metrics(#fillme)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Build actual regression models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's build a simple [kernel ridge regression (KRR)](https://emtiyaz.github.io/pcml15/kernel-ridge-regression.pdf) machine learning model and train it with our raw data.\n",
    "You can try different kernels, but we recommend to start with the Gaussian radial basis function ('rbf') kernel.\n",
    " \n",
    " $\\color{DarkBlue}{\\textsf{Short Question}}$\n",
    "- Do you expect this model to perform better than the dummy models?\n",
    "- Train it and then calculate the performance metrics on the training and test set. How do they compare to the performance of the dummy models?\n",
    "- What is the shape of the Kernel and of the weights? (you can check your answer by looking at the `dual_coef_` attribute of the KRR instance. You can get shapes of objects using the `shape` atrribute "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train the model with a Gaussian kernel\n",
    "krr = KernelRidge(kernel='rbf')\n",
    "krr.fit(#fillme)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the metrics on the train and the test set using the get_regression_metrics functions (as above)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Evaluate the model performance in detail"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have trained our first machine learning model!\n",
    "We'll first have a closer look at its performance, before learning how to improve it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " $\\color{DarkBlue}{\\textsf{Short Exercise}}$\n",
    "- Create a parity plot (true values against predictions)for the training and test data\n",
    "- Plot a histogram of the distribution of the training and test errors on the training and test set. Plot the errors also as a function of the true value\n",
    "- Let's assume we would like to use our model for pre-screening a library of millions of porous materials to zoom-in on those with the most promising gas uptake. Could you tolerate the errors of your model?\n",
    "- Compare the parity plots for this model with the ones for the dummy models. \n",
    "Use the plotting functions below the evaluate all the following models you train.\n",
    "\n",
    "For this exercise, it can be handy to save the results in a dictionary, e.g. \n",
    "```(python)\n",
    "res_train = {\n",
    "    'y true': [],\n",
    "    'y pred': []\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary> <font color='green'>Click here for hints for plotting</font></summary>\n",
    "<ul>\n",
    "    <li> If you want to use matplotlib to make the parity plots, you can use the <a href=\"https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.hist2d.html\">hist2d function</a> </li>\n",
    "    <li> To create the frequencies and the edges of a histogram, one can use <code>np.histogram</code></li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create dictionaries with training and test results to create parity plots\n",
    "res_train = {\n",
    "    'y true': # fillme using the dataframe,\n",
    "    'y pred': # fillme using the model prediction\n",
    "}\n",
    "\n",
    "res_test = {\n",
    "    'y true': # fillme using the dataframe\n",
    "    'y pred': # fillme using the model prediction\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, lets calculate the errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "res_train[\"error\"] = res_train[\"y true\"] - res_train[\"y pred\"]\n",
    "res_test[\"error\"] = res_test[\"y true\"] - res_test[\"y pred\"]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, plot the parity plots and error distributions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary> <font color='green'>Click here for hints for plotting</font></summary>\n",
    "If you want interactive plots, you can use the following code:\n",
    "<pre><code>\n",
    "hv.extension(\"bokeh\")\n",
    "hex_train = hv.HexTiles(res_train, [\"y true\", \"y pred\"]).hist(\n",
    "    dimension=[\"y true\", \"y pred\"]\n",
    ")\n",
    "hex_test = hv.HexTiles(res_test, [\"y true\", \"y pred\"]).hist(\n",
    "    dimension=[\"y true\", \"y pred\"]\n",
    ")\n",
    "hex_train + hex_test\n",
    "</code>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot it\n",
    "hist_density(res_train['y true'], res_train['y pred'], xlabel='y true', ylabel='y pred', title='Train')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hist_density(res_test['y true'], res_test['y pred'], xlabel='y true', ylabel='y pred', title='Test')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Improve the model "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our training set still has a couple of issues you might have noticed:\n",
    "- The feature values are not scaled (different features are measured in different units ...)\n",
    "- Some features are basically constant, i.e. do not contain relevant information and just increase the dimensionality of the problem \n",
    "- Some feature distributions are skewed (which is more relevant for some models than for others ...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\color{DarkBlue}{\\textsf{Short Question}}$\n",
    "- Why might the scaling of the features be relevant for a machine learning model? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.1. Standard scaling and building a first pipeline "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given that we will now go beyond training a single model, we will build [Pipelines](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html), which are objects that can collect a selection of transformations and estimators. This makes it quite easy to apply the same set of operations to different datasets. A simple pipeline might be built as follows \n",
    "\n",
    "<img src=\"https://vitalflux.com/wp-content/uploads/2020/08/ML-Pipeline-Page-2-1024x307.png\" alt=\"Pipeline\" width=\"800\"/>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " $\\color{DarkBlue}{\\textsf{Short Exercise}}$\n",
    "- Build a pipline that first performs standard scaling and then fits a KRR. Call it `pipe_w_scaling`. \n",
    "- Fit it on the training set \n",
    "- Make predictions, calculate the errors and make the parity plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary> <font color='green'>Click here for hints</font></summary>\n",
    "<ul>\n",
    "    <li> the <code>fit</code>, <code>predict</code> methods also work for pipelines </li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipe_w_scaling = Pipeline(\n",
    "   [\n",
    "       ('scaling', StandardScaler()),\n",
    "       ('krr', #fillme)\n",
    "   ]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.2. Hyperparameter optimization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A key component we did not optimize so far are hyperparameters. Those are parameters of the model that we usually cannot learn from the data but have to fix before we train the model. \n",
    "Since we cannot learn those parameters it is not trivial to select them. Hence, what we typically do in practice is to create another set, a \"validation set\", and use it to test models trained with different hyperparameters.\n",
    "\n",
    "The most common approach to hyperparameter optimization is to define a grid of all relevant parameters and to search over the grid for the best model performance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\color{DarkBlue}{\\textsf{Short Exercise}}$\n",
    "- Think about which parameters you could optimize in the pipeline. Note that your KRR model has two parameters you can optimize. You can also switch off some steps by setting them to `None'.\n",
    "- For each parameter you need to define a resonable grid to search over.\n",
    "- Recall, what k-fold cross-validation does. Run the hyperparameter optimization using 5-fold cross-validation (you can adjust the number of folds according to your computational resources/impatience. It turns out at k=10 is the [best tradeoff between variance and bias](https://arxiv.org/abs/1811.12808)). \n",
    "Tune the hyperparameters until you are statisfied (e.g., until you cannot improve the cross validated error any more)\n",
    "- Why don't we use the test set for hyperparameter tuning but instead test on the validation set? \n",
    "- Evaluate the model performance by calculating the performance metrics (MAE, MSE, max error) on the training and the test set.\n",
    "- *Optional:* Instead of grid search, try to use random search on the same grid (`RandomizedSearchCV`) and fix the number of evaluations (`n_iter`) to a fraction of the number of evaluations of grid search. What do you observe and conclude?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " $\\color{DarkRed}{\\textsf{Tips}}$\n",
    "- If you want to see what is happening, set the `verbosity` argument of the `GridSearchCV` object to a higher number.\n",
    " \n",
    "- If you want to speed up the optimization, you can run it in parallel by setting the `n_jobs` argument to the number of workers. If you set it to -1 it will use all available cores. *Using all cores might freeze your computer if you do not have enough memory*\n",
    " \n",
    "- If the optimization is too slow, reduce the number of data points in your set, the number of folds or the grid size. Note that it can also be a feasible strategy to first use a coarser grid and the a finer grid for fine-tuning.\n",
    "\n",
    "- For grid search, you need to define a parameter grid, which is a dictionary of the following form: \n",
    "```(python)\n",
    "param_grid = {\n",
    "                    'pipelinestage__parameter': np.logspace(-4,1,10),\n",
    "                    'pipelinestage': [None, TransformerA(), TransformerB()]\n",
    "            }\n",
    "```\n",
    "\n",
    "- After the search, you can access the best model with `.best_estimator_` and the best parameters with `.best_params_` on the GridSearchCV instance. For example `grid_krr.best_estimator_`\n",
    "\n",
    "- If you initialize the GridSearchCV instance with `refit=True` it will automatically train the model with all training data (and not only the training folds from cross-validations)\n",
    "\n",
    "The double underscore (dunder) notation works recursively and specifies the parameters for any pipeline stage. \n",
    "For example, `ovasvm__estimator__cls__C` would specifiy the `C` parameter of the estimator in the one-versus-rest classifier `ovasvm`. \n",
    "\n",
    "You can print all parameters of the pipeline using `print(sorted(pipeline.get_params().keys()))`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "Be aware that tight grids will drastically increase the number of experiments you will run! In some cases, it can be useful to perform the optimization in steps, i.e., first use a coarse grid and then refine in interesting regions. \n",
    "Alternatively, there are approached like <a href=\"https://www.jmlr.org/papers/volume18/16-558/16-558.pdf\"> hyperband <a> that dynamically adjust the number of data points.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary> <font color='green'>Click here for hints about pipelines and grid search</font></summary>\n",
    "<ul>\n",
    "    <li> You can use the <code>np.logspace</code> function to generate a grid for values that you want to vary on a logarithmic scale </li>\n",
    "    <li> There are two hyperparameters for KRR: the regularization strength <code>alpha</code> and the Gaussian width  <code>gamma</code> </li>\n",
    "    <li> For the regularization strength, values between 1 and 1e-3 can be reasonable. For gamma you can use the median heuristic, gamma = 1 / median, or values between 1e-3 and 1e3</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the parameter grid and the grid search object\n",
    "param_grid = {\n",
    "                    'scaling': [MinMaxScaler(), StandardScaler()], # test different scaling methods\n",
    "                    'krr__alpha': #fillme,\n",
    "                    'krr__#fillme': #fillme\n",
    "            }\n",
    "\n",
    "grid_krr = GridSearchCV(#your pipeline, param_grid=param_grid,\n",
    "                        cv=#number of folds, verbose=2, n_jobs=2)\n",
    "\n",
    "# optional random search\n",
    "#random_krr = RandomizedSearchCV(#your pipeline, param_distributions=param_grid, n_iter=#number of evaluations,\n",
    "#                        cv=#number of folds, verbose=2, n_jobs=2\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# run the grid search by calling the fit method\n",
    "grid_krr.fit(#fillme)\n",
    "# optional random search\n",
    "# random_krr.fit(#fillme)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the performance metrics\n",
    "get_regression_metrics(#fillme)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary> <font color='green'>Click here for some more information about hyperparameter optimization</font></summary>\n",
    "Grid search is not the most efficient way to perform hyperparamter optimization. Even <a href=\"http://jmlr.csail.mit.edu/papers/volume13/bergstra12a/bergstra12a.pdf\">random search was shown to be more efficient</a>. Really efficient though are Bayesian optimization approaches like <a href='https://papers.nips.cc/paper/4443-algorithms-for-hyper-parameter-optimization.pdf)'>TPE</a>. This is implemented in the hyperopt library, which is also installed in your conda environment.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary> <font color='green'>Click here for hyperparameter optimization with hyperopt (advanded and optional outlook)</font></summary>\n",
    "    \n",
    "<b>Import the tools we need</b>\n",
    "<code>\n",
    "from hyperopt import fmin, tpe, hp, STATUS_OK, Trials, mix, rand, anneal, space_eval\n",
    "from functools import partial\n",
    "</code>    \n",
    "\n",
    "<b>Define the grid</b>\n",
    "<code>\n",
    "param_hyperopt = {\n",
    "    \"krr__alpha\": hp.loguniform(\"krr__alpha\", np.log(0.001), np.log(10)),\n",
    "    \"krr__gamma\": hp.loguniform(\"krr__gamma\", np.log(0.001), np.log(10)),\n",
    "}\n",
    "</code> \n",
    "\n",
    "<b>Define the objective function</b>\n",
    "<code>\n",
    "def objective_function(params):\n",
    "    pipe.set_params(\n",
    "        **{\n",
    "            \"krr__alpha\": params[\"krr__alpha\"],\n",
    "            \"krr__gamma\": params[\"krr__gamma\"],\n",
    "        }\n",
    "    )\n",
    "    score = cross_val_score(\n",
    "        pipe, X_train, y_train, cv=10, scoring=\"neg_mean_absolute_error\"\n",
    "    ).mean()\n",
    "    return {\"loss\": -score, \"status\": STATUS_OK} \n",
    "</code>\n",
    "\n",
    "<b>We will use a search in which we mix random search, annealing and tpe</b>\n",
    "<code>\n",
    "trials = Trials()\n",
    "mix_search = partial(\n",
    "   mix.suggest,\n",
    "   p_suggest=[(0.15, rand.suggest), (0.15, anneal.suggest), (0.7, tpe.suggest)],\n",
    ")\n",
    "</code>\n",
    "\n",
    "<b>Now, we can minimize the objective function.</b>\n",
    "<code>\n",
    "best_param = fmin(\n",
    "        objective_function,\n",
    "        param_hyperopt,\n",
    "        algo=mix_search,\n",
    "        max_evals=MAX_EVALES,\n",
    "        trials=trials,\n",
    "        rstate=np.random.RandomState(RANDOM_SEED),\n",
    "    )\n",
    "</code>\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Feature Engineering "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we would like to remove features with low variance. This can be done by setting a variance threshold."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\color{DarkBlue}{\\textsf{Short Question}}$\n",
    "    \n",
    "- What is the reasoning behind doing this? \n",
    "- When might it go wrong and why?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " $\\color{DarkBlue}{\\textsf{Short Exercise}}$\n",
    "- Add a variance threshold to the pipeline (select the correct function argument)\n",
    "- Use random search for hyperparameter optimization, retrain the pipeline, and calculate the performance metrics (max error, MAE, MSE) on the training and test set\n",
    "- If you could improve the predictive performance, do not forget to also run the model for the Kaggle competition!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the pipeline\n",
    "pipe_variance_threshold = Pipeline(\n",
    "    # fillme with the pipeline steps\n",
    "    [\n",
    "        ('variance_treshold', VarianceThreshold(#fillme with threshold)),\n",
    "        #fillme with remaining pipeline steps\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "param_grid_variance_threshold = {\n",
    "                    'scaling': [None, StandardScaler()],\n",
    "                    'krr__alpha': #fillme,\n",
    "                    'krr__#fillme': #fillme,\n",
    "                    'variance_treshold__threshold': #fillme\n",
    "            }\n",
    "\n",
    "random_variance_treshold = RandomizedSearchCV(#your pipeline, param_distributions=param_grid, n_iter=#number of evaluations,\n",
    "                        cv=#number of folds, verbose=2, n_jobs=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fit the pipeline and run the evaluation\n",
    "random_variance_treshold.fit(#fillme)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\color{DarkBlue}{\\textsf{Short Exercise (optional)}}$\n",
    "- replace the variance threshold with a model-based feature selection \n",
    "`('feature_selection', SelectFromModel(LinearSVC(penalty=\"l1\")))` or [any feature selection method that you would like to try](https://scikit-learn.org/stable/modules/feature_selection.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Saving the model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, that we spent so much time in optimizing our model, we do not want to loose it. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " $\\color{DarkBlue}{\\textsf{Short Exercise}}$\n",
    "- use the [joblib library](https://scikit-learn.org/stable/modules/model_persistence.html) to save your model\n",
    "- make sure you can load it again\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dump your model\n",
    "joblib.dump(model, filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try to load it again\n",
    "model_loaded = joblib.load(filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. Influence of Regularization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " $\\color{DarkBlue}{\\textsf{Short Exercise}}$\n",
    "- what happens if you set $\\alpha$  to a really small or to large value? Why is this the case explain what the parameter means using the equation derived in the lectures?\n",
    "\n",
    " To test this, fix this value in one of your pipelines, retrain the models (re-optimizing the other hyperparameters) and rerun the performance evaluation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary> <font color='green'>Click here for hints</font></summary>\n",
    "<ul>\n",
    "    <li> Check the derivation for ridge regression and KRR in the notes. </li>\n",
    "    <li> Also remember the loss landscapes we discussed in the lectures about LASSO. </li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11. Interpreting the model "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, that our model performs decently, we would like to know which features are mainly responsible for this, i.e. how the model performs its reasoning. \n",
    "\n",
    "One method to do so is the [permutation feature importance technique](https://christophm.github.io/interpretable-ml-book/feature-importance.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\color{DarkBlue}{\\textsf{Short question}}$\n",
    "\n",
    "We use both descriptors that encode the pore geometry (density, pore diameters, surface areas) as well as some that describe the chemistry of the MOF (the RACs). \n",
    "- Would you expect the relative importance of these features to be different for prediction of gas adsorption at high vs low gas pressure?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary> <font color='green'>Click here for a hint</font></summary>\n",
    "<ul>\n",
    "    <li> <a href=\"https://pubs.acs.org/doi/abs/10.1021/acs.chemmater.8b02257\">An article from Diego et al.</a> (10.1021/acs.chemmater.8b02257) gives some hints.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " $\\color{DarkBlue}{\\textsf{Short Exercise}}$\n",
    "- Complete the function `_calculate_permutation_scores` (which we took from the `sklearn` package) and which is needed to calculate the permutation feature importance using the `permutation_importance` function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _calculate_permutation_scores(estimator, X, y, col_idx, random_state,\n",
    "                                  n_repeats, scorer):\n",
    "    \"\"\"Calculate score when `col_idx` is permuted. Based on the sklearn implementation\n",
    "\n",
    "    estimator: sklearn estimator object\n",
    "    X: pd.Dataframe or np.array\n",
    "    y: pd.Dataframe or np.array\n",
    "    col_idx: int\n",
    "    random_state: int\n",
    "    n_repeats: int\n",
    "    scorer: function that takes model, X and y_true as arguments\n",
    "    \"\"\"\n",
    "    random_state = check_random_state(random_state)\n",
    "\n",
    "    X_permuted = X.copy()\n",
    "    scores = np.zeros(n_repeats)\n",
    "    # get the indices\n",
    "    shuffling_idx = np.arange(X.shape[0])\n",
    "    for n_round in range(n_repeats):\n",
    "        # FILL BELOW HERE\n",
    "        # shuffle them (fill in what you want to shuffle)\n",
    "        random_state.shuffle(#fillme)\n",
    "\n",
    "        # Deal with dataframes\n",
    "        if hasattr(X_permuted, \"iloc\"):\n",
    "            # .iloc selects the indices from a dataframe and you give it [row, column]\n",
    "            col = X_permuted.iloc[shuffling_idx, col_idx]\n",
    "            col.index = X_permuted.index\n",
    "            X_permuted.iloc[:, col_idx] = col\n",
    "\n",
    "        # Deal with numpy arrays\n",
    "        else:\n",
    "            # FILL BELOW HERE\n",
    "            # array indexing is [row, column]\n",
    "            X_permuted[:, col_idx] = X_permuted[#fillme]\n",
    "\n",
    "        # Get the scores\n",
    "        feature_score = scorer(estimator, X_permuted, y)\n",
    "\n",
    "        # record the scores in array\n",
    "        scores[n_round] = feature_score\n",
    "\n",
    "    return scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nothing to change in the function below, it just call the `_calculate_permutation_scores` function you just completed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def permutation_importance(\n",
    "    estimator,\n",
    "    X,\n",
    "    y,\n",
    "    scoring=\"neg_mean_absolute_error\",\n",
    "    n_repeats=5,\n",
    "    n_jobs=2,\n",
    "    random_state=None,\n",
    "):\n",
    "    \"\"\"Permutation importance for feature evaluation\n",
    "    estimator : object\n",
    "        An estimator that has already been :term:`fitted` and is compatible\n",
    "        with :term:`scorer`.\n",
    "    X : ndarray or DataFrame, shape (n_samples, n_features)\n",
    "        Data on which permutation importance will be computed.\n",
    "    y : array-like or None, shape (n_samples, ) or (n_samples, n_classes)\n",
    "        Targets for supervised or `None` for unsupervised.\n",
    "    scoring : string, callable or None, default=None\n",
    "        Scorer to use. It can be a single\n",
    "        string (see :ref:`scoring_parameter`) or a callable (see\n",
    "        :ref:`scoring`). If None, the estimator's default scorer is used.\n",
    "    n_repeats : int, default=5\n",
    "        Number of times to permute a feature.\n",
    "    n_jobs : int or None, default=2\n",
    "        The number of jobs to use for the computation.\n",
    "        `None` means 1 unless in a :obj:`joblib.parallel_backend` context.\n",
    "        `-1` means using all processors. See :term:`Glossary <n_jobs>`\n",
    "        for more details.\n",
    "    random_state : int, RandomState instance, or None, default=None\n",
    "        Pseudo-random number generator to control the permutations of each\n",
    "        feature. See :term:`random_state`.\n",
    "    \"\"\"\n",
    "    # Deal with dataframes\n",
    "    if not hasattr(X, \"iloc\"):\n",
    "        X = check_array(X, force_all_finite=\"allow-nan\", dtype=None)\n",
    "\n",
    "    # Precompute random seed from the random state to be used\n",
    "    # to get a fresh independent RandomState instance for each\n",
    "    # parallel call to _calculate_permutation_scores, irrespective of\n",
    "    # the fact that variables are shared or not depending on the active\n",
    "    # joblib backend (sequential, thread-based or process-based).\n",
    "    random_state = check_random_state(random_state)\n",
    "    random_seed = random_state.randint(np.iinfo(np.int32).max + 1)\n",
    "\n",
    "    # Determine scorer from user options.\n",
    "    scorer = check_scoring(estimator, scoring=scoring)\n",
    "    # get the performance score on the unpermuted data\n",
    "    baseline_score = scorer(estimator, X, y)\n",
    "\n",
    "    # run the permuted evaluations in parallel for each column\n",
    "    scores = Parallel(n_jobs=n_jobs)(\n",
    "        delayed(_calculate_permutation_scores)(\n",
    "            estimator, X, y, col_idx, random_seed, n_repeats, scorer\n",
    "        )\n",
    "        for col_idx in range(X.shape[1])\n",
    "    )\n",
    "\n",
    "    # get difference two\n",
    "    importances = baseline_score - np.array(scores)\n",
    "\n",
    "    # return the results (dictionary)\n",
    "    return Bunch(\n",
    "        importances_mean=np.mean(importances, axis=1),\n",
    "        importances_std=np.std(importances, axis=1),\n",
    "        importances=importances,\n",
    "    )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " $\\color{DarkBlue}{\\textsf{Short Exercise}}$\n",
    "- Use your function to find the five most important features.\n",
    "- Which are they? Did you expect this result?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "permutation_results = permutation_importance(#fillme)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "permutation_results[\"features\"] = FEATURES\n",
    "bars = hv.Bars(\n",
    "    permutation_results, \"features\", [\"importances_mean\", \"importances_std\"]\n",
    ").sort(\"importances_mean\", reverse=True)\n",
    "errors = hv.ErrorBars(\n",
    "    permutation_results, \"features\", vdims=[\"importances_mean\", \"importances_std\"]\n",
    ").sort(\"importances_mean\", reverse=True)\n",
    "\n",
    "bars * errors\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary> <font color='green'>Click here for hints</font></summary>\n",
    "<ul>\n",
    "    <li> To get the top <emph>n</emph> indices of an array <code>a</code>, you can use <code>np.argsort(a)[-n:]</code></li>\n",
    "    <li> Get the feature names from the <code>FEATURES</code> list </li> \n",
    "    <li> combined this might look like <code>np.array(FEATURES)[np.argsort(a)[-n:]]</code></li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary> <font color='green'>Click here for more information on model interpretation</font></summary>\n",
    "The permutation feature importance technique is not a silver bullet, e.g. there are issues with correlated features.\n",
    "However, it is likely <a href='https://explained.ai/rf-importance/'>a better choice than feature importance, like impurity decrease, derived from random forests</a>).\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 12. Submit your best model to Kaggle "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Join the [Kaggle competition](https://www.kaggle.com/competitions/molsim-2024-ml-challenge/host/launch-checklist) for this course!\n",
    "For this you can: \n",
    "- try to continue optimizing your KRR model \n",
    "- try to use a new model ([browse the sklearn documentation](https://scikit-learn.org/) for ideas or check out [xgboost](https://xgboost.readthedocs.io/en/stable/)\n",
    "\n",
    "The important parts for us here are: \n",
    "- that you make an attempt to improve your model, discuss this attempt, and use proper models to measure potential improvement \n",
    "- we will not grade you based on how \"fancy\" or model is or how well it performs but rather on whether you do something reasonable that is well motivated in your discussion\n",
    "- you do not need to try both a model and continue optimizing your model. Doing one of them is, in principle, \"enough\"\n",
    "\n",
    "Use then your best model to create a `submission.csv` with your predictions to join the competition and upload it to the competition site.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kaggle_data = pd.read_csv('data/features.csv')\n",
    "kaggle_predictions = #fillme.predict(kaggle_data[FEATURES])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "submission = pd.DataFrame({\"id\": kaggle_data[\"id\"], \"prediction\": kaggle_predictions})\n",
    "\n",
    "submission.to_csv(\"submission.csv\", index=False)\n"
   ]
  }
 ],
 "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.10.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "5c7b89af1651d0b8571dde13640ecdccf7d5a6204171d6ab33e7c296e100e08a"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}