simulation_stratified_cross_val7.0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Stratified cross-validation for unbiased and privacy-preserving federated learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook we study cross-validation of a model when data is distributed in many data warehouses and is analyzed using federated learning. We consider in particular the recurrent problem related to the presence of duplicates of individuals' records. These duplicates are difficult to detect and to clean in a federated learning setting inducing possible data leakage between training and validation datasets that causes over-optimistic estimates of performances. \n",
    "\n",
    "Hereafter we generate synthetic datasets with duplicates and fit XGBoost models on them. Our datasets are made of records $(\\mathbf{x}, y)$ with $\\mathbf{x} = (x_1, x_2, ..., x_{10})$ real covariates and $y\\in\\{0,1\\}$ a binary output. We consider the training of a model $f$ that computes a predicted output $\\tilde{y}=f(\\mathbf{x})$. We consider as performance metric the accuracy $Accuracy = \\mathbb{E}I(y=\\tilde{y})$ with $I(A)$ a function that is equal to 1 when $A$ is true and 0 otherwise.\n",
    "\n",
    "We measure training and validation performances using cross-validation. In the absence of duplicates, partitioning randomly the dataset in folds and applying cross-validation on these folds provides *unbiased estimates* of accuracy. In the presence of duplicates we consider *stratified cross-validation* that consists in partitioning the dataset in folds containing individuals that share similar values of a stratifying covariate $x_{str}$ and in applying cross-validation on these folds. *Stratified cross-validation* avoids over-optimistic biases due to data leakage, but may cause pessimistic biases due to inter-fold heterogeneities. As shown in these simulations, a judicious choice of stratification strategy limits this pessimistic bias and provides a validation methodology that is well suited to federated learning setting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "import scipy\n",
    "import xgboost as xgb\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n",
    "\n",
    "# Seed the random generator\n",
    "np.random.seed(123)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dataset generators\n",
    "We define functions that will be used to generate datasets of various sizes, amounts of duplicates and that can be partitioned in folds adopting different dataset partitioning strategies.\n",
    "\n",
    "Each covariate vector is generated through a centered normal distribution of mean $[\\mu_1, \\mu_2, ..., \\mu_{10}]=[0, 0, ..., 0]$ and of covariance matrix $\\Sigma$:\n",
    "\n",
    "$$\n",
    "\\left[\\begin{array}{c} x_1 \\\\ x_2 \\\\ ... \\\\ x_{10} \\end{array}\\right]= \\mathcal{N}\\left(\\left[\\begin{array}{c} \\mu_1 \\\\ \\mu_2 \\\\ ... \\\\ \\mu_{10} \\end{array}\\right], \\Sigma \\right)\n",
    "$$\n",
    "\n",
    "The covariance matrix $\\Sigma$ is generated as to obtain 9 correlated covariates $x_1$, $x_2$,...$x_9$ and an independent covariate $x_{10}$. For each covariate vector we generate randomly an outcome $y$ through a logistic model that reproduces a highly non-linear association:\n",
    "\n",
    "$$\n",
    "\\log\\frac{p\\big(y=1 | x_1,..., x_{10}\\big)}{p\\big(y=0 | x_1,..., x_{10}\\big)}= a_0 +a_1 x_1 +a_2 x_2 + a_3 x_3 + a_{4}x_1 x_2 + a_{5}x_3I(x_4>0) + a_{6}x_5^2 I(x_6>0) + a_7 x_7 I(x_8 x_9>0)\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Raw data generator\n",
    "Generator of a dataset without duplicates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f_indic(x):\n",
    "    res = 0\n",
    "    if x>0:\n",
    "        res = 1\n",
    "    return res\n",
    "\n",
    "def f_model(x_vec, a_vec):\n",
    "    res = a_vec[0] + a_vec[1]*x_vec[0] + a_vec[2]*x_vec[1] + a_vec[3]*x_vec[2] \\\n",
    "        + a_vec[4]*x_vec[0]*x_vec[1] + a_vec[5]*x_vec[2]*f_indic(x_vec[3]) + a_vec[6]*x_vec[4]**2*f_indic(x_vec[5]) \\\n",
    "        + a_vec[7]*x_vec[6]*f_indic(x_vec[7]*x_vec[8])\n",
    "    return res\n",
    "\n",
    "def logistic_f(x):\n",
    "    res = 1/(1+np.exp(-x))\n",
    "    return res\n",
    "\n",
    "def prob_outcome(x_vec, a_vec):\n",
    "        \"\"\"\n",
    "        Probability of an outcome y=1 given a covariate vector x_vec\n",
    "        and a parameter vector a_vec\n",
    "        \"\"\"\n",
    "        res = f_model(x_vec, a_vec)\n",
    "        res = logistic_f(res)\n",
    "        return res\n",
    "    \n",
    "def raw_data_generator(param_data):\n",
    "    \"\"\"\n",
    "    Function that simulates a dataset without duplicates\n",
    "    Each record is randomly associated with one of the hospitals, with\n",
    "    equal probablity.\n",
    "    \n",
    "    Inputs:\n",
    "    - param_data: dictionnary of parameters defining the data generation\n",
    "\n",
    "    Outputs:\n",
    "    - x_arr: array of covariates (row: records, column: covariates)\n",
    "    - y_arr: array of outcomes\n",
    "    - h_arr: array of hospital indexes\n",
    "    \"\"\"\n",
    "    # Number of patients\n",
    "    num_pat = param_data['num_pat']\n",
    "    \n",
    "    # Number of hospitals\n",
    "    num_h = param_data['num_h']\n",
    "    \n",
    "    # Data generation parameters\n",
    "    a_vec = param_data['a_vec']\n",
    "    sigma = param_data['sigma']\n",
    "    \n",
    "    # Mean of the normal distribution used to generate covariates:\n",
    "    mean = np.zeros(10)\n",
    "    \n",
    "    # Each patient is assigned randomly to an hospital\n",
    "    h_arr = np.random.rand(num_pat)\n",
    "    h_arr = np.floor(h_arr*num_h)\n",
    "    h_arr = h_arr.astype(int)\n",
    "        \n",
    "    # Random generation of covariates\n",
    "    x_arr = np.random.multivariate_normal(mean, sigma, num_pat)\n",
    "\n",
    "    # Random generation of outcomes\n",
    "    func_prob = lambda x_vec : prob_outcome(x_vec, a_vec)\n",
    "    prob = np.apply_along_axis(func_prob, 1, x_arr)\n",
    "    rand_m = np.random.rand(num_pat)\n",
    "    condition = rand_m<prob\n",
    "    y_arr = np.where(condition,1,0).astype(int)\n",
    "        \n",
    "    return x_arr, y_arr, h_arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Duplicates generator\n",
    "A function that adds duplicates to a dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def duplicates_generator(param_data, x_arr, y_arr, h_arr):\n",
    "    \"\"\"\n",
    "    Function that completes a data array with duplicates\n",
    "    \n",
    "    Inputs:\n",
    "    - param_data: dictionary of parameters defining the data generation\n",
    "    - x_arr: array of covariates (row: record, column: covariates)\n",
    "    - y_arr: array of outcomes\n",
    "    - h_arr: array of hospital indexes\n",
    "    \n",
    "    Outputs:\n",
    "    - x_arr: array of covariates (row: records, column: covariates) with duplicates\n",
    "    - y_arr: array of outcomes with duplicates\n",
    "    - h_arr: array of hospital indexes with duplicates\n",
    "    \"\"\"\n",
    "    # Number of patients\n",
    "    num_pat = param_data['num_pat']\n",
    "    \n",
    "    # Number of duplicated records\n",
    "    num_dup = param_data['num_dup']\n",
    "    \n",
    "    # Number of hospitals\n",
    "    num_h = param_data['num_h']\n",
    "    \n",
    "    assert y_arr.shape[0] == num_pat, \"Wrong outcome array {}\"\n",
    "    assert h_arr.shape[0] == num_pat, \"Wrong hospital array\"\n",
    "    \n",
    "    # Create an array used to ensure that two duplicates are never in the same \n",
    "    # hospital\n",
    "    control_duplicates = np.zeros((num_pat, num_h), dtype=int)\n",
    "    for id_pat in range(num_pat):\n",
    "        id_h = h_arr[id_pat]\n",
    "        control_duplicates[id_pat, id_h] = 1\n",
    "    def is_patient_in_h(id_pat, id_h):\n",
    "        return control_duplicates[id_pat, id_h] == 1\n",
    "    \n",
    "    # Add duplicates\n",
    "    count_dup = 0\n",
    "    x_arr_dup = np.zeros((num_dup, x_arr.shape[1]), dtype=float)\n",
    "    h_arr_dup = np.zeros(num_dup, dtype=int)\n",
    "    y_arr_dup = np.zeros(num_dup, dtype=int)\n",
    "    while count_dup < num_dup:\n",
    "        # Draw an existing record at random\n",
    "        randnum = np.random.rand()\n",
    "        id_pat = int(np.floor(randnum * num_pat))\n",
    "        assert id_pat < num_pat\n",
    "        \n",
    "        # Draw randomly a hospital in which to duplicate the record\n",
    "        randnum = np.random.rand()\n",
    "        id_h = int(np.floor(randnum * num_h))\n",
    "        assert id_h < num_h\n",
    "        \n",
    "        # Control that a duplicate of this record does not already exist in\n",
    "        # the given hospital\n",
    "        if not is_patient_in_h(id_pat, id_h):\n",
    "            x_arr_dup[count_dup, :] = x_arr[id_pat, :]            \n",
    "            y_arr_dup[count_dup] = y_arr[id_pat]\n",
    "            h_arr_dup[count_dup] = id_h\n",
    "            count_dup += 1\n",
    "    \n",
    "    # Add duplicates to existing datasets\n",
    "    x_arr_res = np.concatenate((x_arr, x_arr_dup))\n",
    "    y_arr_res = np.concatenate((y_arr, y_arr_dup))\n",
    "    h_arr_res = np.concatenate((h_arr, h_arr_dup))\n",
    "            \n",
    "    return x_arr_res, y_arr_res, h_arr_res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random/stratified splitting of records in folds\n",
    "Functions that split a dataset in folds using either the *random* or the *stratified* fold-partitioning strategy "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_splitting(param_data, param_split, x_arr, y_arr, h_arr):\n",
    "    \"\"\"\n",
    "    Function that splits randomly the records in folds of equal size (per\n",
    "    hospital)\n",
    "    \n",
    "    Inputs:\n",
    "    - param_data: dictionary of parameters defining the data generation\n",
    "    - param_split: dictionary of parameters defining the data splitting\n",
    "    - x_arr: array of covariates (row: record, column: covariates)\n",
    "    - y_arr: array of outcomes \n",
    "    - h_arr: array of hospital indexes\n",
    "    \n",
    "    Outputs:\n",
    "    - f_arr: array of fold indexes\n",
    "    \"\"\"\n",
    "    # Number of patients\n",
    "    num_pat = param_data['num_pat']\n",
    "    \n",
    "    # Number of duplicated records\n",
    "    num_dup = param_data['num_dup']\n",
    "    \n",
    "    # Number of hospitals\n",
    "    num_h = param_data['num_h']\n",
    "    \n",
    "    # Number of folds\n",
    "    num_f = param_split['num_f']\n",
    "    \n",
    "    # Array containing the fold index of each record\n",
    "    f_arr = np.zeros(num_pat + num_dup, dtype=int)\n",
    "    assert f_arr.shape[0] == x_arr.shape[0], \"Wrong f_arr shape\"\n",
    "    \n",
    "    # Count the number of records per hospital\n",
    "    num_rec = num_pat + num_dup\n",
    "    count_h = np.zeros(num_h, dtype=int)\n",
    "    for id_rec in range(num_rec):\n",
    "        id_h = h_arr[id_rec]\n",
    "        count_h[id_h] += 1\n",
    "    \n",
    "    # Compute the number of records that each fold will\n",
    "    # contain, splitting each hospital dataset in equally sized folds\n",
    "    num_rec_f = np.zeros((num_h, num_f), dtype=int)\n",
    "    for id_h in range(num_h):\n",
    "        num_rec_h = count_h[id_h]\n",
    "        \n",
    "        # Each folds contains at least the quotient of the \n",
    "        # euclidian division of the number of records by\n",
    "        # the number of folds\n",
    "        quotient = int(np.floor(num_rec_h / num_f))\n",
    "        num_rec_f[id_h, :] = quotient\n",
    "        rem_n = num_rec_h - quotient * num_f\n",
    "        assert rem_n < num_f, \"Problem during fold splitting\"\n",
    "\n",
    "        # Distribute randomly the remaining records among the hospitals\n",
    "        count_rem_f = np.zeros(num_f, dtype=int)\n",
    "        while rem_n > 0:\n",
    "            randnum = np.random.rand()\n",
    "            id_f = int(np.floor(randnum * num_f))\n",
    "            assert id_f < num_f\n",
    "            \n",
    "            if count_rem_f[id_f] == 0:\n",
    "                num_rec_f[id_h, id_f] += 1\n",
    "                rem_n -= 1\n",
    "                count_rem_f[id_f] += 1\n",
    "            \n",
    "    # Randomly assign each record to a fold in such a way that it\n",
    "    # fulfills the required number of records per fold per hospital\n",
    "    \n",
    "    # Create an array that stores the amount of records assigned to\n",
    "    # each fold, and create a function to test whether a fold\n",
    "    # is full or not\n",
    "    count_rec_f = np.zeros((num_h, num_f), dtype=int)\n",
    "    def is_fold_full(id_h, id_f):\n",
    "        return count_rec_f[id_h, id_f]==num_rec_f[id_h, id_f]\n",
    "    \n",
    "    # Assign each record randomly to a fold that is not full\n",
    "    for id_rec in range(num_rec):\n",
    "        id_h = h_arr[id_rec]\n",
    "        \n",
    "        assigned = False\n",
    "        while not assigned:\n",
    "            randnum = np.random.rand()\n",
    "            id_f = int(np.floor(randnum * num_f))\n",
    "            if not is_fold_full(id_h, id_f):\n",
    "                f_arr[id_rec] = id_f\n",
    "                count_rec_f[id_h, id_f] += 1\n",
    "                assigned = True\n",
    "                \n",
    "    return f_arr\n",
    "\n",
    "\n",
    "def stratified_splitting(param_data, param_split, x_arr, y_arr, h_arr):\n",
    "    \"\"\"\n",
    "    Function that splits the records in folds stratifying \n",
    "    along a covariate\n",
    "    \n",
    "    Inputs:\n",
    "    - param_data: dictionary of parameters defining the data generation\n",
    "    - param_split: dictionary of of parameters defining the data splitting\n",
    "    - x_arr: array of covariates (row: record, column: covariates)\n",
    "    - y_arr: array of outcomes for each record\n",
    "    - h_arr: array of hospital index for each record\n",
    "\n",
    "    Outputs:\n",
    "    - f_arr: empty array of fold indexes\n",
    "    \"\"\"\n",
    "    # Number of patients\n",
    "    num_pat = param_data['num_pat']\n",
    "    \n",
    "    # Number of duplicated records\n",
    "    num_dup = param_data['num_dup']\n",
    "    \n",
    "    # Number of hospitals\n",
    "    num_h = param_data['num_h']\n",
    "    \n",
    "    # Number of folds\n",
    "    num_f = param_split['num_f']\n",
    "    \n",
    "    # Index of the fold used for validation\n",
    "    id_str = param_split['stratifying_covariate_id']\n",
    "    \n",
    "    # Total number of records\n",
    "    num_rec = num_pat + num_dup\n",
    "    \n",
    "    # Array containing the fold index of each record\n",
    "    f_arr = np.zeros(num_pat + num_dup, dtype=int)\n",
    "    assert f_arr.shape[0] == x_arr.shape[0]\n",
    "    \n",
    "    # Array containing all the values of the stratifying covariate\n",
    "    str_arr = x_arr[:, id_str]\n",
    "        \n",
    "    # Sorting of the stratifying covariates\n",
    "    str_arr = np.sort(str_arr)\n",
    "    \n",
    "    # Computing the size of each global fold\n",
    "    fold_size = np.zeros(num_f, dtype=int)\n",
    "    quotient = int(np.floor(num_rec / num_f))\n",
    "    fold_size[:] = quotient\n",
    "    rem_n = num_rec - quotient * num_f\n",
    "    assert rem_n < num_f\n",
    "\n",
    "    count_rem_f = np.zeros(num_f, dtype=int)\n",
    "    while rem_n > 0:\n",
    "        randnum = np.random.rand()\n",
    "        id_f = int(np.floor(randnum * num_f))\n",
    "        assert id_f < num_f\n",
    "\n",
    "        if count_rem_f[id_f] == 0:\n",
    "            fold_size[id_f] += 1\n",
    "            rem_n -= 1\n",
    "            count_rem_f[id_f] += 1\n",
    "    \n",
    "    # Compute the thresholds t for stratification such that each global \n",
    "    # fold contains approximately the same number of records\n",
    "    thresh_arr = np.zeros(num_f - 1, dtype=float)\n",
    "    fold_count = 0\n",
    "    for id_lim in range(num_f - 1):\n",
    "        fold_count += fold_size[id_lim]\n",
    "        \n",
    "        # Lower limit required for the threshold\n",
    "        val_low = str_arr[fold_count-1]\n",
    "        \n",
    "        # Upper limit required for the threshold\n",
    "        val_up = str_arr[fold_count]\n",
    "        \n",
    "        # Threshold definition as the intermediate value\n",
    "        thresh_arr[id_lim] = 0.5*(val_low + val_up)\n",
    "        \n",
    "    # Assign each record to a fold depending on the value of its \n",
    "    # stratifying covariate\n",
    "    for id_rec in range(num_rec):\n",
    "        # Record's stratifying covariate\n",
    "        cov_str = x_arr[id_rec, id_str]\n",
    "        \n",
    "        # Find the threshold index that corresponds to the record\n",
    "        # and assign the record to the corresponding fold\n",
    "        for count_f in range(num_f-1):\n",
    "            thresh = thresh_arr[count_f]\n",
    "            if cov_str < thresh:\n",
    "                f_arr[id_rec] = count_f\n",
    "                break\n",
    "            \n",
    "            # If the record has not been assigned to the first num_f-1\n",
    "            # folds, assign it to the last fold\n",
    "            if count_f == num_f-2:\n",
    "                f_arr[id_rec] = count_f+1\n",
    "            \n",
    "    return f_arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Training / validation dataset creation for a given fold index\n",
    "A function that splits a dataset in training and validation subsets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_val_building(param_data, param_split, x_arr, y_arr, f_arr, id_val_fold):\n",
    "    \"\"\"\n",
    "    Function that builds training and validation datasets out of a dataset\n",
    "    that is already split in folds\n",
    "    \n",
    "    Inputs:\n",
    "    - param_data: dictionary of parameters defining the data generation\n",
    "    - param_split: dictionary of parameters defining the data splitting\n",
    "    - x_arr: array of covariates (row: record, column: covariates)\n",
    "    - y_arr: array of outcomes\n",
    "    - f_arr: array of fold indexes\n",
    "    - id_val_fold: index of the fold used for validation\n",
    "    \n",
    "    Outputs:\n",
    "    - x_train\n",
    "    - y_train\n",
    "    - x_val\n",
    "    - y_val\n",
    "    \"\"\"\n",
    "    # Number of patients\n",
    "    num_pat = param_data['num_pat']\n",
    "    \n",
    "    # Number of duplicated records\n",
    "    num_dup = param_data['num_dup']\n",
    "    \n",
    "    # Number of folds\n",
    "    num_f = param_split['num_f']\n",
    "    \n",
    "    # Number of records\n",
    "    num_rec = num_pat + num_dup\n",
    "    \n",
    "    # Number of training and validation records\n",
    "    num_train = np.count_nonzero(f_arr!=id_val_fold)\n",
    "    num_val = np.count_nonzero(f_arr==id_val_fold)\n",
    "    assert num_train+num_val==num_rec, \"prob train val split\"\n",
    "            \n",
    "    # Create training and validation numpy arrays\n",
    "    val_boolean_mask = f_arr == id_val_fold\n",
    "    x_val = x_arr[val_boolean_mask,:]\n",
    "    y_val = y_arr[val_boolean_mask]\n",
    "    train_boolean_mask = f_arr != id_val_fold\n",
    "    x_train = x_arr[train_boolean_mask,:]\n",
    "    y_train = y_arr[train_boolean_mask]\n",
    "    assert x_train.shape[0]+x_val.shape[0]==num_rec, \"prob train val split\"\n",
    "    assert y_train.shape[0]+y_val.shape[0]==num_rec, \"prob train val split\"\n",
    "    \n",
    "    # Shuffle arrays\n",
    "    permutation = np.random.permutation(num_train)\n",
    "    x_train = x_train[permutation, :]\n",
    "    y_train = y_train[permutation]\n",
    "    permutation = np.random.permutation(num_val)\n",
    "    x_val = x_val[permutation, :]\n",
    "    y_val = y_val[permutation]\n",
    "\n",
    "    return x_train, y_train, x_val, y_val"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gradient Boosting fitting\n",
    "A function that fits a gradient boosting model to a dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model):\n",
    "    \"\"\"\n",
    "    A function that fits a XGBoost model using cross validation on a dataset\n",
    "    that has already been partitioned in folds\n",
    "    \n",
    "    Inputs:\n",
    "    - param_data: dictionary of parameters defining the data generation\n",
    "    - param_split: dictionary of parameters defining the data splitting\n",
    "    - x_arr: array of covariates (row: record, column: covariates)\n",
    "    - y_arr: array of outcomes\n",
    "    - f_arr: array of fold indexes\n",
    "    \n",
    "    Outputs:\n",
    "    - train_acc_list: list of training accuracies computed for each fold\n",
    "    - val_acc_list: list of validation accuracies computed for each fold\n",
    "    - feature_importance_list: list of feature importance computed for each fold\n",
    "    \"\"\"\n",
    "    # Number of folds\n",
    "    num_f = param_split['num_f']\n",
    "    \n",
    "    # Number of boosting iterations\n",
    "    n_round = param_model['num_round']\n",
    "    \n",
    "    # Train accuray list\n",
    "    train_acc_list = []\n",
    "    \n",
    "    # Validation accuracy list\n",
    "    val_acc_list = []\n",
    "    \n",
    "    # Feature importance list\n",
    "    feature_importance_list = []\n",
    "    \n",
    "    # Successive training and validation on each one of the num_f folds\n",
    "    for id_f in range(num_f):\n",
    "        x_train, y_train, x_val, y_val = train_val_building(param_data, param_split, x_arr, y_arr, f_arr, id_f)\n",
    "\n",
    "        dM_train = xgb.DMatrix(x_train, label=y_train)\n",
    "        dM_val = xgb.DMatrix(x_val, label=y_val)\n",
    "\n",
    "        evallist = [(dM_val, 'val'), (dM_train, 'train')]\n",
    "\n",
    "        monitoring = dict()\n",
    "        bst = xgb.train(param_model, dM_train, n_round, evallist, evals_result = monitoring, verbose_eval=False)\n",
    "\n",
    "        if param_model['eval_metric']=='error':\n",
    "            train_err = monitoring['train']['error']\n",
    "            val_err = monitoring['val']['error']\n",
    "            \n",
    "            # Transform error in accuracy\n",
    "            train_acc = 1-np.asarray(train_err)\n",
    "            val_acc = 1-np.asarray(val_err)\n",
    "            \n",
    "            # Add per-fold results to global list\n",
    "            train_acc_list.append(train_acc)\n",
    "            val_acc_list.append(val_acc)\n",
    "        elif param_model['eval_metric']=='auc':\n",
    "            train_auc = monitoring['train']['auc']\n",
    "            val_auc = monitoring['val']['auc']\n",
    "            \n",
    "            # Add per-fold results to global list\n",
    "            train_acc_list.append(train_auc)\n",
    "            val_acc_list.append(val_auc)\n",
    "\n",
    "        # Extract each feature importance\n",
    "        feat_imp = bst.get_score(importance_type='gain')\n",
    "        feature_importance_list.append(feat_imp)\n",
    "        \n",
    "            \n",
    "    return train_acc_list, val_acc_list, feature_importance_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preliminary tests\n",
    "Before running large-scale simulation we test that our experiment-generating functions work on some specific examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initial data exploration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 20 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Parameters for data generation\n",
    "a_vec = [-2, 0.4, 0.8, 1.2, 0.4, 1.2,3.0,2.0]\n",
    "## Eigenvalues of the covariance matrix\n",
    "lambda_vec = [1.0,1.2,1.4,1.6,1.8,2.0,2.2,2.4,2.6]\n",
    "lambda_10 = 2.8\n",
    "## Random orthogonal matrix\n",
    "O = scipy.stats.ortho_group.rvs(9)\n",
    "## Covariance matrix\n",
    "sigma_prime = np.dot(O, np.dot(np.diag(lambda_vec), np.transpose(O)))\n",
    "sigma = scipy.linalg.block_diag(sigma_prime, lambda_10)\n",
    "## Number of patients\n",
    "num_pat = 10000\n",
    "## Number of duplicates\n",
    "num_dup = 0\n",
    "## Number of hospitals\n",
    "num_h = 1\n",
    "\n",
    "param_data = {'num_pat':num_pat, 'num_dup':num_dup, 'num_h':num_h, 'a_vec':a_vec, 'sigma':sigma}\n",
    "\n",
    "# Raw data generation\n",
    "x_arr, y_arr, _ = raw_data_generator(param_data)\n",
    "\n",
    "# function measuring the probability of a positive outcome\n",
    "func_prob_loc = lambda x_vec : prob_outcome(x_vec, a_vec)\n",
    "\n",
    "# Vector containing the probability of a positive outcome for each record\n",
    "p1_arr = np.apply_along_axis(func_prob_loc, 1, x_arr)\n",
    "\n",
    "# Vector containing the optimal prediction to maximize the accuracy\n",
    "pred_opt = p1_arr>0.5\n",
    "pred_opt = pred_opt.reshape((num_pat,1))\n",
    "\n",
    "tot_arr = np.concatenate((x_arr, pred_opt), axis=1)\n",
    "\n",
    "# Plotting of some of the dataset characteristics\n",
    "df = pd.DataFrame(tot_arr, columns=[\"x1\", \"x2\", \"x3\", \"x4\", \\\n",
    "                                    \"x5\", \"x6\", \"x7\", \"x8\", \\\n",
    "                                    \"x9\", \"x10\", \"pred\"])\n",
    "df = df.astype({\"pred\": 'int32'})\n",
    "sns.set(style=\"white\", font_scale = 1.4)\n",
    "df_positive = df.loc[df[\"pred\"]==1]\n",
    "\n",
    "g = sns.PairGrid(df_positive, x_vars=[\"x1\",\"x3\",\"x5\",\"x10\"],y_vars=[\"x1\", \"x3\", \"x5\",\"x10\"])\n",
    "g.map_diag(sns.kdeplot)\n",
    "g.map_upper(plt.scatter, alpha=0.1)\n",
    "\n",
    "from matplotlib.colors import LogNorm\n",
    "def pairgrid_heatmap(x, y, **kws):\n",
    "    sns.kdeplot(x, y, shade=True, shade_lowest=True)\n",
    "\n",
    "g.map_lower(pairgrid_heatmap)\n",
    "\n",
    "plt.subplots_adjust(top=0.9)\n",
    "g.fig.suptitle(\"Positive outcome\")\n",
    "\n",
    "plt.savefig('SF_Fig1.pdf', bbox_inches=\"tight\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Optimal accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal accuracy: 0.881395\n"
     ]
    }
   ],
   "source": [
    "### Number of patients\n",
    "num_pat = 1000000\n",
    "### Number of duplicates\n",
    "num_dup = 0\n",
    "### Number of hospitals\n",
    "num_h = 1\n",
    "\n",
    "param_data = {'num_pat':num_pat, 'num_dup':num_dup, 'num_h':num_h, 'a_vec':a_vec, 'sigma':sigma}\n",
    "\n",
    "x_arr, y_arr, _ = raw_data_generator(param_data)\n",
    "\n",
    "# Probability of positive outcome measurement\n",
    "p1_arr = np.apply_along_axis(func_prob_loc, 1, x_arr)\n",
    "pred_opt = p1_arr>0.5\n",
    "\n",
    "acc_opt = np.mean(pred_opt==y_arr)\n",
    "print(\"Optimal accuracy: {}\".format(acc_opt))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test 1: random partitioning\n",
    "We apply classical cross-validation to a dataset containing duplicates. Partitioning randomly the dataset in folds does not prevent data leakage, as duplicates of a given record can be present simultaneously in training and validation folds. The estimated validation performances are consequently over-optimistic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of positive outcome: 0.46658333333333335\n",
      "Maximal values of covariates: [5.48690759 4.78149299 5.66096344 6.06797576 5.05067452 4.87382256\n",
      " 4.93824278 6.57789821 5.02249825 6.50422897]\n",
      "Minimal values of covariates: [-4.81026034 -5.01434916 -4.56376838 -4.98768103 -5.69858378 -4.78032954\n",
      " -4.54054395 -5.7536598  -5.3236097  -6.70878709]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Over-optimistic validation (data leakage)')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Data generation\n",
    "# Number of patients\n",
    "num_pat = 10000\n",
    "# Number of duplicates\n",
    "num_dup = 2000\n",
    "# Number of hospitals\n",
    "num_h = 5\n",
    "param_data = {'num_pat':num_pat, 'num_dup':num_dup, 'num_h':num_h, 'a_vec':a_vec, 'sigma':sigma}\n",
    "\n",
    "## Data splitting\n",
    "# Splitting strategy (stratified or random)\n",
    "split_strat = 'random'\n",
    "# Number of folds for cross validation\n",
    "num_f = 5\n",
    "# Stratigying covariate (only used for stratified cross validation)\n",
    "stratifying_covariate_id = 9\n",
    "param_split = {'split_strat':split_strat, 'num_f':num_f, 'stratifying_covariate_id':stratifying_covariate_id}\n",
    "\n",
    "## Model fitting\n",
    "fit_model = 'GB'\n",
    "max_depth = 3\n",
    "eta = 0.6\n",
    "objective = 'binary:logistic'\n",
    "eval_metric = 'error'\n",
    "num_round = 200\n",
    "param_model = {'fit_model':fit_model, 'max_depth':max_depth, 'eta':eta, 'objective':objective, 'eval_metric':eval_metric, \n",
    "              'num_round':num_round}\n",
    "\n",
    "## Data characterization\n",
    "# Raw data generation\n",
    "x_arr, y_arr, h_arr = raw_data_generator(param_data)\n",
    "# Insertion of duplicates\n",
    "x_arr, y_arr, h_arr = duplicates_generator(param_data, x_arr, y_arr, h_arr)\n",
    "# Print proportion of positive outcome\n",
    "prop_outcome = np.sum(y_arr)/len(y_arr)\n",
    "print(\"Proportion of positive outcome: {}\".format(prop_outcome))\n",
    "\n",
    "# Print maximal values\n",
    "max_values = np.amax(x_arr, axis=0)\n",
    "print(\"Maximal values of covariates: {}\".format(max_values))\n",
    "\n",
    "# Print minimal values\n",
    "min_values = np.amin(x_arr, axis=0)\n",
    "print(\"Minimal values of covariates: {}\".format(min_values))\n",
    "\n",
    "f_arr = random_splitting(param_data, param_split, x_arr, y_arr, h_arr)\n",
    "train_acc, val_acc, feat_imp = GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model)\n",
    "# Number of training curves (correspond to each training on a subset during cross-validation)\n",
    "num_curve = len(train_acc)\n",
    "num_feat_importance = len(feat_imp)\n",
    "epochs = len(train_acc[0])\n",
    "\n",
    "x_plt = np.linspace(0, epochs, epochs)\n",
    "\n",
    "for id_curve in range(num_curve):\n",
    "    if id_curve==0:\n",
    "        x_scat = [x_plt[index] for index in range(len(x_plt)) if (index+id_curve)%6==0]\n",
    "        y_scat = [train_acc[id_curve][index] for index in range(len(x_plt)) if (index+id_curve)%6==0]\n",
    "        plt.scatter(x_scat, y_scat, label='per-fold train', color='tab:red', marker='o', s=50)\n",
    "        plt.plot(x_plt, val_acc[id_curve], label='per-fold val', color='tab:red')\n",
    "    else:\n",
    "        x_scat = [x_plt[index] for index in range(len(x_plt)) if (index+id_curve)%6==0]\n",
    "        y_scat = [train_acc[id_curve][index] for index in range(len(x_plt)) if (index+id_curve)%6==0]\n",
    "        plt.scatter(x_scat, y_scat, color='tab:red', marker='o', s=50)\n",
    "        plt.plot(x_plt, val_acc[id_curve], color='tab:red')\n",
    "plt.xlabel(\"Boosting iterations\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.legend()\n",
    "plt.title(\"Over-optimistic validation (data leakage)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test 2: stratified partitioning, uncorrelated covariate\n",
    "We run an experiment adopting the *stratified cross-validation* strategy, stratifying along the covariate that is an independent variable. Thus we prevent data leakage and we obtain folds that are statistically equivalent: the validation performances correspond to the desired unbiased internal validation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Unbiased validation')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Splitting strategy (stratified or random)\n",
    "param_split['split_strat']='stratified'\n",
    "# Stratifying covariate (for stratified cross validation)\n",
    "stratifying_covariate_id = 9\n",
    "param_split['stratifying_covariate_id']=stratifying_covariate_id\n",
    "\n",
    "f_arr = stratified_splitting(param_data, param_split, x_arr, y_arr, h_arr)\n",
    "train_acc, val_acc, feat_imp = GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model)\n",
    "# Number of training curves (correspond to each training on a subset during cross-validation)\n",
    "num_curve = len(train_acc)\n",
    "num_feat_importance = len(feat_imp)\n",
    "epochs = len(train_acc[0])\n",
    "\n",
    "x_plt = np.linspace(0, epochs, epochs)\n",
    "\n",
    "for id_curve in range(num_curve):\n",
    "    if id_curve==0:\n",
    "        x_scat = [x_plt[index] for index in range(len(x_plt)) if (index+id_curve)%6==0]\n",
    "        y_scat = [train_acc[id_curve][index] for index in range(len(x_plt)) if (index+id_curve)%6==0]\n",
    "        plt.scatter(x_scat, y_scat, label='per-fold train', color='tab:green', marker='o', s=50)\n",
    "        plt.plot(x_plt, val_acc[id_curve], label='per-fold val', color='tab:green')\n",
    "    else:\n",
    "        x_scat = [x_plt[index] for index in range(len(x_plt)) if (index+id_curve)%6==0]\n",
    "        y_scat = [train_acc[id_curve][index] for index in range(len(x_plt)) if (index+id_curve)%6==0]\n",
    "        plt.scatter(x_scat, y_scat, color='tab:green', marker='o', s=50)\n",
    "        plt.plot(x_plt, val_acc[id_curve], color='tab:green')\n",
    "plt.xlabel(\"Boosting iterations\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.legend()\n",
    "plt.title(\"Unbiased validation\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test 3: stratified partitioning, correlated covariate\n",
    "We run an experiment adopting the *stratified cross-validation* strategy, stratifying along a covariate that is correlated to other covariates and to the outcome. We prevent data leakage and avoid thus over-optimistic validation, but the folds obtained after stratification are statistically heterogeneous, and estimated performances may be pessimistic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Pessimistic validation (inter-fold heterogeneity)')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "param_split['split_strat']='stratified'\n",
    "stratifying_covariate_id = 4\n",
    "param_split['stratifying_covariate_id']=stratifying_covariate_id\n",
    "\n",
    "f_arr = stratified_splitting(param_data, param_split, x_arr, y_arr, h_arr)\n",
    "train_acc, val_acc, feat_imp = GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model)\n",
    "# Number of training curves (correspond to each training on a subset during cross-validation)\n",
    "num_curve = len(train_acc)\n",
    "num_feat_importance = len(feat_imp)\n",
    "epochs = len(train_acc[0])\n",
    "\n",
    "x_plt = np.linspace(0, epochs, epochs)\n",
    "\n",
    "for id_curve in range(num_curve):\n",
    "    if id_curve==0:\n",
    "        x_scat = [x_plt[index] for index in range(len(x_plt)) if (index+id_curve)%6==0]\n",
    "        y_scat = [train_acc[id_curve][index] for index in range(len(x_plt)) if (index+id_curve)%6==0]\n",
    "        plt.scatter(x_scat, y_scat, label='per-fold train', color='tab:blue', marker='o', s=50)\n",
    "        plt.plot(x_plt, val_acc[id_curve], label='per-fold val', color='tab:blue')\n",
    "    else:\n",
    "        x_scat = [x_plt[index] for index in range(len(x_plt)) if (index+id_curve)%6==0]\n",
    "        y_scat = [train_acc[id_curve][index] for index in range(len(x_plt)) if (index+id_curve)%6==0]\n",
    "        plt.scatter(x_scat, y_scat, color='tab:blue', marker='o', s=50)\n",
    "        plt.plot(x_plt, val_acc[id_curve], color='tab:blue')\n",
    "plt.xlabel(\"Boosting iterations\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.legend()\n",
    "plt.title(\"Pessimistic validation (inter-fold heterogeneity)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Large scale simulation\n",
    "We run large scale simulations with various experimental conditions in order to probe the characteristics of cross-validation methodologt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fig. 2: Monitoring of Gradient Boosting fitting\n",
    "We run a single experiment to illustrate the variation of performances during boosting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "sns.set(style=\"white\", font_scale = 1.4)\n",
    "\n",
    "num_round = 200\n",
    "param_model['num_round']=num_round\n",
    "num_dup = 0\n",
    "param_data['num_dup'] = num_dup\n",
    "x_arr, y_arr, h_arr = raw_data_generator(param_data)\n",
    "\n",
    "# Analysis without duplicates (unbiased)\n",
    "split_strat = 'random'\n",
    "param_split['split_strat'] = split_strat\n",
    "f_arr = random_splitting(param_data, param_split, x_arr, y_arr, h_arr)\n",
    "train_acc, val_acc, feat_imp = GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model)\n",
    "# Number of training curves (correspond to each training on a subset during cross-validation)\n",
    "num_curve = len(train_acc)\n",
    "num_feat_importance = len(feat_imp)\n",
    "epochs = len(train_acc[0])\n",
    "x_plt = np.linspace(0, epochs, epochs)\n",
    "\n",
    "av_train_unbias_acc = np.zeros(epochs)\n",
    "av_train_r_acc = np.zeros(epochs)\n",
    "av_train_x_acc = np.zeros(epochs)\n",
    "\n",
    "av_val_unbias_acc = np.zeros(epochs)\n",
    "av_val_r_acc = np.zeros(epochs)\n",
    "av_val_x_acc = np.zeros(epochs)\n",
    "\n",
    "for id_curve in range(num_curve):\n",
    "    av_train_unbias_acc += train_acc[id_curve]\n",
    "    av_val_unbias_acc += val_acc[id_curve]\n",
    "\n",
    "# Insertion of duplicates\n",
    "num_dup = 2000\n",
    "param_data['num_dup'] = num_dup\n",
    "x_arr, y_arr, h_arr = duplicates_generator(param_data, x_arr, y_arr, h_arr)\n",
    "\n",
    "# Analysis through random fold-partitioning\n",
    "split_strat = 'random'\n",
    "param_split['split_strat'] = split_strat\n",
    "f_arr = random_splitting(param_data, param_split, x_arr, y_arr, h_arr)\n",
    "train_acc, val_acc, feat_imp = GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model)\n",
    "for id_curve in range(num_curve):\n",
    "    for id_epoch in range(epochs):\n",
    "        av_train_r_acc[id_epoch] += train_acc[id_curve][id_epoch]\n",
    "        av_val_r_acc[id_epoch] += val_acc[id_curve][id_epoch]\n",
    "\n",
    "# Analysis through stratified fold-partitioning\n",
    "split_strat = 'stratified'\n",
    "param_split['split_strat'] = split_strat\n",
    "stratifying_covariate_id = 0\n",
    "param_split['stratifying_covariate_id'] = stratifying_covariate_id\n",
    "f_arr = stratified_splitting(param_data, param_split, x_arr, y_arr, h_arr)\n",
    "train_acc, val_acc, feat_imp = GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model)\n",
    "for id_curve in range(num_curve):\n",
    "    av_train_x_acc += train_acc[id_curve]\n",
    "    av_val_x_acc += val_acc[id_curve]\n",
    "        \n",
    "av_train_unbias_acc /= num_curve  \n",
    "av_train_r_acc /= num_curve\n",
    "av_train_x_acc /= num_curve\n",
    "\n",
    "av_val_unbias_acc /= num_curve\n",
    "av_val_r_acc /= num_curve\n",
    "av_val_x_acc /= num_curve\n",
    "\n",
    "x_unbias_m = [x_plt[index] for index in range(len(x_plt)) if (index+16)%24==0]\n",
    "train_unbias_m = [av_train_unbias_acc[index] for index in range(len(x_plt)) if (index+16)%24==0]\n",
    "x_r_m = [x_plt[index] for index in range(len(x_plt)) if index%24==0]\n",
    "train_r_m = [av_train_r_acc[index] for index in range(len(x_plt)) if index%24==0]\n",
    "x_x_m = [x_plt[index] for index in range(len(x_plt)) if (index+8)%24==0]\n",
    "train_x_m = [av_train_x_acc[index] for index in range(len(x_plt)) if (index+8)%24==0]\n",
    "\n",
    "s1 = plt.scatter(x_unbias_m, train_unbias_m, label=r'train unb', color='tab:green', marker='s', s=50)\n",
    "s2 = plt.scatter(x_r_m, train_r_m, label=r'train rand', color='tab:red', marker='o', s=50)\n",
    "s3 = plt.scatter(x_x_m, train_x_m, label=r'train $x_1$', color='tab:blue', marker='^', s=50)\n",
    "\n",
    "p1 = plt.plot(x_plt, av_val_unbias_acc, label=r'val unb', color='tab:green', ls='-.', lw =3)\n",
    "p2 = plt.plot(x_plt, av_val_r_acc, label='val rand', color='tab:red', ls='-', lw =3)\n",
    "p3 = plt.plot(x_plt, av_val_x_acc, label=r'val $x_1$', color='tab:blue', ls='--', lw =3)\n",
    "\n",
    "plt.xlabel(\"Boosting iterations\", fontsize = 20)\n",
    "plt.ylabel(r\"Accuracy\", fontsize = 20)\n",
    "\n",
    "plt.ylim(0.80, 1.0)\n",
    "plt.xlim(0,200)\n",
    "l1 = plt.legend(loc = 2, handlelength=4, fontsize=10)\n",
    "plt.axhline(y=acc_opt, ls='--', color ='black')\n",
    "\n",
    "#sns.set(style=\"white\", font_scale = 1.4)\n",
    "\n",
    "plt.savefig('Fig2.pdf', bbox_inches=\"tight\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fig. 3: Quantification of biases associated to various fold-partitioning strategies\n",
    "We run simulations to quantify the over-optimistic and pessimistic biases related to various fold-partitioning strategies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num sim: 0\n",
      "Num sim: 1\n",
      "Num sim: 2\n",
      "Num sim: 3\n",
      "Num sim: 4\n",
      "Num sim: 5\n",
      "Num sim: 6\n",
      "Num sim: 7\n",
      "Num sim: 8\n",
      "Num sim: 9\n",
      "Num sim: 10\n",
      "Num sim: 11\n",
      "Num sim: 12\n",
      "Num sim: 13\n",
      "Num sim: 14\n",
      "Num sim: 15\n",
      "Num sim: 16\n",
      "Num sim: 17\n",
      "Num sim: 18\n",
      "Num sim: 19\n",
      "Num sim: 20\n",
      "Num sim: 21\n",
      "Num sim: 22\n",
      "Num sim: 23\n",
      "Num sim: 24\n",
      "Num sim: 25\n",
      "Num sim: 26\n",
      "Num sim: 27\n",
      "Num sim: 28\n",
      "Num sim: 29\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Number of simulations\n",
    "num_sim = 30\n",
    "\n",
    "# Number of duplicates\n",
    "num_dup = 2000\n",
    "\n",
    "# Result array\n",
    "results = []\n",
    "\n",
    "# Results color\n",
    "palette = []\n",
    "palette.append('tab:green')\n",
    "palette.append('tab:red')\n",
    "for id_cov in range(10):\n",
    "    palette.append('tab:blue')\n",
    "        \n",
    "av_unbiased = 0.0\n",
    "for ind_sim in range(num_sim):\n",
    "    print(\"Num sim: {}\".format(ind_sim))\n",
    "    \n",
    "    # Raw data generation\n",
    "    x_arr, y_arr, h_arr = raw_data_generator(param_data)\n",
    "    \n",
    "    # Data analysis without duplicates\n",
    "    split_strat = 'random'\n",
    "    param_split['split_strat'] = split_strat\n",
    "    param_data['num_dup'] = 0\n",
    "    f_arr = random_splitting(param_data, param_split, x_arr, y_arr, h_arr)\n",
    "    num_f = param_split['num_f']\n",
    "    train_acc, val_acc, feat_imp = GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model)\n",
    "    final_acc = 0.0\n",
    "    for id_f in range(num_f):\n",
    "        final_acc += val_acc[id_f][-1]\n",
    "    final_acc /= num_f\n",
    "    results.append([final_acc, 'unbiased'])\n",
    "    av_unbiased += final_acc\n",
    "    \n",
    "    # Insertion of duplicates\n",
    "    param_data['num_dup'] = num_dup\n",
    "    x_arr, y_arr, h_arr = duplicates_generator(param_data, x_arr, y_arr, h_arr)\n",
    "    \n",
    "    # Data analysis with duplicates\n",
    "    split_strat = 'random'\n",
    "    param_split['split_strat'] = split_strat\n",
    "    f_arr = random_splitting(param_data, param_split, x_arr, y_arr, h_arr)\n",
    "    num_f = param_split['num_f']\n",
    "    train_acc, val_acc, feat_imp = GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model)\n",
    "    final_acc = 0.0\n",
    "    for id_f in range(num_f):\n",
    "        final_acc += val_acc[id_f][-1]\n",
    "    final_acc /= num_f\n",
    "    results.append([final_acc, 'rand'])\n",
    "    \n",
    "    split_strat = 'stratified'\n",
    "    param_split['split_strat'] = split_strat\n",
    "    \n",
    "    for strat_cov_id in range(10):\n",
    "        param_split['stratifying_covariate_id'] = strat_cov_id\n",
    "        f_arr = stratified_splitting(param_data, param_split, x_arr, y_arr, h_arr)\n",
    "        train_acc, val_acc, feat_imp = GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model)\n",
    "        final_acc = 0.0\n",
    "        for id_f in range(num_f):\n",
    "            final_acc += val_acc[id_f][-1]\n",
    "        final_acc /= num_f\n",
    "        results.append([final_acc, strat_cov_id+1])\n",
    "    \n",
    "sns.set(style=\"whitegrid\", font_scale = 1.4)\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "dataFrame = pd.DataFrame(results, columns=['Accuracy','Fold-partitioning strategy'])\n",
    "sns_plot = sns.violinplot(x='Fold-partitioning strategy', y='Accuracy', data=dataFrame, \\\n",
    "                          palette=palette, order=['unbiased', 'rand',1,2,3,4,5,6,7,8,9,10] \\\n",
    "                          ,inner=\"points\", ax=ax)\n",
    "sns_plot.set(xticklabels=['unb','r', r'$x_1$',r'$x_2$', r'$x_3$',r'$x_4$',r'$x_5$'\\\n",
    "                          ,r'$x_6$',r'$x_7$', r'$x_8$',r'$x_9$',r'$x_{10}$'])\n",
    "sns_plot.set_xlabel('Fold-partitioning strategy', fontsize=20)\n",
    "sns_plot.set_ylabel(r'Accuracy', fontsize=20)\n",
    "ax.yaxis.grid(False)\n",
    "ax.xaxis.grid(True)\n",
    "\n",
    "fig = sns_plot.get_figure()\n",
    "plt.axhline(y=acc_opt, ls='--', color ='black')\n",
    "\n",
    "av_unbiased /= num_sim\n",
    "plt.axhline(y=av_unbiased, ls='--', color ='tab:green')\n",
    "\n",
    "plt.show()\n",
    "\n",
    "fig.savefig('Fig3.pdf', bbox_inches=\"tight\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison with logistic regresson and SVM modelings\n",
    "In order to assess the relevance of gradient boosting modeling, we compute the accuracies obtained by logistic regression and SVM applied to the same dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num sim: 0\n",
      "Num sim: 1\n",
      "Num sim: 2\n",
      "Num sim: 3\n",
      "Num sim: 4\n",
      "Num sim: 5\n",
      "Num sim: 6\n",
      "Num sim: 7\n",
      "Num sim: 8\n",
      "Num sim: 9\n",
      "Num sim: 10\n",
      "Num sim: 11\n",
      "Num sim: 12\n",
      "Num sim: 13\n",
      "Num sim: 14\n",
      "Num sim: 15\n",
      "Num sim: 16\n",
      "Num sim: 17\n",
      "Num sim: 18\n",
      "Num sim: 19\n",
      "Num sim: 20\n",
      "Num sim: 21\n",
      "Num sim: 22\n",
      "Num sim: 23\n",
      "Num sim: 24\n",
      "Num sim: 25\n",
      "Num sim: 26\n",
      "Num sim: 27\n",
      "Num sim: 28\n",
      "Num sim: 29\n",
      "Logistic regression mean accuracy: 0.7362934248566351\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "# Number of simulations\n",
    "num_sim = 30\n",
    "\n",
    "# Result array    \n",
    "acc_list = []\n",
    "for ind_sim in range(num_sim):\n",
    "    print(\"Num sim: {}\".format(ind_sim))\n",
    "\n",
    "    # Data analysis without duplicates\n",
    "    split_strat = 'random'\n",
    "    param_split['split_strat'] = split_strat\n",
    "    param_data['num_dup'] = 0\n",
    "    \n",
    "    # Raw data generation\n",
    "    x_arr, y_arr, h_arr = raw_data_generator(param_data)\n",
    "    f_arr = random_splitting(param_data, param_split, x_arr, y_arr, h_arr)\n",
    "    num_f = param_split['num_f']\n",
    "    \n",
    "    \n",
    "    for id_f in range(num_f):\n",
    "        x_train, y_train, x_val, y_val = train_val_building(param_data, param_split, x_arr, y_arr, f_arr, id_f)\n",
    "        \n",
    "        clf = LogisticRegression(random_state=0, solver='lbfgs', penalty='none').fit(x_train, y_train)\n",
    "        clf.fit(x_train, y_train)\n",
    "        y_pred = clf.predict(x_val)\n",
    "        acc = np.mean(y_pred * y_val+(1-y_pred) * (1-y_val))\n",
    "        acc_list.append(acc)\n",
    "\n",
    "print(\"Logistic regression mean accuracy: {}\".format(np.mean(acc_list)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SVM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num sim: 0\n",
      "Num sim: 1\n",
      "Num sim: 2\n",
      "Num sim: 3\n",
      "Num sim: 4\n",
      "Num sim: 5\n",
      "Num sim: 6\n",
      "Num sim: 7\n",
      "Num sim: 8\n",
      "Num sim: 9\n",
      "Num sim: 10\n",
      "Num sim: 11\n",
      "Num sim: 12\n",
      "Num sim: 13\n",
      "Num sim: 14\n",
      "Num sim: 15\n",
      "Num sim: 16\n",
      "Num sim: 17\n",
      "Num sim: 18\n",
      "Num sim: 19\n",
      "Num sim: 20\n",
      "Num sim: 21\n",
      "Num sim: 22\n",
      "Num sim: 23\n",
      "Num sim: 24\n",
      "Num sim: 25\n",
      "Num sim: 26\n",
      "Num sim: 27\n",
      "Num sim: 28\n",
      "Num sim: 29\n",
      "SVM mean accuracy: 0.8186232335443757\n"
     ]
    }
   ],
   "source": [
    "from sklearn import svm\n",
    "\n",
    "# Number of simulations\n",
    "num_sim = 30\n",
    "\n",
    "# Result array\n",
    "acc_list = []\n",
    "for ind_sim in range(num_sim):\n",
    "    print(\"Num sim: {}\".format(ind_sim))\n",
    "    \n",
    "    # Data analysis without duplicates\n",
    "    split_strat = 'random'\n",
    "    param_split['split_strat'] = split_strat\n",
    "    param_data['num_dup'] = 0\n",
    "    \n",
    "    \n",
    "    #Raw data generation\n",
    "    x_arr, y_arr, h_arr = raw_data_generator(param_data)\n",
    "    \n",
    "    f_arr = random_splitting(param_data, param_split, x_arr, y_arr, h_arr)\n",
    "    num_f = param_split['num_f']\n",
    "    \n",
    "    \n",
    "    for id_f in range(num_f):\n",
    "        x_train, y_train, x_val, y_val = train_val_building(param_data, param_split, x_arr, y_arr, f_arr, id_f)\n",
    "        \n",
    "        clf = svm.SVC(gamma='auto')\n",
    "        clf.fit(x_train, y_train)\n",
    "        y_pred = clf.predict(x_val)\n",
    "        acc = np.mean(y_pred * y_val+(1-y_pred) * (1-y_val))\n",
    "        acc_list.append(acc)\n",
    "print(\"SVM mean accuracy: {}\".format(np.mean(acc_list)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fig. 4: Correlation of the pessimistic bias and the importance of the stratifying covariate\n",
    "We run simulations to quantify the association between the pessimistic bias and the importance of the stratifying covariate $x_{str}$.\n",
    "\n",
    "We draw 100 random sets of generating parameters $\\{\\Sigma, \\mathbf{a}\\}$. For each set $\\{\\Sigma, \\mathbf{a}\\}$ we generate a dataset without duplicates and we fit a gradient boosting on it using classical cross-validation, measuring thus an unbiased estimate of accuracy. We compute the feature importances of each covariate, and we normalize them by the maximum feature importance in order to obtain values between 0 and 1 (see [1] p.367 for computational details). \n",
    "\n",
    "We then add duplicates to each dataset, and analyze it through *stratified cross-validation* using successively each one of the 10 covariates as the stratifying covariate. We plot the ratio of accuracy measured after having stratified along $x_{str}$ over the unbiased estimate of accuracy, as a function of the normalized feature importance of the stratifying covariate.\n",
    "\n",
    "[1] Trevor Hastie, Robert Tibshirani, and Jerome Friedman. The Elements of Statistical Learning: Data Mining,\n",
    "Inference, and Prediction, Second Edition. Springer Series in Statistics. Springer-Verlag, New York, 2 edition,\n",
    "2009."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A_vec number: 0\n",
      "A_vec number: 1\n",
      "A_vec number: 2\n",
      "A_vec number: 3\n",
      "A_vec number: 4\n",
      "A_vec number: 5\n",
      "A_vec number: 6\n",
      "A_vec number: 7\n",
      "A_vec number: 8\n",
      "A_vec number: 9\n",
      "A_vec number: 10\n",
      "A_vec number: 11\n",
      "A_vec number: 12\n",
      "A_vec number: 13\n",
      "A_vec number: 14\n",
      "A_vec number: 15\n",
      "A_vec number: 16\n",
      "A_vec number: 17\n",
      "A_vec number: 18\n",
      "A_vec number: 19\n",
      "A_vec number: 20\n",
      "A_vec number: 21\n",
      "A_vec number: 22\n",
      "A_vec number: 23\n",
      "A_vec number: 24\n",
      "A_vec number: 25\n",
      "A_vec number: 26\n",
      "A_vec number: 27\n",
      "A_vec number: 28\n",
      "A_vec number: 29\n",
      "A_vec number: 30\n",
      "A_vec number: 31\n",
      "A_vec number: 32\n",
      "A_vec number: 33\n",
      "A_vec number: 34\n",
      "A_vec number: 35\n",
      "A_vec number: 36\n",
      "A_vec number: 37\n",
      "A_vec number: 38\n",
      "A_vec number: 39\n",
      "A_vec number: 40\n",
      "A_vec number: 41\n",
      "A_vec number: 42\n",
      "A_vec number: 43\n",
      "A_vec number: 44\n",
      "A_vec number: 45\n",
      "A_vec number: 46\n",
      "A_vec number: 47\n",
      "A_vec number: 48\n",
      "A_vec number: 49\n",
      "A_vec number: 50\n",
      "A_vec number: 51\n",
      "A_vec number: 52\n",
      "A_vec number: 53\n",
      "A_vec number: 54\n",
      "A_vec number: 55\n",
      "A_vec number: 56\n",
      "A_vec number: 57\n",
      "A_vec number: 58\n",
      "A_vec number: 59\n",
      "A_vec number: 60\n",
      "A_vec number: 61\n",
      "A_vec number: 62\n",
      "A_vec number: 63\n",
      "A_vec number: 64\n",
      "A_vec number: 65\n",
      "A_vec number: 66\n",
      "A_vec number: 67\n",
      "A_vec number: 68\n",
      "A_vec number: 69\n",
      "A_vec number: 70\n",
      "A_vec number: 71\n",
      "A_vec number: 72\n",
      "A_vec number: 73\n",
      "A_vec number: 74\n",
      "A_vec number: 75\n",
      "A_vec number: 76\n",
      "A_vec number: 77\n",
      "A_vec number: 78\n",
      "A_vec number: 79\n",
      "A_vec number: 80\n",
      "A_vec number: 81\n",
      "A_vec number: 82\n",
      "A_vec number: 83\n",
      "A_vec number: 84\n",
      "A_vec number: 85\n",
      "A_vec number: 86\n",
      "A_vec number: 87\n",
      "A_vec number: 88\n",
      "A_vec number: 89\n",
      "A_vec number: 90\n",
      "A_vec number: 91\n",
      "A_vec number: 92\n",
      "A_vec number: 93\n",
      "A_vec number: 94\n",
      "A_vec number: 95\n",
      "A_vec number: 96\n",
      "A_vec number: 97\n",
      "A_vec number: 98\n",
      "A_vec number: 99\n",
      "Pearson product-moment correlation coefficients: [[ 1.         -0.75324335]\n",
      " [-0.75324335  1.        ]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Number of a_vec that are tested\n",
    "num_a_vec = 100\n",
    "\n",
    "# Results list\n",
    "results = []\n",
    "\n",
    "for id_a_vec in range(num_a_vec):\n",
    "    print(\"A_vec number: {}\".format(id_a_vec))\n",
    "    av_feat_imp = np.zeros(10)\n",
    "    av_val_acc = np.zeros(10)\n",
    "    \n",
    "    ### Weights of generating law\n",
    "    a_vec = 10.0*(np.random.rand(8)-0.5*np.ones(8))\n",
    "    ### Eigenvalues of the covariance matrix\n",
    "    lambda_vec = 2.0*np.random.rand(9)+np.ones(9)\n",
    "    lambda_10 = 2.0*np.random.rand() + 1.0\n",
    "    ### Random orthogonal matrix\n",
    "    O = scipy.stats.ortho_group.rvs(9)\n",
    "    ### Covariance matrix\n",
    "    sigma_prime = np.dot(O, np.dot(np.diag(lambda_vec), np.transpose(O)))\n",
    "    sigma = scipy.linalg.block_diag(sigma_prime, lambda_10)\n",
    "\n",
    "    param_data['a_vec'] = a_vec\n",
    "    param_data['sigma'] = sigma\n",
    "    \n",
    "    # Raw data generation\n",
    "    x_arr, y_arr, h_arr = raw_data_generator(param_data)\n",
    "\n",
    "    # Data analysis without duplicates\n",
    "    split_strat = 'random'\n",
    "    param_split['split_strat'] = split_strat\n",
    "    param_data['num_dup'] = 0\n",
    "    f_arr = random_splitting(param_data, param_split, x_arr, y_arr, h_arr)\n",
    "    num_f = param_split['num_f']\n",
    "    train_acc, val_acc, feat_imp = GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model)\n",
    "    unbiased_val_acc = 0.0\n",
    "    feat_norm = np.zeros(10)\n",
    "    for id_f in range(num_f):\n",
    "        unbiased_val_acc += val_acc[id_f][-1]\n",
    "    for id_cov in range(10):\n",
    "        key = 'f'+str(id_cov)\n",
    "        for id_f in range(num_f):\n",
    "            feat_norm[id_cov] += feat_imp[id_f][key]\n",
    "    unbiased_val_acc /= num_f\n",
    "    feat_norm /= np.amax(feat_norm)\n",
    "    \n",
    "    # Insertion of duplicates\n",
    "    param_data['num_dup'] = 2000\n",
    "    x_arr, y_arr, h_arr = duplicates_generator(param_data, x_arr, y_arr, h_arr)\n",
    "    \n",
    "    param_split['split_strat'] = 'stratified'\n",
    "    for strat_cov_id in range(10):\n",
    "        param_split['stratifying_covariate_id'] = strat_cov_id\n",
    "        \n",
    "        # Splitting of datasets in folds\n",
    "        f_arr = stratified_splitting(param_data, param_split, x_arr, y_arr, h_arr)\n",
    "\n",
    "        train_acc, val_acc, feat_imp = GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model)\n",
    "        final_acc = 0.0\n",
    "        for id_f in range(num_f):\n",
    "            final_acc += val_acc[id_f][-1]\n",
    "        final_acc /= num_f\n",
    "        final_acc /= unbiased_val_acc\n",
    "        results.append([feat_norm[strat_cov_id], final_acc])\n",
    "        \n",
    "results = np.asarray(results)\n",
    "np.savetxt(\"feature_importance.csv\", results)\n",
    "corr = np.corrcoef(np.asarray(results).T)\n",
    "print(\"Pearson product-moment correlation coefficients: {}\".format(corr))\n",
    "\n",
    "sns.set(style=\"white\",font_scale = 1.4)\n",
    "sns_plot2 = sns.jointplot(results[:,0], results[:,1], xlim=(0,1))\n",
    "sns_plot2.set_axis_labels(r'Normalized $x_{str}$ feature importance', r'Accuracy$_{str}$/Accuracy$_{unb}$', fontsize=20)\n",
    "sns_plot2.fig.text(0.15,0.15,\"$r=${}\".format(round(corr[0][1], 2)), fontsize=20)\n",
    "\n",
    "sns_plot2.savefig('Fig4.pdf', bbox_inches=\"tight\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Real medical data: MIMIC-III dataset\n",
    "In order to complement the study of stratified cross-validation that has been conducted on synthetic datasets, we consider now the case of real medical data. We focus on the famous MIMIC-III dataset that is freely available for research [2]. We have extracted from the database a set of 31384 records corresponding to the admissions of patients in two different intensive care units (ICU), either the medical one (MICU) or the surgical one (SICU). Each record corresponds to a single admission, and a patient may have multiple admissions. For the sake of simplicity and to avoid data leakage between various records related to a given patient, we keep at random only one record per patient. For each record, we have computed the 15 explanatory variables used in SOFA score [3] and we keep 4 additional variables that are used for stratification: age at admission, weight at admission, lowest creatinine value from the first 24 hours after ICU admission, lowest blood urea nitrogen value from the first 24 hours after ICU admission, highest hemoglobin value from the first 24 hours after ICU admission. These variables may vary from one admission to another for a the same patient, but they are shared by duplicated records. \n",
    "\n",
    "To mimick the duplication of records that may occur when a patient is transferred from one ICU to the other, we duplicate at random 17% of each ICU records, and transfer them to the other ICU. We reproduce the training and validation of a mortality prediction model using gradient boosting [4], and compare the measured performances either 1) in absence of duplication or 2) with duplication and random cross-validation or 3) with duplication and stratified cross-validation.\n",
    "\n",
    "The part of this notebook that is related to real medical records is not run for privacy protection. \n",
    "\n",
    "[2] Johnson AEW, Pollard TJ, Shen L, et al. MIMIC-III, a freely accessible critical care database. Sci Data 2016;3:1–9. doi:10.1038/sdata.2016.35\n",
    "\n",
    "[3] Vincent JL, Moreno R, Takala J, et al. The SOFA (Sepsis-related Organ Failure Assessment) score to describe organ dysfunction/failure. On behalf of the Working Group on Sepsis-Related Problems of the European Society of Intensive Care Medicine. Intensive Care Med 1996;22:707–10. doi:10.1007/bf01709751\n",
    "\n",
    "[4] Pirracchio R, Petersen ML, Carone M, et al. Mortality prediction in intensive care units with the Super ICU Learner Algorithm (SICULA): a population-based study. Lancet Respir Med 2015;3:42–52. doi:10.1016/S2213-2600(14)70239-5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset pre-processing\n",
    "We upload a csv file containing all the records related to the two ICUs of interest (n=31384). For each record we have the 15 explanatory variables of SOFA score and the 5 stratifying covariates. When one explanatory variable was missing, a value of 0 has been imputed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Upload of a pre-processed csv file with variables of interest\n",
    "df_mimic = pd.read_csv(\"cleaned_mimic_4.csv\")\n",
    "df_mimic = df_mimic.drop('Unnamed: 0', axis=1)\n",
    "df_mimic.head()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_mimic.shape\n",
    "\n",
    "# RESULT:\n",
    "\n",
    "# (31384, 28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Replacing string variables by integers\n",
    "df_mimic = df_mimic.replace({'CURR_CAREUNIT_transfers' : 'MICU'}, 0)\n",
    "df_mimic = df_mimic.replace({'CURR_CAREUNIT_transfers' : 'SICU'}, 1)\n",
    "df_mimic = df_mimic.replace({'gender' : 'M'}, 0)\n",
    "df_mimic = df_mimic.replace({'gender' : 'F'}, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Computation of the rate of missing value for stratifying covariates (imputation of 0 for saps-ii scores already done)\n",
    "num_rec, _ = df_mimic.shape\n",
    "100*df_mimic.isnull().sum()/num_rec\n",
    "\n",
    "# RESULT:\n",
    "\n",
    "# columns:hadm_id                     0.000000\n",
    "# subject_id                  0.000000\n",
    "# sapsii                      0.000000\n",
    "# sapsii_prob                 0.000000\n",
    "# age_score                   0.000000\n",
    "# hr_score                    0.000000\n",
    "# sysbp_score                 0.000000\n",
    "# temp_score                  0.000000\n",
    "# pao2fio2_score              0.000000\n",
    "# uo_score                    0.000000\n",
    "# bun_score                   0.000000\n",
    "# wbc_score                   0.000000\n",
    "# potassium_score             0.000000\n",
    "# sodium_score                0.000000\n",
    "# bicarbonate_score           0.000000\n",
    "# bilirubin_score             0.000000\n",
    "# gcs_score                   0.000000\n",
    "# comorbidity_score           0.000000\n",
    "# admissiontype_score         0.000000\n",
    "# hospital_mortality          0.000000\n",
    "# gender                      0.000000\n",
    "# age                         0.000000\n",
    "# creatinine_min              1.516696\n",
    "# CURR_CAREUNIT_transfers     0.000000\n",
    "# weight                     12.719857\n",
    "# bun_min                     1.523069\n",
    "# hemoglobin_max              1.746113\n",
    "# height                     40.992225"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imputation of 0 in place of missing values\n",
    "df_mimic = df_mimic.fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Keeping at random one record for each individual\n",
    "df_mimic_1rec = df_mimic.groupby('subject_id').apply(lambda df: df.sample(1))\n",
    "\n",
    "# Total number of records\n",
    "num_tot_rec = df_mimic_1rec.shape[0]\n",
    "print(\"Total number of records in the deduplicated dataset: {}\".format(num_tot_rec))\n",
    "\n",
    "# Number of records in medical ICU\n",
    "num_MICU_rec = df_mimic_1rec[df_mimic_1rec['CURR_CAREUNIT_transfers']==0].shape[0]\n",
    "print(\"MICU number of records in the deduplicated dataset: {}\".format(num_MICU_rec))\n",
    "\n",
    "# Number of records in surgical ICU\n",
    "num_SICU_rec = df_mimic_1rec[df_mimic_1rec['CURR_CAREUNIT_transfers']==1].shape[0]\n",
    "print(\"SICU number of records in the deduplicated dataset: {}\".format(num_SICU_rec))\n",
    "\n",
    "# RESULT:\n",
    "# Total number of records in the deduplicated dataset: 22678\n",
    "# MICU number of records in the deduplicated dataset: 15446\n",
    "# SICU number of records in the deduplicated dataset: 7232\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definition of various dataframes\n",
    "## Training covariates dataframe\n",
    "df_mimic_x = df_mimic_1rec[['age_score','hr_score','sysbp_score','temp_score', \\\n",
    "                            'pao2fio2_score','uo_score','bun_score','wbc_score', \\\n",
    "                            'potassium_score','sodium_score','bicarbonate_score', \\\n",
    "                            'bilirubin_score','gcs_score','comorbidity_score', \\\n",
    "                            'admissiontype_score']]\n",
    "\n",
    "## Outcome dataframe\n",
    "df_mimic_y = df_mimic_1rec[['hospital_mortality']]\n",
    "\n",
    "## ICU dataframe\n",
    "df_mimic_h = df_mimic_1rec[['CURR_CAREUNIT_transfers']]\n",
    "\n",
    "## Stratifying covariates dataframe\n",
    "df_mimic_strat_cov = df_mimic_1rec[['age', 'weight','creatinine_min', 'bun_min','hemoglobin_max']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Converting dataframes to numpy arrays\n",
    "x_arr_0 = df_mimic_x.to_numpy()\n",
    "y_arr_0 = np.squeeze(df_mimic_y.to_numpy())\n",
    "h_arr_0 = np.squeeze(df_mimic_h.to_numpy())\n",
    "strat_arr_0 = df_mimic_strat_cov.to_numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training and validation of a mortality prediction model\n",
    "We train and validate a gradient boosting model on the n=22678 records either directly or after having added 17% duplicates."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fig: training and validation monitoring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Number of patients\n",
    "num_pat = x_arr_0.shape[0]\n",
    "param_data['num_pat'] = num_pat\n",
    "\n",
    "# Number of hospitals (corresponding here to the two ICUs)\n",
    "num_h = 2\n",
    "param_data['num_h'] = num_h\n",
    "\n",
    "## Model definition\n",
    "fit_model = 'GB'\n",
    "max_depth = 3\n",
    "eta = 0.6\n",
    "objective = 'binary:logistic'\n",
    "eval_metric = 'auc'\n",
    "num_round = 200\n",
    "param_model = {'fit_model':fit_model, 'max_depth':max_depth, 'eta':eta, 'objective':objective, 'eval_metric':eval_metric, \n",
    "              'num_round':num_round}\n",
    "\n",
    "# Print proportion of positive outcome\n",
    "prop_outcome = np.sum(y_arr_0)/len(y_arr_0)\n",
    "prop_outcome_MICU = np.sum(y_arr_0[h_arr_0==0])/len(y_arr_0[h_arr_0==0])\n",
    "prop_outcome_SICU = np.sum(y_arr_0[h_arr_0==1])/len(y_arr_0[h_arr_0==1])\n",
    "print(\"Proportion of positive outcome ICU: {}\".format(prop_outcome))\n",
    "print(\"Proportion of positive outcome MICU: {}\".format(prop_outcome_MICU))\n",
    "print(\"Proportion of positive outcome SICU: {}\".format(prop_outcome_SICU))\n",
    "\n",
    "# Definition of working arrays\n",
    "x_arr, y_arr, h_arr = np.copy(x_arr_0), np.copy(y_arr_0), np.copy(h_arr_0)\n",
    "\n",
    "# ANALYSIS 1: without duplicates (unbiased), with classical cross-validation\n",
    "# Number of duplicates\n",
    "num_dup = 0\n",
    "param_data['num_dup'] = num_dup\n",
    "split_strat = 'random'\n",
    "param_split['split_strat'] = split_strat\n",
    "f_arr = random_splitting(param_data, param_split, x_arr, y_arr, h_arr)\n",
    "train_auc, val_auc, feat_imp = GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model)\n",
    "\n",
    "# Number of training curves (correspond to each training on a subset during cross-validation)\n",
    "num_curve = len(train_auc)\n",
    "num_feat_importance = len(feat_imp)\n",
    "epochs = len(train_auc[0])\n",
    "x_plt = np.linspace(0, epochs, epochs)\n",
    "\n",
    "av_train_unbias_auc = np.zeros(epochs)\n",
    "av_train_r_auc = np.zeros(epochs)\n",
    "av_train_x_auc = np.zeros(epochs)\n",
    "\n",
    "av_val_unbias_auc = np.zeros(epochs)\n",
    "av_val_r_auc = np.zeros(epochs)\n",
    "av_val_x_auc = np.zeros(epochs)\n",
    "\n",
    "for id_curve in range(num_curve):\n",
    "    av_train_unbias_auc += train_auc[id_curve]\n",
    "    av_val_unbias_auc += val_auc[id_curve]\n",
    "\n",
    "# ANALYSIS 2: with duplicates\n",
    "# Insertion of duplicates\n",
    "num_dup = int(np.floor(x_arr_0.shape[0])*0.17/(1-0.17))\n",
    "param_data['num_dup'] = num_dup\n",
    "print(\"Number of duplicates added : {}\".format(num_dup))\n",
    "l_x = x_arr_0.shape[1]\n",
    "x_strat_arr_0 = np.concatenate((x_arr_0, strat_arr_0), axis=1)\n",
    "x_strat_arr, y_arr, h_arr = duplicates_generator(param_data, x_strat_arr_0, y_arr_0, h_arr_0)\n",
    "x_arr, strat_arr = np.split(x_strat_arr, [l_x], axis=1)\n",
    "\n",
    "# Analysis through random fold-partitioning\n",
    "split_strat = 'random'\n",
    "param_split['split_strat'] = split_strat\n",
    "f_arr = random_splitting(param_data, param_split, x_arr, y_arr, h_arr)\n",
    "train_auc, val_auc, feat_imp = GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model)\n",
    "for id_curve in range(num_curve):\n",
    "    for id_epoch in range(epochs):\n",
    "        av_train_r_auc[id_epoch] += train_auc[id_curve][id_epoch]\n",
    "        av_val_r_auc[id_epoch] += val_auc[id_curve][id_epoch]\n",
    "\n",
    "# Analysis through stratified fold-partitioning\n",
    "split_strat = 'stratified'\n",
    "param_split['split_strat'] = split_strat\n",
    "stratifying_covariate_id = 0\n",
    "param_split['stratifying_covariate_id'] = stratifying_covariate_id\n",
    "f_arr = stratified_splitting(param_data, param_split, strat_arr, y_arr, h_arr)\n",
    "train_auc, val_auc, feat_imp = GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model)\n",
    "for id_curve in range(num_curve):\n",
    "    av_train_x_auc += train_auc[id_curve]\n",
    "    av_val_x_auc += val_auc[id_curve]\n",
    "        \n",
    "av_train_unbias_auc /= num_curve  \n",
    "av_train_r_auc /= num_curve\n",
    "av_train_x_auc /= num_curve\n",
    "\n",
    "av_val_unbias_auc /= num_curve\n",
    "av_val_r_auc /= num_curve\n",
    "av_val_x_auc /= num_curve\n",
    "\n",
    "# Plot training and validation curves\n",
    "x_unbias_m = [x_plt[index] for index in range(len(x_plt)) if (index+16)%24==0]\n",
    "train_unbias_m = [av_train_unbias_auc[index] for index in range(len(x_plt)) if (index+16)%24==0]\n",
    "x_r_m = [x_plt[index] for index in range(len(x_plt)) if index%24==0]\n",
    "train_r_m = [av_train_r_auc[index] for index in range(len(x_plt)) if index%24==0]\n",
    "x_x_m = [x_plt[index] for index in range(len(x_plt)) if (index+8)%24==0]\n",
    "train_x_m = [av_train_x_auc[index] for index in range(len(x_plt)) if (index+8)%24==0]\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "sns.set(style=\"white\", font_scale = 1.4)\n",
    "\n",
    "s1 = plt.scatter(x_unbias_m, train_unbias_m, label=r'train unb', color='tab:green', marker='s', s=50)\n",
    "s2 = plt.scatter(x_r_m, train_r_m, label=r'train rand', color='tab:red', marker='o', s=50)\n",
    "s3 = plt.scatter(x_x_m, train_x_m, label=r'train age-str', color='tab:blue', marker='^', s=50)\n",
    "\n",
    "p1 = plt.plot(x_plt, av_val_unbias_auc, label=r'val unb', color='tab:green', ls='-.', lw =3)\n",
    "p2 = plt.plot(x_plt, av_val_r_auc, label='val rand', color='tab:red', ls='-', lw =3)\n",
    "p3 = plt.plot(x_plt, av_val_x_auc, label=r'val age-str', color='tab:blue', ls='--', lw =3)\n",
    "\n",
    "plt.xlabel(\"Boosting iterations\", fontsize = 20)\n",
    "plt.ylabel(r\"AUC\", fontsize = 20)\n",
    "\n",
    "plt.ylim(0.80,0.9)\n",
    "plt.xlim(0,200)\n",
    "l1 = plt.legend(loc = 2, handlelength=4, fontsize=10)\n",
    "\n",
    "plt.savefig('Fig_Monitoring_MIMIC.pdf', bbox_inches=\"tight\")\n",
    "\n",
    "# RESULT:\n",
    "\n",
    "# Proportion of positive outcome: 0.16293323926272157\n",
    "# Number of duplicates added : 4644\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fig. Correlation of the pessimistic bias and the importance of the stratifying covariate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Number of simulations\n",
    "num_sim = 30\n",
    "\n",
    "# Number of duplicates\n",
    "num_dup = int(np.floor(x_arr_0.shape[0])*0.17/(1-0.17))\n",
    "print(\"Number of duplicates added : {}\".format(num_dup))\n",
    "\n",
    "# Result array\n",
    "results = []\n",
    "\n",
    "# Results color\n",
    "palette = []\n",
    "palette.append('tab:green')\n",
    "palette.append('tab:red')\n",
    "for id_cov in range(5):\n",
    "    palette.append('tab:blue')\n",
    "        \n",
    "for ind_sim in range(num_sim):\n",
    "    print(\"Num sim: {}\".format(ind_sim))\n",
    "    \n",
    "    # Raw data generation\n",
    "    x_arr, y_arr, h_arr, strat_arr = x_arr_0, y_arr_0, h_arr_0, strat_arr_0\n",
    "    \n",
    "    # Data analysis without duplicates\n",
    "    split_strat = 'random'\n",
    "    param_split['split_strat'] = split_strat\n",
    "    param_data['num_dup'] = 0\n",
    "    f_arr = random_splitting(param_data, param_split, x_arr, y_arr, h_arr)\n",
    "    num_f = param_split['num_f']\n",
    "    train_auc, val_auc, feat_imp = GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model)\n",
    "    final_auc = 0.0\n",
    "    for id_f in range(num_f):\n",
    "        final_auc += val_auc[id_f][-1]\n",
    "    final_auc /= num_f\n",
    "    results.append([final_auc, 'unbiased', 'NaN'])\n",
    "    \n",
    "    # Data analysis without duplicates with all variables, including stratifying covariates, \n",
    "    # to measure covariate importance\n",
    "    x_arr_1 = np.concatenate((x_arr, strat_arr), axis=1)\n",
    "    f_arr = random_splitting(param_data, param_split, x_arr_1, y_arr, h_arr)\n",
    "    num_f = param_split['num_f']\n",
    "    train_auc, val_auc, feat_imp = GB_fitting(x_arr_1, y_arr, f_arr, param_data, param_split, param_model)\n",
    "    feat_norm = np.zeros(x_arr_1.shape[1])\n",
    "    for id_cov in range(x_arr_1.shape[1]):\n",
    "        key = 'f'+str(id_cov)\n",
    "        for id_f in range(num_f):\n",
    "            if key in feat_imp[id_f]:\n",
    "                feat_norm[id_cov] += feat_imp[id_f][key]\n",
    "    feat_norm /= np.amax(feat_norm)\n",
    "    \n",
    "    # Insertion of duplicates\n",
    "    param_data['num_dup'] = num_dup\n",
    "    \n",
    "    l_x = x_arr_0.shape[1]\n",
    "    x_strat_arr_0 = np.concatenate((x_arr_0, strat_arr_0), axis=1)\n",
    "    x_strat_arr, y_arr, h_arr = duplicates_generator(param_data, x_strat_arr_0, y_arr_0, h_arr_0)\n",
    "    x_arr, strat_arr = np.split(x_strat_arr, [l_x], axis=1)\n",
    "    \n",
    "    # Data analysis with duplicates\n",
    "    split_strat = 'random'\n",
    "    param_split['split_strat'] = split_strat\n",
    "    f_arr = random_splitting(param_data, param_split, x_arr, y_arr, h_arr)\n",
    "    num_f = param_split['num_f']\n",
    "    train_auc, val_auc, feat_imp = GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model)\n",
    "    final_auc = 0.0\n",
    "    for id_f in range(num_f):\n",
    "        final_auc += val_auc[id_f][-1]\n",
    "    final_auc /= num_f\n",
    "    results.append([final_auc, 'rand', 'NaN'])\n",
    "    \n",
    "    split_strat = 'stratified'\n",
    "    param_split['split_strat'] = split_strat\n",
    "    \n",
    "    for strat_cov_id in range(5):\n",
    "        param_split['stratifying_covariate_id'] = strat_cov_id\n",
    "        f_arr = stratified_splitting(param_data, param_split, strat_arr, y_arr, h_arr)\n",
    "        train_auc, val_auc, feat_imp = GB_fitting(x_arr, y_arr, f_arr, param_data, param_split, param_model)\n",
    "        final_auc = 0.0\n",
    "        for id_f in range(num_f):\n",
    "            final_auc += val_auc[id_f][-1]\n",
    "        final_auc /= num_f\n",
    "        results.append([final_auc, strat_cov_id+1, feat_norm[x_arr.shape[1]+strat_cov_id]])\n",
    "    \n",
    "sns.set(style=\"whitegrid\", font_scale = 1.4)\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "dataFrame = pd.DataFrame(results, columns=['AUC','Fold-partitioning strategy','Feature importance'])\n",
    "sns_plot = sns.violinplot(x='Fold-partitioning strategy', y='AUC', data=dataFrame, \\\n",
    "                          palette=palette, order=['unbiased', 'rand',1,2,3,4,5] \\\n",
    "                          ,inner=\"points\", ax=ax)\n",
    "sns_plot.set(xticklabels=['unb','r', r'age',r'wei', r'cre', r'bun', r'hem'])\n",
    "sns_plot.set_xlabel('Fold-partitioning strategy', fontsize=20)\n",
    "sns_plot.set_ylabel(r'AUC', fontsize=20)\n",
    "ax.set_ylim(0.79, 0.89)\n",
    "ax.yaxis.grid(False)\n",
    "ax.xaxis.grid(True)\n",
    "\n",
    "\n",
    "list_foldpart_strat = ['unbiased', 'rand',1,2,3,4,5]\n",
    "\n",
    "av_unbiased = 0\n",
    "for item in list_foldpart_strat:\n",
    "    av_auc = dataFrame[dataFrame['Fold-partitioning strategy']==item].mean(axis=0)['AUC']\n",
    "    print(\"Mean AUC for {} strategy: {}\".format(item, av_auc))\n",
    "    if item=='unbiased':\n",
    "        av_unbiased = av_auc\n",
    "plt.axhline(y=av_unbiased, ls='--', color ='tab:green')\n",
    "\n",
    "\n",
    "\n",
    "axins = inset_axes(ax,  \"40%\", \"40%\" ,loc=\"upper right\", borderpad=0)\n",
    "dataFrame = dataFrame[(dataFrame['Fold-partitioning strategy']!='unbiased')&(dataFrame['Fold-partitioning strategy']!='rand')]\n",
    "dataFrame['AUC'] = dataFrame['AUC']/av_unbiased\n",
    "sns_subplot = sns.scatterplot(x='Feature importance', y='AUC', data=dataFrame)\n",
    "sns_subplot.set_xlabel('Norm. feat. imp.', fontsize=15)\n",
    "sns_subplot.set_ylabel(r'AUC/AUC$_{unb}$', fontsize=15)\n",
    "\n",
    "\n",
    "\n",
    "results = dataFrame[['AUC', 'Feature importance']].to_numpy()\n",
    "corr = np.corrcoef(results.astype(float).T)\n",
    "print(\"Pearson product-moment correlation coefficients: {}\".format(corr))\n",
    "sns_subplot.text(0.15,0.95,\"$r=${}\".format(round(corr[0][1], 2)), fontsize=15)\n",
    "\n",
    "sns_subplot.figure.savefig('Fig5.pdf', bbox_inches=\"tight\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}