From ef14075f126b02147b9b4aaab07e7b38e959ab72 Mon Sep 17 00:00:00 2001
From: Francesco Pisu <frapisu9@gmail.com>
Date: Sat, 16 Sep 2023 00:33:31 +0200
Subject: [PATCH 1/2] docs: update example notebook with average ROC curves
 plot of multiple binary classifiers

---
 docs/example.ipynb | 554 +++++++++++++++++++++++++++++++++++++--------
 1 file changed, 463 insertions(+), 91 deletions(-)

diff --git a/docs/example.ipynb b/docs/example.ipynb
index ce178a4..8cc9db6 100644
--- a/docs/example.ipynb
+++ b/docs/example.ipynb
@@ -14,14 +14,15 @@
    "metadata": {},
    "source": [
     "In this notebook we will see how to:\n",
-    "- train and test a binary classifier within a cross-validation framework;\n",
-    "- accumulate ground-truths and predictions and\n",
-    "- assess calibration using the modelsight's `hosmer_lemeshow_plot` function."
+    "- cross-validate multiple binary classifiers;\n",
+    "- accumulate ground-truths and predictions\n",
+    "- assess calibration using the modelsight's `hosmer_lemeshow_plot` function.\n",
+    "- generate average ROC curves and test statistical significance of differences in AUCS between pairs of classifiers."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -31,15 +32,78 @@
     "sys.path.insert(0, os.path.abspath(\"../\"))"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Miscellaneous"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
-    "SEED = 1234\n",
-    "N_REPEATS = 10\n",
-    "N_SPLITS = 10"
+    "import random\n",
+    "import numpy as np\n",
+    "from dataclasses import dataclass, field\n",
+    "from numpy.random import SeedSequence, BitGenerator, Generator\n",
+    "from typing import Union, List, Tuple, Annotated, Literal, TypeVar, Optional\n",
+    "from sklearn.base import BaseEstimator  # type: ignore\n",
+    "from sklearn.model_selection._split import BaseCrossValidator, _RepeatedSplits\n",
+    "\n",
+    "try:\n",
+    "    from numpy.typing import ArrayLike\n",
+    "except ImportError:\n",
+    "    ArrayLike = Union[np.ndarray, List[List[float]]]\n",
+    "\n",
+    "if sys.version_info >= (3, 10):\n",
+    "    from typing import TypeAlias\n",
+    "else:\n",
+    "    from typing_extensions import TypeAlias\n",
+    "\n",
+    "\n",
+    "Estimator = TypeVar(\"Estimator\", bound=BaseEstimator)\n",
+    "SeedType = Union[None, int, ArrayLike, SeedSequence, BitGenerator, Generator]\n",
+    "CVScheme: TypeAlias = TypeVar(\"CVScheme\", BaseCrossValidator, _RepeatedSplits)\n",
+    "\n",
+    "\n",
+    "@dataclass\n",
+    "class CVModellingOutput:    \n",
+    "    gts_train: ArrayLike\n",
+    "    gts_val: ArrayLike\n",
+    "    gts_train_conc: ArrayLike\n",
+    "    gts_val_conc: ArrayLike\n",
+    "\n",
+    "    # predicted probabilities\n",
+    "    probas_train: ArrayLike\n",
+    "    probas_val: ArrayLike\n",
+    "    probas_train_conc: ArrayLike\n",
+    "    probas_val_conc: ArrayLike\n",
+    "    \n",
+    "    # misc\n",
+    "    models: List[Estimator]\n",
+    "    errors: Optional[ArrayLike]\n",
+    "    correct: Optional[ArrayLike]\n",
+    "    features: Optional[ArrayLike]\n",
+    "\n",
+    "class Colors:\n",
+    "    blue = \"#4974a5\"\n",
+    "    lightblue = \"#b0c4de\"\n",
+    "    salmon = \"#ff8c69\"\n",
+    "    lightsalmon = \"#FFD1C2\"\n",
+    "    darksalmon = \"#e57e5e\"\n",
+    "\n",
+    "    green2 = \"#82B240\"\n",
+    "    charcoal = \"#31485D\"\n",
+    "    gray = \"#A3BAC3\"\n",
+    "    white = \"#EAEBED\"\n",
+    "\n",
+    "    yellow = \"#FFC325\"\n",
+    "    red = \"#E31B23\"\n",
+    "    blue = \"#005CAB\"\n",
+    "    violet = \"#9A348E\""
    ]
   },
   {
@@ -69,7 +133,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -110,7 +174,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -149,7 +213,7 @@
        "dtype: int64"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -176,93 +240,331 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from interpret.glassbox import ExplainableBoostingClassifier\n",
-    "from sklearn.model_selection import RepeatedStratifiedKFold\n",
-    "\n",
-    "cv = RepeatedStratifiedKFold(n_repeats=N_REPEATS, \n",
-    "                             n_splits=N_SPLITS, \n",
-    "                             random_state=SEED)\n",
-    "\n",
-    "cv_results = {\n",
-    "    \"gt_train\": [],\n",
-    "    \"gt_val\": [],\n",
-    "    \"probas_train\": [],\n",
-    "    \"probas_val\": []\n",
-    "}\n",
-    "\n",
-    "for i, (train_idx, val_idx) in enumerate(cv.split(X, y)):\n",
-    "    Xtrain, ytrain = X.iloc[train_idx, :], y.iloc[train_idx]\n",
-    "    Xval, yval = X.iloc[val_idx, :], y.iloc[val_idx]\n",
-    "\n",
-    "    model = ExplainableBoostingClassifier(random_state=SEED,\n",
-    "                                            interactions=6,\n",
-    "                                            learning_rate=0.02,\n",
-    "                                            min_samples_leaf=5,\n",
-    "                                            n_jobs=4)\n",
-    "\n",
-    "    # this is a toy example hence we will train the model on all available features\n",
-    "    model.fit(Xtrain, ytrain)\n",
-    "\n",
-    "    # accumulate ground-truths\n",
-    "    cv_results[\"gt_train\"].append(ytrain)\n",
-    "    cv_results[\"gt_val\"].append(yval)\n",
-    "\n",
-    "    # accumulate predictions\n",
-    "    train_pred_probas = model.predict_proba(Xtrain)[:, 1]\n",
-    "    val_pred_probas = model.predict_proba(Xval)[:, 1]\n",
-    "\n",
-    "    cv_results[\"probas_train\"].append(train_pred_probas)\n",
-    "    cv_results[\"probas_val\"].append(val_pred_probas)    "
+    "import pandas as pd\n",
+    "from sklearn.base import clone\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.model_selection import StratifiedKFold, RepeatedStratifiedKFold\n",
+    "from sklearn.calibration import CalibratedClassifierCV\n",
+    "from sklearn.metrics import roc_curve\n",
+    "from sklearn.svm import SVC\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.neighbors import KNeighborsClassifier\n",
+    "from sklearn.linear_model import LogisticRegression\n",
+    "from interpret.glassbox import ExplainableBoostingClassifier"
    ]
   },
   {
-   "attachments": {},
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": 9,
    "metadata": {},
+   "outputs": [],
    "source": [
-    "Let's see how this model is performing"
+    "class BinaryModelFactory:\n",
+    "    def get_model(self, model_name: str) -> Estimator:\n",
+    "        if model_name == \"EBM\":\n",
+    "            return ExplainableBoostingClassifier(random_state=cv_config.get(\"SEED\"),\n",
+    "                                        interactions=6,\n",
+    "                                        learning_rate=0.02,\n",
+    "                                        min_samples_leaf=5,\n",
+    "                                        n_jobs=-1)\n",
+    "        elif model_name == \"LR\":\n",
+    "            return LogisticRegression(penalty=\"elasticnet\",\n",
+    "                                 solver=\"saga\",\n",
+    "                                 l1_ratio=0.3,\n",
+    "                                 max_iter=10000,\n",
+    "                                 random_state=cv_config.get(\"SEED\"))\n",
+    "        elif model_name == \"SVC\": \n",
+    "            return SVC(probability=True, \n",
+    "                   class_weight=\"balanced\", \n",
+    "                   random_state=cv_config.get(\"SEED\"))\n",
+    "        elif model_name == \"RF\": \n",
+    "            return RandomForestClassifier(random_state=cv_config.get(\"SEED\"),\n",
+    "                                     n_estimators=5,\n",
+    "                                     max_depth=3,\n",
+    "                                     n_jobs=-1)\n",
+    "        elif model_name == \"KNN\": \n",
+    "            return KNeighborsClassifier(n_jobs=-1)        \n",
+    "        else:\n",
+    "            raise ValueError(f\"{model_name} is not a valid estimator name.\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
-    "import numpy as np\n",
-    "from sklearn.metrics import roc_auc_score, brier_score_loss"
+    "def get_calibrated_model(model: Estimator, \n",
+    "                         X: ArrayLike, y: ArrayLike) -> Estimator:\n",
+    "    \"\"\"Calibrate an already fitted model using data X, y.\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    model : Estimator\n",
+    "        Already fitted model that should be calibrated\n",
+    "    X : ArrayLike\n",
+    "        Design matrix of n features and m observations.\n",
+    "    y : ArrayLike\n",
+    "        Array of m ground-truths\n",
+    "\n",
+    "    Returns\n",
+    "    -------\n",
+    "    Estimator\n",
+    "        The calibrated model\n",
+    "    \"\"\"\n",
+    "    calib_model = CalibratedClassifierCV(estimator=model,\n",
+    "                                         method=\"sigmoid\",\n",
+    "                                         n_jobs=10,\n",
+    "                                         cv=\"prefit\")\n",
+    "    calib_model.fit(X, y)\n",
+    "    \n",
+    "    return calib_model\n",
+    "\n",
+    "\n",
+    "def get_feature_selector(seed: SeedType) -> Estimator:\n",
+    "    fs = RandomForestClassifier(random_state=seed,\n",
+    "                                n_estimators=10,\n",
+    "                                max_depth=3,\n",
+    "                                n_jobs=4,\n",
+    "                                min_samples_leaf=2,\n",
+    "                                min_samples_split=3)\n",
+    "    return fs\n",
+    "\n",
+    "\n",
+    "def select_features(X: ArrayLike,\n",
+    "                    y: ArrayLike,\n",
+    "                    selector: Estimator,\n",
+    "                    cv: CVScheme,\n",
+    "                    scale: bool,\n",
+    "                    frac: float) -> set[str]:\n",
+    "    \"\"\"Custom feature selection using a feature selector (in our case\n",
+    "    a Random Forest) and cross-validation. We select all features that\n",
+    "    are associated with a Gini impurity reduction at least 25% greater\n",
+    "    than the mean value.\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : ArrayLike\n",
+    "        An array of features values\n",
+    "    y : ArrayLike\n",
+    "        An array of ground truths\n",
+    "    selector : Estimator\n",
+    "        The feature selector. In our case is a Random Forest Classifier\n",
+    "        and we will use the built-in feature importances.\n",
+    "    cv : CVScheme\n",
+    "        A cross-validation scheme for selecting features.\n",
+    "    scale: bool\n",
+    "        Whether data should be scaled according to a StandardScaler\n",
+    "    frac: float\n",
+    "        Fraction of mean importance \n",
+    "\n",
+    "    Returns\n",
+    "    -------\n",
+    "    The set union of all selected features\n",
+    "    \"\"\"\n",
+    "    inner_feature_sets = dict()\n",
+    "\n",
+    "    for ji, (train_idxs_inner, _) in enumerate(cv.split(X, y)):\n",
+    "        # print(f\"Inner split no. {ji+1}\")\n",
+    "        inner_split = f\"inner_split_{ji}\"\n",
+    "        inner_feature_sets[inner_split] = set()\n",
+    "\n",
+    "        # select inner training and validation folds\n",
+    "        X_train_inner = X.iloc[train_idxs_inner, :].copy()\n",
+    "        if not isinstance(y, pd.Series):\n",
+    "            y = pd.Series(y)\n",
+    "\n",
+    "        y_train_inner = y.iloc[train_idxs_inner]\n",
+    "\n",
+    "        # X_val_inner, y_val_inner = X.iloc[val_idxs_inner].copy(), y[val_idxs_inner]\n",
+    "\n",
+    "        if scale:\n",
+    "            numeric_cols = X_train_inner.select_dtypes(\n",
+    "                include=[np.float64, np.int64]).columns.tolist()\n",
+    "            scaler = StandardScaler()\n",
+    "            X_train_inner.loc[:, numeric_cols] = scaler.fit_transform(\n",
+    "                X_train_inner.loc[:, numeric_cols])\n",
+    "            # X_val_inner.loc[:, numeric_cols] = scaler.transform(X_val_inner.loc[:, numeric_cols])\n",
+    "\n",
+    "        # feature selection\n",
+    "        selected_features = set()\n",
+    "\n",
+    "        feat_selector = clone(selector)\n",
+    "        feat_selector.fit(X_train_inner, y_train_inner)\n",
+    "\n",
+    "        selected_features = list(map(lambda t: t[0], list(filter(\n",
+    "            lambda w: w[1] > frac*feat_selector.feature_importances_.mean(), zip(X.columns, feat_selector.feature_importances_)))))\n",
+    "\n",
+    "        if not selected_features:\n",
+    "            continue\n",
+    "\n",
+    "        # Check that each output feature is present in the dataset's columns.\n",
+    "        diff = set.difference(set(selected_features),\n",
+    "                              set(X_train_inner.columns))\n",
+    "        if diff:\n",
+    "            raise ValueError(\n",
+    "                F\"Could not find features {DIFF} in the dataframe.\")\n",
+    "\n",
+    "        if not isinstance(selected_features, set):\n",
+    "            selected_features = set(selected_features)\n",
+    "\n",
+    "        inner_feature_sets[inner_split] = selected_features\n",
+    "\n",
+    "    return sorted(set.union(*inner_feature_sets.values()))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Median (95% CI) validation area under the curve: 1.00 (0.97 - 1.00)\n",
-      "Mean ± SD validation area under the curve: 0.99 ± 0.01\n"
+      "Processing model EBM\n",
+      "\n",
+      "Processing model LR\n",
+      "\n",
+      "Processing model SVC\n",
+      "\n",
+      "Processing model RF\n",
+      "\n",
+      "Processing model KNN\n",
+      "\n"
      ]
     }
    ],
    "source": [
-    "roc_aucs = []\n",
-    "for gt, preds in zip(cv_results[\"gt_val\"], cv_results[\"probas_val\"]):\n",
-    "    roc_auc = roc_auc_score(gt, preds)\n",
-    "    roc_aucs.append(roc_auc)\n",
+    "cv_config = {\n",
+    "    \"N_REPEATS\": 2,\n",
+    "    \"N_SPLITS\": 10,\n",
+    "    \"SHUFFLE\": True,\n",
+    "    \"SCALE\": False,\n",
+    "    \"CALIBRATE\": True,\n",
+    "    \"CALIB_FRACTION\": 0.15,\n",
+    "    \"SEED\": 1303\n",
+    "}\n",
+    "\n",
+    "outer_cv = RepeatedStratifiedKFold(n_repeats=cv_config.get(\"N_REPEATS\"),\n",
+    "                                   n_splits=cv_config.get(\"N_SPLITS\"),\n",
+    "                                   random_state=cv_config.get(\"SEED\"))\n",
+    "\n",
+    "inner_cv = StratifiedKFold(n_splits=cv_config.get(\"N_SPLITS\"),\n",
+    "                           shuffle=cv_config.get(\"SHUFFLE\"),\n",
+    "                           random_state=cv_config.get(\"SEED\"))\n",
+    "\n",
+    "models_names = [\"EBM\", \"LR\", \"SVC\", \"RF\", \"KNN\"]\n",
+    "\n",
+    "model_factory = BinaryModelFactory()\n",
+    "cv_results = dict()\n",
+    "\n",
+    "for model_name in models_names:\n",
+    "    print(f\"Processing model {model_name}\\n\")\n",
+    "\n",
+    "    gts_train = []\n",
+    "    gts_val = []\n",
+    "    probas_train = []\n",
+    "    probas_val = []\n",
+    "    gts_train_conc = []\n",
+    "    gts_val_conc = []\n",
+    "    probas_train_conc = []\n",
+    "    probas_val_conc = []\n",
     "\n",
-    "roc_low, roc_med, roc_up = np.percentile(roc_aucs, [2.5, 50, 97.5])\n",
-    "roc_mean = np.mean(roc_aucs)\n",
-    "roc_sd = np.std(roc_aucs)\n",
+    "    models = []\n",
+    "    errors = []\n",
+    "    correct = []\n",
+    "    features = []\n",
+    "        \n",
+    "    for i, (train_idx, val_idx) in enumerate(outer_cv.split(X, y)):\n",
+    "        Xtemp, ytemp = X.iloc[train_idx, :], y.iloc[train_idx]\n",
+    "        Xval, yval = X.iloc[val_idx, :], y.iloc[val_idx]\n",
     "\n",
-    "print(f\"Median (95% CI) validation area under the curve: {roc_med:.2f} ({roc_low:.2f} - {roc_up:.2f})\")\n",
-    "print(f\"Mean ± SD validation area under the curve: {roc_mean:.2f} ± {roc_sd:.2f}\")"
+    "        if cv_config.get(\"CALIBRATE\"):\n",
+    "            Xtrain, Xcal, ytrain, ycal = train_test_split(Xtemp, ytemp,\n",
+    "                                                          test_size=cv_config.get(\n",
+    "                                                              \"CALIB_FRACTION\"),\n",
+    "                                                          stratify=ytemp,\n",
+    "                                                          random_state=cv_config.get(\"SEED\"))\n",
+    "        else:\n",
+    "            Xtrain, ytrain = Xtemp, ytemp\n",
+    "\n",
+    "        model = model_factory.get_model(model_name)\n",
+    "\n",
+    "        # select features\n",
+    "        feat_subset = select_features(Xtrain, ytrain,\n",
+    "                                      selector=get_feature_selector(\n",
+    "                                          cv_config.get(\"SEED\")),\n",
+    "                                      cv=inner_cv,\n",
+    "                                      scale=False,\n",
+    "                                      frac=1.25)\n",
+    "        features.append(feat_subset)\n",
+    "\n",
+    "        if cv_config.get(\"SCALE\"):\n",
+    "            numeric_cols = Xtrain.select_dtypes(\n",
+    "                include=[np.float64, np.int64]).columns.tolist()\n",
+    "            scaler = StandardScaler()\n",
+    "            Xtrain.loc[:, numeric_cols] = scaler.fit_transform(\n",
+    "                Xtrain.loc[:, numeric_cols])\n",
+    "            Xtest.loc[:, numeric_cols] = scaler.transform(\n",
+    "                Xtest.loc[:, numeric_cols])\n",
+    "\n",
+    "        model.fit(Xtrain.loc[:, feat_subset], ytrain)\n",
+    "\n",
+    "        if cv_config.get(\"CALIBRATE\"):\n",
+    "            model = get_calibrated_model(model,\n",
+    "                                         X=Xcal.loc[:, feat_subset],\n",
+    "                                         y=ycal)\n",
+    "\n",
+    "        models.append(model)\n",
+    "\n",
+    "        # accumulate ground-truths\n",
+    "        gts_train.append(ytrain)\n",
+    "        gts_val.append(yval)\n",
+    "\n",
+    "        # accumulate predictions\n",
+    "        train_pred_probas = model.predict_proba(Xtrain.loc[:, feat_subset])[:, 1]\n",
+    "        val_pred_probas = model.predict_proba(Xval.loc[:, feat_subset])[:, 1]\n",
+    "\n",
+    "        probas_train.append(train_pred_probas)\n",
+    "        probas_val.append(val_pred_probas)\n",
+    "\n",
+    "        # identify correct and erroneous predictions according to the\n",
+    "        # classification cut-off that maximizes the Youden's J index\n",
+    "        fpr, tpr, thresholds = roc_curve(ytrain, train_pred_probas)\n",
+    "        idx = np.argmax(tpr - fpr)\n",
+    "        youden = thresholds[idx]\n",
+    "\n",
+    "        labels_val = np.where(val_pred_probas >= youden, 1, 0)\n",
+    "\n",
+    "        # indexes of validation instances misclassified by the model\n",
+    "        error_idxs = Xval[(yval != labels_val)].index\n",
+    "        errors.append(error_idxs)\n",
+    "\n",
+    "        # indexes of correct predictions\n",
+    "        correct.append(Xval[(yval == labels_val)].index)\n",
+    "\n",
+    "    # CV results for current model\n",
+    "    curr_est_results = CVModellingOutput(\n",
+    "        gts_train=gts_train,\n",
+    "        gts_val=gts_val,\n",
+    "        probas_train=probas_train,\n",
+    "        probas_val=probas_val,\n",
+    "        gts_train_conc=np.concatenate(gts_train),\n",
+    "        gts_val_conc=np.concatenate(gts_val),\n",
+    "        probas_train_conc=np.concatenate(probas_train),\n",
+    "        probas_val_conc=np.concatenate(probas_val),\n",
+    "        models=models,\n",
+    "        errors=errors,\n",
+    "        correct=correct,\n",
+    "        features=features\n",
+    "    )\n",
+    "    \n",
+    "    cv_results[model_name] = curr_est_results"
    ]
   },
   {
@@ -270,23 +572,74 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We will now compute median Brier score (95% CI) and use it to annotate the calibration plot."
+    "## Average ROC curves"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 42,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "briers = []\n",
-    "for gt, preds in zip(cv_results[\"gt_val\"], cv_results[\"probas_val\"]):\n",
-    "    brier = brier_score_loss(gt, preds)\n",
-    "    briers.append(brier)\n",
+    "import matplotlib.pyplot as plt\n",
+    "from modelsight.curves import average_roc_curves, roc_comparisons, add_annotations\n",
     "\n",
-    "brier_low, brier_med, brier_up = np.percentile(briers, [2.5, 50, 97.5])\n",
     "\n",
-    "brier_annot = f\"{brier_med:.2f} ({brier_low:.2f} - {brier_up:.2f})\""
+    "model_names = list(cv_results.keys())\n",
+    "alpha = 0.05\n",
+    "alph_str = str(alpha).split(\".\")[1]\n",
+    "alpha_formatted = f\".{alph_str}\"\n",
+    "roc_symbol = \"*\"\n",
+    "palette = [Colors.green2, Colors.blue, Colors.yellow, Colors.violet, Colors.darksalmon]\n",
+    "n_boot = 100\n",
+    "\n",
+    "f, ax = plt.subplots(1, 1, figsize=(8, 8))\n",
+    "\n",
+    "kwargs = dict()\n",
+    "\n",
+    "f, ax, barplot, bars, all_data = average_roc_curves(cv_results,\n",
+    "                                                    colors=palette,\n",
+    "                                                    model_keys=model_names,\n",
+    "                                                    show_ci=True,\n",
+    "                                                    n_boot=n_boot,\n",
+    "                                                    bars_pos=[\n",
+    "                                                        0.3, 0.01, 0.6, 0.075*len(model_names)],\n",
+    "                                                    random_state=cv_config.get(\"SEED\"),\n",
+    "                                                    ax=ax,\n",
+    "                                                    **kwargs)\n",
+    "\n",
+    "roc_comparisons_results = roc_comparisons(cv_results, \"EBM\")\n",
+    "\n",
+    "kwargs = dict(space_between_whiskers = 0.07)\n",
+    "order = [\n",
+    "    (\"EBM\", \"RF\"),\n",
+    "    (\"EBM\", \"SVC\"),\n",
+    "    (\"EBM\", \"LR\"),\n",
+    "    (\"EBM\", \"KNN\")\n",
+    "]\n",
+    "ax_annot = add_annotations(roc_comparisons_results, \n",
+    "                  alpha = 0.05, \n",
+    "                  bars=bars, \n",
+    "                  direction = \"vertical\",\n",
+    "                  order = order,\n",
+    "                  symbol = roc_symbol,\n",
+    "                  symbol_fontsize = 30,\n",
+    "                  voffset = -0.05,\n",
+    "                  ext_voffset=0,\n",
+    "                  ext_hoffset=0,\n",
+    "                  ax=barplot,\n",
+    "                  **kwargs)"
    ]
   },
   {
@@ -294,7 +647,32 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Assess model calibration"
+    "## Model calibration"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will now compute median Brier score (95% CI) of the ExplainableBoostingClassifier and use it to annotate the calibration plot."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.metrics import brier_score_loss\n",
+    "briers = []\n",
+    "for gt, preds in zip(cv_results[\"EBM\"].gts_val, cv_results[\"EBM\"].probas_val):\n",
+    "    brier = brier_score_loss(gt, preds)\n",
+    "    briers.append(brier)\n",
+    "\n",
+    "brier_low, brier_med, brier_up = np.percentile(briers, [2.5, 50, 97.5])\n",
+    "\n",
+    "brier_annot = f\"{brier_med:.2f} ({brier_low:.2f} - {brier_up:.2f})\""
    ]
   },
   {
@@ -307,14 +685,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 52,
+   "execution_count": 39,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 1400x600 with 2 Axes>"
+       "<Figure size 1100x600 with 2 Axes>"
       ]
      },
      "metadata": {},
@@ -325,23 +703,17 @@
     "import matplotlib.pyplot as plt\n",
     "from modelsight.calibration import hosmer_lemeshow_plot\n",
     "\n",
-    "# pool validation ground-truths and predicted probabilities in a long vector\n",
-    "gt_val_conc = np.concatenate(cv_results[\"gt_val\"])\n",
-    "probas_val_conc = np.concatenate(cv_results[\"probas_val\"])\n",
-    "\n",
-    "f, ax = plt.subplots(1, 1, figsize=(14,6))\n",
+    "f, ax = plt.subplots(1, 1, figsize=(11,6))\n",
     "\n",
-    "f, ax = hosmer_lemeshow_plot(gt_val_conc,\n",
-    "                             probas_val_conc,\n",
+    "f, ax = hosmer_lemeshow_plot(cv_results[\"EBM\"].gts_val_conc,\n",
+    "                             cv_results[\"EBM\"].probas_val_conc,\n",
     "                             n_bins=10,\n",
-    "                             colors=('#005CAB', '#FFC325'),\n",
+    "                             colors=(Colors.darksalmon, Colors.green2),\n",
     "                             annotate_bars=True,\n",
     "                             title=\"\",\n",
     "                             brier_score_annot=brier_annot,\n",
     "                             ax=ax\n",
-    "                             )\n",
-    "\n",
-    "plt.show()"
+    "                             )"
    ]
   },
   {

From 47d4cbc859378e7e030bdae2ffeb69d041964f63 Mon Sep 17 00:00:00 2001
From: Francesco Pisu <frapisu9@gmail.com>
Date: Sat, 16 Sep 2023 20:11:31 +0200
Subject: [PATCH 2/2] docs: update example notebook + self-contained python
 script #3

---
 docs/example.ipynb |  35 +++---
 docs/quickstart.py | 278 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 299 insertions(+), 14 deletions(-)
 create mode 100644 docs/quickstart.py

diff --git a/docs/example.ipynb b/docs/example.ipynb
index 8cc9db6..36ed9fe 100644
--- a/docs/example.ipynb
+++ b/docs/example.ipynb
@@ -22,7 +22,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -41,7 +41,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -133,7 +133,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -143,7 +143,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -155,7 +155,7 @@
        "Name: proportion, dtype: float64"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -174,7 +174,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
@@ -213,7 +213,7 @@
        "dtype: int64"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -240,7 +240,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -259,7 +259,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -294,7 +294,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -577,7 +577,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 45,
    "metadata": {},
    "outputs": [
     {
@@ -639,7 +639,11 @@
     "                  ext_voffset=0,\n",
     "                  ext_hoffset=0,\n",
     "                  ax=barplot,\n",
-    "                  **kwargs)"
+    "                  **kwargs)\n",
+    "\n",
+    "\n",
+    "#plt.savefig(\"roc.png\", dpi=300, bbox_inches='tight')\n",
+    "plt.show()"
    ]
   },
   {
@@ -685,7 +689,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 46,
    "metadata": {},
    "outputs": [
     {
@@ -713,7 +717,10 @@
     "                             title=\"\",\n",
     "                             brier_score_annot=brier_annot,\n",
     "                             ax=ax\n",
-    "                             )"
+    "                             )\n",
+    "\n",
+    "#plt.savefig(\"calib.png\", dpi=300, bbox_inches='tight')\n",
+    "plt.show()"
    ]
   },
   {
diff --git a/docs/quickstart.py b/docs/quickstart.py
new file mode 100644
index 0000000..9aa2782
--- /dev/null
+++ b/docs/quickstart.py
@@ -0,0 +1,278 @@
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from sklearn.datasets import load_breast_cancer
+from sklearn.model_selection import train_test_split
+from sklearn.model_selection import StratifiedKFold, RepeatedStratifiedKFold
+from sklearn.metrics import roc_curve, brier_score_loss
+from sklearn.svm import SVC
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.linear_model import LogisticRegression
+from interpret.glassbox import ExplainableBoostingClassifier
+
+from tests.utils import (
+    select_features, 
+    get_feature_selector, 
+    get_calibrated_model
+)
+
+from modelsight.curves import (
+    average_roc_curves, 
+    roc_comparisons, 
+    add_annotations
+)
+from modelsight.calibration import hosmer_lemeshow_plot
+from modelsight._typing import CVModellingOutput, Estimator
+
+# Define factory for binary classifiers
+class BinaryModelFactory:
+    def get_model(self, model_name: str) -> Estimator:
+        if model_name == "EBM":
+            return ExplainableBoostingClassifier(random_state=cv_config.get("SEED"),
+                                        interactions=6,
+                                        learning_rate=0.02,
+                                        min_samples_leaf=5,
+                                        n_jobs=-1)
+        elif model_name == "LR":
+            return LogisticRegression(penalty="elasticnet",
+                                solver="saga",
+                                l1_ratio=0.3,
+                                max_iter=10000,
+                                random_state=cv_config.get("SEED"))
+        elif model_name == "SVC": 
+            return SVC(probability=True, 
+                class_weight="balanced", 
+                random_state=cv_config.get("SEED"))
+        elif model_name == "RF": 
+            return RandomForestClassifier(random_state=cv_config.get("SEED"),
+                                    n_estimators=5,
+                                    max_depth=3,
+                                    n_jobs=-1)
+        elif model_name == "KNN": 
+            return KNeighborsClassifier(n_jobs=-1)        
+        else:
+            raise ValueError(f"{model_name} is not a valid estimator name.")
+
+class Colors:
+    blue = "#4974a5"
+    lightblue = "#b0c4de"
+    salmon = "#ff8c69"
+    lightsalmon = "#FFD1C2"
+    darksalmon = "#e57e5e"
+
+    green2 = "#82B240"
+    charcoal = "#31485D"
+    gray = "#A3BAC3"
+    white = "#EAEBED"
+
+    yellow = "#FFC325"
+    red = "#E31B23"
+    blue = "#005CAB"
+    violet = "#9A348E"
+    
+def run_cv(X, y, models_names, cv_config):
+    # define outer and inner cross-validation schemes
+    outer_cv = RepeatedStratifiedKFold(n_repeats=cv_config.get("N_REPEATS"),
+                                    n_splits=cv_config.get("N_SPLITS"),
+                                    random_state=cv_config.get("SEED"))
+
+    inner_cv = StratifiedKFold(n_splits=cv_config.get("N_SPLITS"),
+                            shuffle=cv_config.get("SHUFFLE"),
+                            random_state=cv_config.get("SEED"))
+
+    # factory and cv results dictionary
+    model_factory = BinaryModelFactory()
+    cv_results = dict()
+
+    for model_name in models_names:
+        print(f"Processing model {model_name}\n")
+
+        gts_train = []
+        gts_val = []
+        probas_train = []
+        probas_val = []
+        gts_train_conc = []
+        gts_val_conc = []
+        probas_train_conc = []
+        probas_val_conc = []
+
+        models = []
+        errors = []
+        correct = []
+        features = []
+            
+        for i, (train_idx, val_idx) in enumerate(outer_cv.split(X, y)):
+            Xtemp, ytemp = X.iloc[train_idx, :], y.iloc[train_idx]
+            Xval, yval = X.iloc[val_idx, :], y.iloc[val_idx]
+
+            if cv_config.get("CALIBRATE"):
+                Xtrain, Xcal, ytrain, ycal = train_test_split(Xtemp, ytemp,
+                                                            test_size=cv_config.get(
+                                                                "CALIB_FRACTION"),
+                                                            stratify=ytemp,
+                                                            random_state=cv_config.get("SEED"))
+            else:
+                Xtrain, ytrain = Xtemp, ytemp
+
+            model = model_factory.get_model(model_name)
+
+            # select features
+            feat_subset = select_features(Xtrain, ytrain,
+                                        selector=get_feature_selector(
+                                            cv_config.get("SEED")),
+                                        cv=inner_cv,
+                                        scale=False,
+                                        frac=1.25)
+            features.append(feat_subset)
+
+            if cv_config.get("SCALE"):
+                numeric_cols = Xtrain.select_dtypes(
+                    include=[np.float64, np.int64]).columns.tolist()
+                scaler = StandardScaler()
+                Xtrain.loc[:, numeric_cols] = scaler.fit_transform(
+                    Xtrain.loc[:, numeric_cols])
+                Xtest.loc[:, numeric_cols] = scaler.transform(
+                    Xtest.loc[:, numeric_cols])
+
+            model.fit(Xtrain.loc[:, feat_subset], ytrain)
+
+            if cv_config.get("CALIBRATE"):
+                model = get_calibrated_model(model,
+                                            X=Xcal.loc[:, feat_subset],
+                                            y=ycal)
+
+            models.append(model)
+
+            # accumulate ground-truths
+            gts_train.append(ytrain)
+            gts_val.append(yval)
+
+            # accumulate predictions
+            train_pred_probas = model.predict_proba(Xtrain.loc[:, feat_subset])[:, 1]
+            val_pred_probas = model.predict_proba(Xval.loc[:, feat_subset])[:, 1]
+
+            probas_train.append(train_pred_probas)
+            probas_val.append(val_pred_probas)
+
+            # identify correct and erroneous predictions according to the
+            # classification cut-off that maximizes the Youden's J index
+            fpr, tpr, thresholds = roc_curve(ytrain, train_pred_probas)
+            idx = np.argmax(tpr - fpr)
+            youden = thresholds[idx]
+
+            labels_val = np.where(val_pred_probas >= youden, 1, 0)
+
+            # indexes of validation instances misclassified by the model
+            error_idxs = Xval[(yval != labels_val)].index
+            errors.append(error_idxs)
+
+            # indexes of correct predictions
+            correct.append(Xval[(yval == labels_val)].index)
+
+        # CV results for current model
+        curr_est_results = CVModellingOutput(
+            gts_train=gts_train,
+            gts_val=gts_val,
+            probas_train=probas_train,
+            probas_val=probas_val,
+            gts_train_conc=np.concatenate(gts_train),
+            gts_val_conc=np.concatenate(gts_val),
+            probas_train_conc=np.concatenate(probas_train),
+            probas_val_conc=np.concatenate(probas_val),
+            models=models,
+            errors=errors,
+            correct=correct,
+            features=features
+        )
+        
+        cv_results[model_name] = curr_est_results
+        
+    return cv_results
+    
+if __name__ == "__main__":
+    cv_config = {
+        "N_REPEATS": 2,
+        "N_SPLITS": 10,
+        "SHUFFLE": True,
+        "SCALE": False,
+        "CALIBRATE": True,
+        "CALIB_FRACTION": 0.15,
+        "SEED": 1303
+    }
+    
+    # Load data
+    X, y = load_breast_cancer(return_X_y=True, as_frame=True)
+    models_names = ["EBM", "LR", "SVC", "RF", "KNN"]
+    cv_results = run_cv(X, y, models_names, cv_config)
+    
+    # average ROC plot
+    model_names = list(cv_results.keys())
+    alpha = 0.05
+    alph_str = str(alpha).split(".")[1]
+    alpha_formatted = f".{alph_str}"
+    roc_symbol = "*"
+    palette = [Colors.green2, Colors.blue, Colors.yellow, Colors.violet, Colors.darksalmon]
+    n_boot = 100
+
+    f, ax = plt.subplots(1, 1, figsize=(8, 8))
+
+    kwargs = dict()
+
+    f, ax, barplot, bars, all_data = average_roc_curves(cv_results,
+                                                        colors=palette,
+                                                        model_keys=model_names,
+                                                        show_ci=True,
+                                                        n_boot=n_boot,
+                                                        bars_pos=[
+                                                            0.3, 0.01, 0.6, 0.075*len(model_names)],
+                                                        random_state=cv_config.get("SEED"),
+                                                        ax=ax,
+                                                        **kwargs)
+
+    roc_comparisons_results = roc_comparisons(cv_results, "EBM")
+
+    kwargs = dict(space_between_whiskers = 0.07)
+    order = [
+        ("EBM", "RF"),
+        ("EBM", "SVC"),
+        ("EBM", "LR"),
+        ("EBM", "KNN")
+    ]
+    ax_annot = add_annotations(roc_comparisons_results, 
+                    alpha = 0.05, 
+                    bars=bars, 
+                    direction = "vertical",
+                    order = order,
+                    symbol = roc_symbol,
+                    symbol_fontsize = 30,
+                    voffset = -0.05,
+                    ext_voffset=0,
+                    ext_hoffset=0,
+                    ax=barplot,
+                    **kwargs)
+    plt.show()
+    
+    # assess calibration after cv
+    briers = []
+    for gt, preds in zip(cv_results["EBM"].gts_val, cv_results["EBM"].probas_val):
+        brier = brier_score_loss(gt, preds)
+        briers.append(brier)
+
+    brier_low, brier_med, brier_up = np.percentile(briers, [2.5, 50, 97.5])
+
+    brier_annot = f"{brier_med:.2f} ({brier_low:.2f} - {brier_up:.2f})"
+
+    f, ax = plt.subplots(1, 1, figsize=(11,6))
+
+    f, ax = hosmer_lemeshow_plot(cv_results["EBM"].gts_val_conc,
+                                cv_results["EBM"].probas_val_conc,
+                                n_bins=10,
+                                colors=(Colors.darksalmon, Colors.green2),
+                                annotate_bars=True,
+                                title="",
+                                brier_score_annot=brier_annot,
+                                ax=ax
+                                )
+    
+    plt.show()
\ No newline at end of file