2.dealing-with-numerical-data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7f8cb5cf-d21b-48eb-96b3-94a83dcd6cae",
   "metadata": {},
   "source": [
    "# Gérer des données numériques dans un projet d’apprentissage supervisé"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c599a71-0737-4bf5-b599-0f68a79536a5",
   "metadata": {},
   "source": [
    "C’est bien connu, les machines adorent les nombres. Ils ont cela de commode qu’ils se prêtent mieux aux calculs que des symboles comme *pomme* ou *Pommes*. Dans un projet de *machine learning*, les données fournies aux algorithmes d’apprentissage devront toutes être représentées sous forme numérique et, avant d’aborder la manière de vectoriser des chaînes de caractère, il est plus sage de commencer par la manipulations des nombres, qu’ils prennent des valeurs entières ou réelles.\n",
    "\n",
    "Au fil de ce calepin électronique, nous programmerons une machine intelligente censée prédire une valeur cible pour un ensemble de caractéristiques, et ce en respectant les étapes du *workflow* décrit dans la présentation :\n",
    "\n",
    "1. Partition du jeu de données en un jeu d’entraînement et un jeu de test ;\n",
    "2. entraînement du modèle avec un algorithme ;\n",
    "3. évaluation de la performance du modèle.\n",
    "\n",
    "Nous commencerons à utiliser la librairie [*Scikit-Learn*](https://scikit-learn.org/), spécifiquement dédiée aux tâches du *machine learning*, mais avant, chargeons quelques-uns des modules courants qui nous seront nécessaires pour exécuter les codes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93ac0581-3977-4425-a038-8143c62390dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "\n",
    "sns.set_context('notebook')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdb74d3b-bb60-4a1d-b5c6-9943a3062e69",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Identifier une variable aléatoire quantitative"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4914a9e5-8f59-4917-b881-a3bcb9fb5e77",
   "metadata": {},
   "source": [
    "En statistiques, une variable aléatoire est l’une des caractéristiques d’une observation. Elle peut se représenter de manière rudimentaire sous forme de tableau à deux dimensions :\n",
    "\n",
    "|Sexe|Taille|\n",
    "|-|:-:|\n",
    "|F|180|\n",
    "|M|172|\n",
    "|M|167|\n",
    "|F|178|\n",
    "\n",
    "Le tableau étant composé de trois lignes et de deux colonnes, il est réputé présenter deux caractéristiques pour trois observations dans une structure de dimensions $4\\times 2$.\n",
    "\n",
    "Sans se tromper, la variable aléatoire *Sexe* n’est pas de type numérique quand la variable *Taille*, elle, l’est.\n",
    "\n",
    "Comment s’en assurer avec Python ? La propriété `dtypes` d’un *data frame* répond à l’objectif :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f91e080e-3ebd-4453-bd64-835eae5c87dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame({\n",
    "    'gender': ['F', 'M', 'M', 'F'],\n",
    "    'height': [180, 172, 167, 178]\n",
    "})\n",
    "\n",
    "df.dtypes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a77f499d-2e93-4a5c-9025-ba2231da5390",
   "metadata": {},
   "source": [
    "La variable `height` est bien de type numérique. Pour autant, une variable aléatoire représentée sous forme numérique est-elle systématiquement quantitative, au sens statistique du terme ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a98dcd1b-f766-465c-a4a6-40f2088a79e2",
   "metadata": {},
   "source": [
    "### Numérique ≠ quantitatif"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e745fc2-561b-4507-b85d-aabe1af9fd3d",
   "metadata": {},
   "source": [
    "Pour qu’une variable numérique soit considérée comme quantitative, elle est censée exprimer une quantité. Après avoir ajouté les années de naissance des individus, la propriété `dtypes` signale que la variable `birth`, conformément à l’intuition, est bien de type numérique :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9eb769a-5803-40d6-8350-5952dbfdda66",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"birth\"] = [1983, 1987, 1987, 2001]\n",
    "\n",
    "df.dtypes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "314d9f5f-3a97-43d9-855a-3d543111cc28",
   "metadata": {},
   "source": [
    "Très bien, la variable `birth` est de type numérique (`int64`), mais est-elle quantitative ? Pour le déterminer facilement, il faut se poser la question de savoir si cela fait sens de cumuler les valeurs consignées. Quand les tailles des individus peuvent former une somme pour obtenir ensuite une moyenne, est-ce raisonnable d’additionner des années de naissance ? Le calcul de la moyenne arithmétique des années de naissance donne pour résultat : $1989,5$. Est-il logique de poser ce genre de question ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32a1d256-fe66-456a-a2a4-0193ecd3ba0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"birth\"].mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8f6df12-cc12-4407-815b-b43f696385b5",
   "metadata": {},
   "source": [
    "Eh bien, en fait, oui. Si la moyenne ici n’est pas à proprement parler intéressante, il est légitime de se demander quelle est la médiane des années de naissance des individus interrogés, elle pourrait expliquer certains résultats. En revanche, il n’en serait pas de même des codes postaux de leur lieu d’habitation ou de leurs numéros de sécurité sociale."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df8f7b6d-2f20-45fd-a3c7-a4b031918926",
   "metadata": {},
   "source": [
    "### Quantitative discrète ou continue ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "810f12fa-2005-4607-83e5-8c0be8fbdd53",
   "metadata": {},
   "source": [
    "La différence est encore parfois plus subtile entre les variables aléatoires quantitatives discrètes et continues. Dans l’exemple avec les années, la coutume est de considérer leur valeur comme une discrétion du temps qui, lui, est continu ; d’un autre côté, si le jeu de données comporte une représentation décimale des années, où $1998,55$ équivaudrait au 15 juin 1998, rien n’interdit de considérer qu’il existe alors une continuité.\n",
    "\n",
    "Parfois, une distinction commode véhiculée par certaines sources consiste à considérer une donnée représentée par un élément de l’ensemble $\\mathbb{Z}$ comme discrète, mais appliquer cette préconisation sans réflexion peut amener à des erreurs d’interprétation. L’âge, par exemple, est souvent noté sous forme d’entiers naturels. Il s’agit d’une convention : personne ne passe réellement de $x$ ans à $x+1$ ans sans vivre les intervalles, si ? Pour s’en assurer tout à fait, demandons-nous si le calcul de l’âge moyen des individus d’une enquête ferait sens.\n",
    "\n",
    "En revanche, si au moment de la préparation des données de l’enquête, on établissait des classes d’âge (moins de 18 ans, plus de 35 ans etc.), la variable deviendrait discrète, et qualitative. D’autres données posent les mêmes difficultés, comme la taille, ou le poids, qui, comme elles sont exprimées avec une unité et ne peuvent prendre qu’une valeur isolée, sont cataloguées généralement comme valeurs discrètes. Pourtant, la taille et le poids **d’un individu** peuvent prendre, si mesurés précisément, n’importe quelle valeur dans un intervalle (p. ex. : de 0 à 300 cm) et exprimer ainsi une continuité.\n",
    "\n",
    "Comment, alors, être sûr·es de faire le bon choix ? Dans le doute, une bonne option est de se reposer sur la représentation graphique de la variable en ballottage :\n",
    "- Un diagrammes en barres pour une quantitative discrète ;\n",
    "- un histogramme pour une quantitative continue.\n",
    "\n",
    "Dans notre petit jeu de données, nous avons catalogué la variable *année* comme une quantitative discrète. Représentons-la avec un diagramme en barres, puis un histogramme :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dab08a7d-1778-4c97-b632-9e9ee7f21ba2",
   "metadata": {},
   "outputs": [],
   "source": [
    "figure, (ax_1, ax_2) = plt.subplots(ncols=2, figsize=(10,4))\n",
    "\n",
    "sns.countplot(data=df, x=\"birth\", ax=ax_1)\n",
    "sns.histplot(data=df, x=\"birth\", ax=ax_2)\n",
    "\n",
    "ax_1.set(title=\"Un diagramme en barres\", xlabel=\"Année\", ylabel=\"Nombre\")\n",
    "ax_2.set(title=\"Un histogramme\", xlabel=\"Année\", ylabel=\"Nombre\")\n",
    "\n",
    "sns.despine()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8876458-428a-4f4f-b19e-77cc430d9561",
   "metadata": {},
   "source": [
    "Quand le premier graphique parle de lui-même, le second peine à convaincre."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e0c9a52-6afb-40fb-a897-a49a4f65d13e",
   "metadata": {
    "tags": []
   },
   "source": [
    "## La délicate question du pré-traitement des données"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5132fc43-5d40-4152-abfe-7d435e3d9921",
   "metadata": {},
   "source": [
    "Un algorithme de *machine learning* est grandement dépendant de la qualité des données sur lesquelles il est entraîné. Pour cette raison, la phase de pré-traitement (*pre-processing*) est cruciale. Il s’agira de ne laisser aucune donnée manquante dans le jeu de données et d’harmoniser les grandeurs des variables numériques."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d27cf469-38d0-47c6-bbe2-84e7f75fc2e0",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Distinguer les variables explicatives"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cca97370-a986-40e5-921e-213bd87bd338",
   "metadata": {},
   "source": [
    "Toutes les variables aléatoires d’une enquête ne servent pas forcément à expliquer un trait. Si l’ambition d’un algorithme est par exemple de prédire l’appartenance d’un manchot à telle ou telle espèce, son sexe ne sera pas un facteur déterminant, alors que la longueur de ses nageoires le serait probablement.\n",
    "\n",
    "Commençons par charger le résultat d’une enquête sur la satisfaction des patients à l’hôpital :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8cf3ad26-d808-4792-b1e5-84c75f0c972c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"./files/satisfaction-hopital.csv\", delimiter=\";\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c16c35c-3cd0-4e0b-bf68-b593c506855a",
   "metadata": {},
   "source": [
    "Afin de ne pas décider abritrairement des variables à sélectionner, on dresse une matrice de corrélation où le score révèle leur dépendance avec la variable cible. Sur un *data frame*, il suffit d’appeler la méthode `.corr()` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6172b241-7bbd-4543-b47c-a5fd952d5e14",
   "metadata": {},
   "outputs": [],
   "source": [
    "target = \"recommander\"\n",
    "correlation_matrix = df.corr()\n",
    "\n",
    "correlation_matrix[target]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "941e23c7-fc22-4827-a7fa-233102d17399",
   "metadata": {},
   "source": [
    "Par défaut, le score calculé est le coefficient de corrélation de Pearson (ou *r* de Pearson), qui rend compte de la dépendance entre deux variables. On parle bien de dépendance et non pas de lien de causalité. Échelonné dans un intervalle situé entre $\\mathopen{[}-1;1\\mathclose{]}$, il indique la sensibilité d’une variable de la paire à la variance de l’autre. Un score de $1$ montre ainsi une corrélation linéaire positive, un score de $-1$ une corrélation linéaire négative, et un score de $0$ qu’il n’existe aucune corrélation entre les variables.\n",
    "\n",
    "À partir de la matrice de corrélation, il est facile d’obtenir une carte thermique, parfois plus facile à lire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf8e38be-3f23-480f-8a0b-8b6a5d31449c",
   "metadata": {},
   "outputs": [],
   "source": [
    "_ = sns.heatmap(correlation_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63e5ea8f-b889-42d7-8898-fadde628c7a5",
   "metadata": {},
   "source": [
    "Dans l’exemple de l’enquête sur la satisfaction à l’hôpital, on remarque que la variable *recommander* est quelque peu dépendante du score attribué par le patient à la relation avec le personnel soignant et à la qualité de l’information qu’il a reçue. Comme les coefficients de corrélation sont assez faibles, on pourrait tout aussi bien retenir comme variables explicatives la perception de l’amélioration du moral et de l’état de santé du patient :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3cf686bc-5b1c-4c13-ba5c-9f06f0245b24",
   "metadata": {},
   "outputs": [],
   "source": [
    "features = [\"score.relation\", \"score.information\", \"amelioration.sante\", \"amelioration.moral\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e517eeb7-5309-46ba-ab99-730a90fc5c2a",
   "metadata": {},
   "source": [
    "Il ne reste plus qu’à reconstituer le jeu de données sur lequel nous allons entraîner l’algorithme d’apprentissage :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ffa617d-a11c-4ff1-a450-51cb83f911b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.DataFrame(df[features + [target]])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c729fb68-fe6c-46ef-81a5-804b0776d115",
   "metadata": {
    "tags": []
   },
   "source": [
    "### La chasse aux données manquantes…"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4edf0aba-018d-46ff-8689-4f7870783483",
   "metadata": {},
   "source": [
    "Comment repérer les données manquantes dans un *dataset* et, surtout, comment les gérer ? Pour une seule variable sans valeur, faut-il supprimer toute l’observation ? Et s’il est question de la remplacer, quelle valeur choisir ?\n",
    "\n",
    "La méthode `.info()` d’un *data frame* nous donne un aperçu de l’étendue des données manquantes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c64bb4a7-55ab-45e7-96c7-5e3c2597885f",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a1f3de5-6f37-4d9e-a771-55efc54ab1e3",
   "metadata": {},
   "source": [
    "Il en ressort que les 534 observations ne sont pas toutes complètes, loin s’en faut."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adfbcee8-a2e2-4225-9965-ae260869b307",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Supprimer les observations avec données manquantes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4c8cae9-1900-4e81-b8ba-e175ba8a8b96",
   "metadata": {},
   "source": [
    "La première stratégie consiste à supprimer les observations concernées. Les *data frames* disposent d’une méthode `.dropna()` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f66b937-5a60-4cd1-81ec-5b411c737f64",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_copy = data.dropna()\n",
    "\n",
    "data_copy.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a863d69d-6eca-41ad-9029-ee644cfa579d",
   "metadata": {},
   "source": [
    "L’opération a détruit pratiquement 50 % de l’échantillon, un rapport qui nous semble trop conséquent pour ce jeu de données. Une meilleure stratégie consisterait à combler les manques.\n",
    "\n",
    "Pour autant, il est primordial que la série contenant la variable cible soit complète. Aussi, supprimons les observations où la variable *recommander* n’a pas été renseignée :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72f81239-2738-4c39-9fb8-983769f7057a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# select rows where target is not null\n",
    "data = data[data[target].notna()]\n",
    "data.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d846ee20-fa15-47d2-b36e-8967d438e196",
   "metadata": {},
   "source": [
    "Et, par commodité, réindexons le *data frame* avec la méthode `.reset_index()` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81cfd867-776a-4f77-b15d-54feb7836372",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = data.reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cfaaa82-7de9-45fd-b3f4-bb38cacb6789",
   "metadata": {},
   "source": [
    "#### Remplacer par une valeur"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d024fe1-db93-4f5d-9238-e90f445d716b",
   "metadata": {},
   "source": [
    "Plusieurs options se présentent : remplacer par des zéros, par une valeur fixe, par la moyenne, par la médiane ou encore par la valeur la plus représentée. Chacune de ces options a ses avantages et ses inconvénients.\n",
    "\n",
    "*Scikit-Learn* dispose d’une classe `SimpleImputer` pour réaliser n’importe laquelle de ces options. Elle prend un paramètre `strategy`, dont les valeurs sont à choisir parmi : `mean` (option par défaut), `median`, `most_frequent`, `constant`. Si la stratégie `constant` est sélectionnée, il faut indiquer la valeur dans un paramètre `fill_value`.\n",
    "\n",
    "Remplaçons dans un premier temps les valeurs manquantes par une valeur fixe, le zéro :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b89a0cfa-35fd-4f03-ac6e-db48594c6361",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.impute import SimpleImputer\n",
    "\n",
    "# copy of the data\n",
    "data_copy = pd.DataFrame.copy(data)\n",
    "# new instance\n",
    "imputer = SimpleImputer(strategy=\"constant\", fill_value=0)\n",
    "# fit the imputer to data\n",
    "imputer.fit(data_copy)\n",
    "# create a matrice\n",
    "X = imputer.transform(data_copy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50f2adb8-9717-4e03-a48d-bb39d01a2f28",
   "metadata": {},
   "source": [
    "Dans les données avant traitement, la 7e observation contient deux données manquantes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1c565e7-f691-44b7-88c5-f407c7cc5574",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.iloc[6,:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74123eec-e59c-4691-b76c-aac1ba9ad21c",
   "metadata": {},
   "source": [
    "Après traitement, elles ont bien été fixées à 0 :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e163344f-271f-4e90-be7a-a78b7522af5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# missing values for the 7th sample are now fixed to 0\n",
    "X[6]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e31af55d-7d37-406d-9ba4-b5a36b2c5d90",
   "metadata": {},
   "source": [
    "Cette méthode étant trop destructive, remplaçons plutôt par la valeur médiane :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9bb56765-cb5f-443c-a0a9-b452639857bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# copy\n",
    "data_copy = pd.DataFrame.copy(data)\n",
    "# an imputer with median strategy\n",
    "imputer = SimpleImputer(strategy=\"median\")\n",
    "# shortcut for fit then transform\n",
    "X = imputer.fit_transform(data_copy)\n",
    "\n",
    "# values for the 7th sample\n",
    "X[6]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03e7f2b9-249d-4ff1-bb14-284478a3823c",
   "metadata": {},
   "source": [
    "D’autres imputeurs existent :\n",
    "- `KNNImputer`, pour estimer les valeurs manquantes en fonction des valeurs voisines ;\n",
    "- `IterativeImputer`, qui estime les valeurs à imputer pour chaque caractéristique à partir de toutes les autres."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89b9cc8f-b093-405b-85d8-bdf70c42a927",
   "metadata": {
    "tags": []
   },
   "source": [
    "### … et aux données aberrantes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d324792f-6317-41a3-aab6-613eed13ed84",
   "metadata": {},
   "source": [
    "Les mêmes stratégies peuvent s’appliquer aux données aberrantes, les valeurs extrêmes pouvant affecter négativement certaines mesures. Il s’agit parfois d’un zéro surnuméraire ou du déplacement de la virgule dans la notation décimale d’une quantité. La moyenne arithmétique est par exemple très sensible à ces erreurs. Et il en va de même des algorithmes d’apprentissage automatique."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20959423-cc01-49dd-a6fc-0df629060008",
   "metadata": {},
   "source": [
    "### Séparer les données en jeux d’entraînement et de test"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "423ac871-d5a2-4839-828d-ff6fec8c4254",
   "metadata": {},
   "source": [
    "Il serait tout à fait possible de programmer un système intelligent sur l’ensemble des données à disposition, mais il ne permettrait alors pas de rendre compte de sa performance sur des données qui lui sont inconnues. Pour cette raison, il est d’usage de constituer un jeu pour l’entraîner et un autre pour le mettre à l’épreuve.\n",
    "\n",
    "*Scikit-Learn* propose une fonction `train_test_split()` pour faciliter leur mise en place. Non seulement elle séparera les variables explicatives et la variable cible en deux jeux, mais elle les aura au préalable mélangées afin d’éviter tout biais dû au tri des observations :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40d3f02e-5e78-498c-8cab-a9ca976e878c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# two data frames for: i) the target; ii) the features\n",
    "y = data[target]\n",
    "X = data.drop(columns=target)\n",
    "\n",
    "# two sets for both data frames\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3b8be6b-ee29-4168-a0b0-ff9ab1c2e9f4",
   "metadata": {},
   "source": [
    "Le paramètre `test_size` permet d’indiquer la proportion à utiliser. L’usage recommande un partage 80/20, 80 % pour le jeu d’entraînement et 20 % pour le jeu de test, mais il est à ajuster en fonction de la quantité de données à disposition.\n",
    "\n",
    "Quant au paramètre `random_state`, il permet de contrôler le générateur de nombres aléatoires utilisé. Lui transmettre un entier naturel permet d’assurer la reproductibilité de la transformation. La valeur 42 est souvent renseignée parce qu’il s’agit de la réponse à la [question ultime sur la vie, l’Univers et tout le reste](https://en.wikipedia.org/wiki/Phrases_from_The_Hitchhiker%27s_Guide_to_the_Galaxy#The_Answer_to_the_Ultimate_Question_of_Life,_the_Universe,_and_Everything_is_42)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2736fd39-6991-45ea-be26-4f67c818f055",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Mise à l’échelle"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a01460e-6dfd-42e3-a94b-c069b0a5fe2e",
   "metadata": {},
   "source": [
    "Les données d’une observation font rarement toutes référence à une échelle commune. L’âge d’un individu sera compris entre 0 et 100, sa taille entre 0 et 200, son score de satisfaction entre 0 et 10, la numération de ses globules rouges entre 3 000 000 et 6 000 000 etc. Il faut savoir que les algorithmes d’apprentissage sont sensibles à la différence entre les grandeurs et fourniront des prédictions de mauvaise qualité si certaines variables sont réparties dans un espace bien plus vaste que les autres.\n",
    "\n",
    "La mise à l’échelle consiste alors à réduire leur variance ou leur valeur absolue. Plusieurs méthodes existent et, parmi les plus utilisées, citons la **standardisation** et la **normalisation**.\n",
    "\n",
    "Avant toutes choses, récupérons une variable descriptive de la satisfaction des patients à l’hôpital, le score de relation avec le personnel soignant et comblons manuellement les données manquantes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5089a7e-f8a3-4449-90d2-a4eb051720c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "score_relation_median = data[\"score.relation\"].median()\n",
    "score_relation = data[\"score.relation\"].fillna(score_relation_median)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98912bc7-c7b1-41f5-a5f9-2e9ea51771f3",
   "metadata": {},
   "source": [
    "#### La standardisation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2ac119f-a851-431b-b26c-949ed2f5a1ab",
   "metadata": {},
   "source": [
    "La standardisation (*Z score normalization*) consiste à centrer la variable autour de 0 de telle manière que son écart-type soit égal à 1. La formule donne avec $\\mu$ pour la moyenne et $\\sigma$ pour l’écart-type :\n",
    "\n",
    "$$f(x) = \\frac{x − \\mu}{\\sigma}$$\n",
    "\n",
    "Avant de centrer-réduire la variable *score_relation*, l’affichage de sa moyenne et de son écart-type donne 35,33 pour la première et 4,25 pour la seconde."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d9b02eb-d85b-4bb5-a0c1-e97d03754ee0",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\n",
    "    f\"Mean value: { score_relation.mean().round(2) }\",\n",
    "    f\"Standard deviation: { score_relation.std().round(2) }\",\n",
    "    sep=\"\\n\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7021e34-c512-4eab-bbd6-7e2d4774ef8a",
   "metadata": {},
   "source": [
    "Concrètement, l’opération de standardisation va d’abord soustraire la moyenne puis diviser ensuite le résultat par l’écart-type. Si l’on effectue ce calcul à la main, on obtient bien une moyenne à 0 et un écart-type de 1 :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6101999-82f4-491f-96ee-40a8a2f09c22",
   "metadata": {},
   "outputs": [],
   "source": [
    "score_relation_scaled = [\n",
    "    (n - score_relation.mean()) / score_relation.std()\n",
    "    for n in score_relation\n",
    "]\n",
    "score_relation_scaled = pd.Series( (value for value in score_relation_scaled) )\n",
    "\n",
    "print(\n",
    "    f\"Mean value: { score_relation_scaled.mean().round(2) }\",\n",
    "    f\"Standard deviation: { score_relation_scaled.std().round(2) }\",\n",
    "    sep=\"\\n\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31eae630-d67f-45a5-8d69-3c10da031725",
   "metadata": {},
   "source": [
    "Il existe heureusement une classe `StandardScaler` dans *Scikit-Learn* pour effectuer l’opération plus simplement :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6da43185-4b4c-4208-affc-f7c4852838f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# standard scaler\n",
    "scaler = StandardScaler()\n",
    "\n",
    "# reshape Serie to match 2d array\n",
    "score_relation_scaled = scaler.fit_transform(score_relation.values.reshape(-1, 1))\n",
    "\n",
    "print(\n",
    "    f\"Mean value: { score_relation_scaled.mean().round(2) }\",\n",
    "    f\"Standard deviation: { score_relation_scaled.std().round(2) }\",\n",
    "    sep=\"\\n\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d93cd73-a75b-48d3-92a2-dbcf1639e019",
   "metadata": {},
   "source": [
    "#### La normalisation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "297986b4-6260-466a-8c10-d9559a108d55",
   "metadata": {},
   "source": [
    "Plus simple à appréhender, la normalisation Min-Max (*Min-Max normalization*) est une méthode qui va soustraire à chaque valeur la minimale puis la diviser ensuite par l’écart maximal de la série. Comme la formule est basée sur les extrêmes, elle est particulièrement sensible aux données aberrantes.\n",
    "\n",
    "$$f(x) = \\frac{x − min(x)}{max(x) − min(x)}$$\n",
    "\n",
    "Le résultat n’est plus une variable centrée réduite, mais une variable dont les valeurs seront contenues dans un intervalle $[0, 1]$.\n",
    "\n",
    "En reprenant l’exemple précédent sur le score de relation, nous appliquons cette fois-ci une classe `MinMaxScaler` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26c16b3b-5d41-4a2e-9169-edc937fd2e3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "scaler = MinMaxScaler()\n",
    "score_relation_scaled = scaler.fit_transform(score_relation.values.reshape(-1, 1))\n",
    "\n",
    "score_relation_scaled[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c1785c8-ca09-4a31-b111-c74624c3351c",
   "metadata": {
    "tags": []
   },
   "source": [
    "## La mise en place d’un pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44c7eafd-9783-4072-b648-d34c6881ea40",
   "metadata": {},
   "source": [
    "Les pipelines en *machine learning* ne servent pas à convoyer des fluides, comme par exemple du gaz naturel ou du pétrole brut, mais plutôt des données. Comme les étapes de transformation sont parfois nombreuses et qu’il est impératif de les exécuter dans le bon ordre (remplacer les données manquantes avant de mettre les séries à l’échelle, etc.), *Scikit-Learn* fournit une fonction `make_pipeline()` pour garantir la cohérence entre elles :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97e4374a-dbd2-4c79-8f70-bdd6e0616fc4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.pipeline import make_pipeline\n",
    "\n",
    "model = make_pipeline(\n",
    "    SimpleImputer(strategy=\"median\"),\n",
    "    StandardScaler(),\n",
    "    LinearRegression()\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05b5406b-1474-44ec-b7ab-720b8b1556b8",
   "metadata": {},
   "source": [
    "Un pipeline est constitué de plusieurs estimateurs. Tous les estimateurs, à l’exception du dernier, doivent être des transformateurs.\n",
    "\n",
    "Comme la dernière étape est assurée par un prédicteur, il suffit maintenant d’appeler la méthode `.fit()` pour ajuster le modèle sur les données d’entraînement :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "790290c5-b3b9-4d0f-89b8-389ee808a690",
   "metadata": {},
   "outputs": [],
   "source": [
    "_ = model.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f986c186-1f5d-4432-9718-0b0d6c9d84dc",
   "metadata": {},
   "source": [
    "Un autre avantage non négligeable des pipelines est qu’ils sont nettement plus rapides que si l’on réalisait les étapes une à une."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e077b477-13d8-4a1d-8f84-7c5ec84adbb9",
   "metadata": {},
   "source": [
    "## Effectuer des prédictions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3df4846f-b55c-4d9f-840b-a8d16614ce19",
   "metadata": {},
   "source": [
    "La méthode `.predict()` permet d’effectuer des prédictions. En lui envoyant les données du jeu de test (`X_test`), cela permet de comparer avec les résultats obtenus pour la variable cible (`y_test`) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c4d6495-bc11-4995-8f93-0c8eb16dc848",
   "metadata": {},
   "outputs": [],
   "source": [
    "# make some predictions\n",
    "model.predict(X_test)\n",
    "\n",
    "# evaluate (R2 score, mainly in [0, 1])\n",
    "model.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c8798f4-a8de-407f-8b0d-bc048ff0db5c",
   "metadata": {},
   "source": [
    "Le coefficient de détermination mesure ici la qualité de la prédiction du modèle de régression linéaire. D’ordinaire situé dans l’intervalle $[0,1]$, un score de 0,43 montre la faiblesse de notre modèle, mais ne serait-il pas plutôt ici révélateur d’une erreur de méthode ? Quelle serait-elle selon vous ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "feed50c7-8255-4b1e-93b9-cea1353f9daf",
   "metadata": {},
   "source": [
    "### Prédire avec des données inédites"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9af6324c-4aaf-4f75-b486-14f045c58683",
   "metadata": {},
   "source": [
    "Afin d’obtenir des prédictions à partir de données originales, la seule contrainte est qu’elles respectent le format des données sur lesquelles la machine a été entraînée. Prenons l’exemple de trois nouveaux patients qui attribuent les scores suivants aux quatre variables explicatives retenues par notre modèle :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "984da706-cf43-49f6-89b0-8a74c6ca5065",
   "metadata": {},
   "outputs": [],
   "source": [
    "# unseen data…\n",
    "new_data = {\n",
    "    \"score.relation\": [32, 36, 31],\n",
    "    \"score.information\": [37, 25, 30],\n",
    "    \"amelioration.sante\": [3, 2, 1],\n",
    "    \"amelioration.moral\": [2, 3, 3]\n",
    "}\n",
    "\n",
    "# … as a data frame\n",
    "new_data = pd.DataFrame(new_data)\n",
    "\n",
    "# get predictions\n",
    "model.predict(new_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b5d5953-babe-4644-8904-2ca9ccf836d7",
   "metadata": {},
   "source": [
    "## Récapitulatif"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1e6d3c2-bb43-40f9-876a-6ae4cf3a39ce",
   "metadata": {},
   "source": [
    "Si nous reprenons les différentes étapes de la programmation de notre petite intelligence artificielle :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "102b45e5-7618-4a49-a495-8a67af6c747e",
   "metadata": {},
   "source": [
    "### 1e étape : extraire les variables cible et explicatives"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ab63df5-f207-4daf-89bc-9d5cc5da4142",
   "metadata": {},
   "source": [
    "L’analyse du jeu de données permet de déterminer quelles sont les variables explicatives à retenir pour programmer au mieux l’IA :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0817ac27-c0f7-4029-8488-8d5834bc60fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"./files/satisfaction-hopital.csv\", delimiter=\";\")\n",
    "\n",
    "# uncomment to display the correlation between all variables\n",
    "#_ = sns.heatmap(df.corr())\n",
    "\n",
    "target = \"recommander\"\n",
    "features = [\"score.relation\", \"score.information\", \"amelioration.sante\", \"amelioration.moral\"]\n",
    "\n",
    "data = pd.DataFrame(df[features + [target]])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c283d5b-8ffd-486f-833b-5e4fdcdbf438",
   "metadata": {},
   "source": [
    "### 2e étape : établir le jeu d’entraînement et le jeu de test"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cec842c6-95e4-4c75-b134-f9fd33212ded",
   "metadata": {},
   "source": [
    "Dans un premier temps, seules sont retenues les observations pour lesquelles la donnée de la variable cible est connue. Toutes les autres sont supprimées. Une fonction de *Scikit-Learn* se charge ensuite de la répartition des données entre tous les jeux nécessaires (deux jeux pour d’un côté la variable cible ; deux autres pour les caractéristiques retenues) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ce5e398-4a6c-433f-bc96-5d3132fcd3bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# drop rows where target is missing\n",
    "data.dropna(subset=target, inplace=True)\n",
    "\n",
    "# two data frames for: i) the target; ii) the features\n",
    "y = data[target]\n",
    "X = data[features]\n",
    "\n",
    "# two sets for both data frames\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e4e4690-8ac7-41ff-bdb4-27bc660ca3bd",
   "metadata": {},
   "source": [
    "### 3e étape : définir les couches du modèle"