Workflow_Ultime_2_(code).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_EFrydps2_8G"
   },
   "source": [
    "# Phase 1 - Récuperer les données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "jbJWeuCC2v4e"
   },
   "outputs": [],
   "source": [
    "train_url = 'http://bit.ly/titanic-train-set'\n",
    "test_url  = 'http://bit.ly/titanic-test-set'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 354
    },
    "id": "pPi61Szl3EYv",
    "outputId": "33351ceb-1026-4389-8724-71ab56e8a582"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Survived</th>\n",
       "      <th>Pclass</th>\n",
       "      <th>Name</th>\n",
       "      <th>Sex</th>\n",
       "      <th>Age</th>\n",
       "      <th>SibSp</th>\n",
       "      <th>Parch</th>\n",
       "      <th>Ticket</th>\n",
       "      <th>Fare</th>\n",
       "      <th>Cabin</th>\n",
       "      <th>Embarked</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>PassengerId</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>Braund, Mr. Owen Harris</td>\n",
       "      <td>male</td>\n",
       "      <td>22.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>A/5 21171</td>\n",
       "      <td>7.2500</td>\n",
       "      <td>NaN</td>\n",
       "      <td>S</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>Cumings, Mrs. John Bradley (Florence Briggs Th...</td>\n",
       "      <td>female</td>\n",
       "      <td>38.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>PC 17599</td>\n",
       "      <td>71.2833</td>\n",
       "      <td>C85</td>\n",
       "      <td>C</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>Heikkinen, Miss. Laina</td>\n",
       "      <td>female</td>\n",
       "      <td>26.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>STON/O2. 3101282</td>\n",
       "      <td>7.9250</td>\n",
       "      <td>NaN</td>\n",
       "      <td>S</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>Futrelle, Mrs. Jacques Heath (Lily May Peel)</td>\n",
       "      <td>female</td>\n",
       "      <td>35.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>113803</td>\n",
       "      <td>53.1000</td>\n",
       "      <td>C123</td>\n",
       "      <td>S</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>Allen, Mr. William Henry</td>\n",
       "      <td>male</td>\n",
       "      <td>35.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>373450</td>\n",
       "      <td>8.0500</td>\n",
       "      <td>NaN</td>\n",
       "      <td>S</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             Survived  Pclass  \\\n",
       "PassengerId                     \n",
       "1                   0       3   \n",
       "2                   1       1   \n",
       "3                   1       3   \n",
       "4                   1       1   \n",
       "5                   0       3   \n",
       "\n",
       "                                                          Name     Sex   Age  \\\n",
       "PassengerId                                                                    \n",
       "1                                      Braund, Mr. Owen Harris    male  22.0   \n",
       "2            Cumings, Mrs. John Bradley (Florence Briggs Th...  female  38.0   \n",
       "3                                       Heikkinen, Miss. Laina  female  26.0   \n",
       "4                 Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  35.0   \n",
       "5                                     Allen, Mr. William Henry    male  35.0   \n",
       "\n",
       "             SibSp  Parch            Ticket     Fare Cabin Embarked  \n",
       "PassengerId                                                          \n",
       "1                1      0         A/5 21171   7.2500   NaN        S  \n",
       "2                1      0          PC 17599  71.2833   C85        C  \n",
       "3                0      0  STON/O2. 3101282   7.9250   NaN        S  \n",
       "4                1      0            113803  53.1000  C123        S  \n",
       "5                0      0            373450   8.0500   NaN        S  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Si il ya un split train / test, on le fait.\n",
    "\n",
    "# Train Set\n",
    "df = pd.read_csv(train_url, index_col=\"PassengerId\")\n",
    "# Test Set\n",
    "df_test = pd.read_csv(test_url, index_col=\"PassengerId\")\n",
    "\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 252
    },
    "id": "4jIAzOqB37Mf",
    "outputId": "3a20c826-5a4b-466e-9d64-a3a8dc088211"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Pclass</th>\n",
       "      <th>Name</th>\n",
       "      <th>Sex</th>\n",
       "      <th>Age</th>\n",
       "      <th>SibSp</th>\n",
       "      <th>Parch</th>\n",
       "      <th>Ticket</th>\n",
       "      <th>Fare</th>\n",
       "      <th>Cabin</th>\n",
       "      <th>Embarked</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>PassengerId</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>892</th>\n",
       "      <td>3</td>\n",
       "      <td>Kelly, Mr. James</td>\n",
       "      <td>male</td>\n",
       "      <td>34.5</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>330911</td>\n",
       "      <td>7.8292</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Q</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>893</th>\n",
       "      <td>3</td>\n",
       "      <td>Wilkes, Mrs. James (Ellen Needs)</td>\n",
       "      <td>female</td>\n",
       "      <td>47.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>363272</td>\n",
       "      <td>7.0000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>S</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>894</th>\n",
       "      <td>2</td>\n",
       "      <td>Myles, Mr. Thomas Francis</td>\n",
       "      <td>male</td>\n",
       "      <td>62.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>240276</td>\n",
       "      <td>9.6875</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Q</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>895</th>\n",
       "      <td>3</td>\n",
       "      <td>Wirz, Mr. Albert</td>\n",
       "      <td>male</td>\n",
       "      <td>27.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>315154</td>\n",
       "      <td>8.6625</td>\n",
       "      <td>NaN</td>\n",
       "      <td>S</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>896</th>\n",
       "      <td>3</td>\n",
       "      <td>Hirvonen, Mrs. Alexander (Helga E Lindqvist)</td>\n",
       "      <td>female</td>\n",
       "      <td>22.0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>3101298</td>\n",
       "      <td>12.2875</td>\n",
       "      <td>NaN</td>\n",
       "      <td>S</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             Pclass  ... Embarked\n",
       "PassengerId          ...         \n",
       "892               3  ...        Q\n",
       "893               3  ...        S\n",
       "894               2  ...        Q\n",
       "895               3  ...        S\n",
       "896               3  ...        S\n",
       "\n",
       "[5 rows x 10 columns]"
      ]
     },
     "execution_count": 8,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_test.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZVSWVQfF3jPz"
   },
   "source": [
    "# Phase 2 - Isoler les features `X` des cibles `Y`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "g_NndEPs3iz9"
   },
   "outputs": [],
   "source": [
    "# Pour le train test\n",
    "colonne_cible = \"Survived\"\n",
    "\n",
    "X = df.drop(colonne_cible, axis='columns')\n",
    "Y = df[colonne_cible]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PySPVtgQ3PWd"
   },
   "outputs": [],
   "source": [
    "# Pour le test\n",
    "X_test = df_test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pIWKEm_B4Qiv"
   },
   "source": [
    "# Phase 3 - EDA\n",
    "\n",
    "On va juste regarder les valeurs nulles.\n",
    "\n",
    "(en théorie il faudrait aussi recharcher la présence de valeur aberrante, tracer des graphiques etc...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bJ7A1y8_4CSu",
    "outputId": "d9d418dc-20d4-423c-fca6-b3fb427e45e8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pclass        0\n",
       "Name          0\n",
       "Sex           0\n",
       "Age         177\n",
       "SibSp         0\n",
       "Parch         0\n",
       "Ticket        0\n",
       "Fare          0\n",
       "Cabin       687\n",
       "Embarked      2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 12,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check valeur nulle sur le train\n",
    "X.isna().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "RJ4-1Mpa4wnT",
    "outputId": "54115965-3a68-41e1-ca0e-cf4c51bebbe6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pclass        0\n",
       "Name          0\n",
       "Sex           0\n",
       "Age          86\n",
       "SibSp         0\n",
       "Parch         0\n",
       "Ticket        0\n",
       "Fare          1\n",
       "Cabin       327\n",
       "Embarked      0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 16,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check valeur nulle sur le test\n",
    "X_test.isna().sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "T4ItGCz-4__b"
   },
   "source": [
    "# Phase 4 - Déterminer quoi faire avec chaque colonne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "wpYpCjgw40iL"
   },
   "outputs": [],
   "source": [
    "# Les colonnes sur lesquelles on va faire un traitement\n",
    "colonnes_catégoriques = ['Sex']\n",
    "colonnes_numériques = []\n",
    "colonnes_catégoriques_avec_valeurs_manquantes = ['Embarked']\n",
    "colonnes_numériques_avec_valeurs_manquantes = ['Age', 'Fare']\n",
    "colonnes_feature_engineering = ['Name' , 'Cabin']  # CountVectorizer / Cabin etc...\n",
    "\n",
    "# Le reste\n",
    "drop_colonnes = ['Ticket']  # Colonnes à lacher\n",
    "passthrough_colonnes = ['Pclass', 'SibSp', 'Parch'] # Colonnes à laisser-passer telles quelles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "JHhUPwlL7-8M",
    "outputId": "245ce3d9-0a87-4c7a-c37e-6ab3906a8bd1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ok\n"
     ]
    }
   ],
   "source": [
    "# Vérifier qu'on a tout\n",
    "\n",
    "all_columns = (colonnes_catégoriques \n",
    "               + colonnes_numériques \n",
    "               + colonnes_catégoriques_avec_valeurs_manquantes\n",
    "               + colonnes_numériques_avec_valeurs_manquantes\n",
    "               + colonnes_feature_engineering\n",
    "               + drop_colonnes\n",
    "               + passthrough_colonnes)\n",
    "\n",
    "if set(all_columns) == set(X.columns):\n",
    "  print('Ok')\n",
    "else:\n",
    "  # Alors je veux voir les différences\n",
    "  print('dans all_columns mais pas dans X.columns   :', set(all_columns) - set(X.columns))\n",
    "  print('dans X.columns   mais pas dans all_columns :', set(X.columns) - set(all_columns))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0TlcXQIg9nRR"
   },
   "source": [
    "# Phase 5 - Data Cleaning\n",
    "\n",
    "### 1. Importer les outils "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "09Fivl188UrJ"
   },
   "outputs": [],
   "source": [
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.compose import make_column_transformer\n",
    "from sklearn.pipeline import make_pipeline, Pipeline\n",
    "from sklearn.preprocessing import FunctionTransformer\n",
    "\n",
    "from sklearn."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "190wPEaF-LRp"
   },
   "source": [
    "### 2. Créer les transformers complexes (ceux qui sont pas ok, out-of-box)\n",
    "\n",
    "Dans notre cas:\n",
    "\n",
    "\n",
    "*   `'Embarked'` : Valeur Manquante -> Categorique [One Hot] \n",
    "*   `'Cabin'` : Feature Engineering -> Valeur Manquante -> Categorique [One Hot] \n",
    "\n",
    "https://towardsdatascience.com/pipeline-columntransformer-and-featureunion-explained-f5491f815f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xhHJpfx6-KqG"
   },
   "outputs": [],
   "source": [
    "fill_missing_then_one_hot_encoder = make_pipeline(\n",
    "    SimpleImputer(strategy='constant', fill_value='manquante'),\n",
    "    OneHotEncoder(handle_unknown='ignore')\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rFLtMc2Z_9sB"
   },
   "outputs": [],
   "source": [
    "def extraire_la_première_lettre(serie):\n",
    "    return pd.DataFrame(serie.str[0])\n",
    "\n",
    "extraire_lettre_cabine = make_pipeline(\n",
    "    FunctionTransformer(extraire_la_première_lettre),\n",
    "    fill_missing_then_one_hot_encoder,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DF8H9PrY-VLb"
   },
   "source": [
    "### 3. Les combiner dans un ColumnTransformer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nsaigajy-IUe"
   },
   "outputs": [],
   "source": [
    "data_cleaning = make_column_transformer(\n",
    "    ( OneHotEncoder(), colonnes_catégoriques ),\n",
    "    ( fill_missing_then_one_hot_encoder , colonnes_catégoriques_avec_valeurs_manquantes),\n",
    "    ( SimpleImputer(strategy='mean'), colonnes_numériques_avec_valeurs_manquantes),\n",
    "    ( CountVectorizer(), 'Name'),\n",
    "    ( extraire_lettre_cabine, 'Cabin'),\n",
    "    ( 'drop' , drop_colonnes),\n",
    "    ( 'passthrough' , passthrough_colonnes)\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "q_3uPj8eDomm",
    "outputId": "b33ff0f5-7fec-4f36-c93a-73accc5f1c3c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C'est bon\n"
     ]
    }
   ],
   "source": [
    "# Il est conseillé de vérfiier que ça marche\n",
    "# pour ça, on va voir si on peut fit transform sans erreur\n",
    "\n",
    "# data_cleaning.fit(X)\n",
    "\n",
    "# data_cleaning.transform(X)\n",
    "\n",
    "# data_cleaning.transform(X_test)\n",
    "\n",
    "print('C\\'est bon')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8hGD7m98EMDY"
   },
   "source": [
    "# Phase 6 - Trouver la Meilleure Pipeline\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "fpjmK7FSJkA8"
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import GridSearchCV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zjVACzWEE-if"
   },
   "source": [
    "### étape 1 : Définir Procédure de Cross-Validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "dtz3-FwpE-yi",
    "outputId": "0e1fad1d-730e-461b-f5d1-af478be4db29"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KFold(n_splits=5, random_state=77, shuffle=True)"
      ]
     },
     "execution_count": 1,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import KFold\n",
    "\n",
    "cross_validation_design = KFold(n_splits=5,\n",
    "                                shuffle=True,\n",
    "                                random_state=77)\n",
    "\n",
    "cross_validation_design"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2NIH3tN7Ebr2"
   },
   "source": [
    "### Pipeline 1 : KNN (pas de PCA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Q6oAtB3jGzuL"
   },
   "outputs": [],
   "source": [
    "data_cleaning = make_column_transformer(\n",
    "    ( OneHotEncoder(), colonnes_catégoriques ),\n",
    "    ( fill_missing_then_one_hot_encoder , colonnes_catégoriques_avec_valeurs_manquantes),\n",
    "    ( SimpleImputer(strategy='mean'), colonnes_numériques_avec_valeurs_manquantes),\n",
    "    ( CountVectorizer(), 'Name'),\n",
    "    ( extraire_lettre_cabine, 'Cabin'),\n",
    "    ( 'drop' , drop_colonnes),\n",
    "    ( 'passthrough' , passthrough_colonnes)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "xv9xHIofEGhz",
    "outputId": "a9fd4fc5-2092-4f44-b338-7d814ac55d5f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=KFold(n_splits=5, random_state=77, shuffle=True),\n",
       "             error_score=nan,\n",
       "             estimator=Pipeline(memory=None,\n",
       "                                steps=[('data_cleaning',\n",
       "                                        ColumnTransformer(n_jobs=None,\n",
       "                                                          remainder='drop',\n",
       "                                                          sparse_threshold=0.3,\n",
       "                                                          transformer_weights=None,\n",
       "                                                          transformers=[('onehotencoder',\n",
       "                                                                         OneHotEncoder(categories='auto',\n",
       "                                                                                       drop=None,\n",
       "                                                                                       dtype=<class 'numpy.float64'>,\n",
       "                                                                                       handle_unknown='error...\n",
       "                                        KNeighborsClassifier(algorithm='auto',\n",
       "                                                             leaf_size=30,\n",
       "                                                             metric='minkowski',\n",
       "                                                             metric_params=None,\n",
       "                                                             n_jobs=None,\n",
       "                                                             n_neighbors=5, p=2,\n",
       "                                                             weights='uniform'))],\n",
       "                                verbose=False),\n",
       "             iid='deprecated', n_jobs=None,\n",
       "             param_grid={'knn__n_neighbors': [1, 3, 9, 21, 51],\n",
       "                         'knn__weights': ['uniform', 'distance']},\n",
       "             pre_dispatch='2*n_jobs', refit=True, return_train_score=False,\n",
       "             scoring=None, verbose=0)"
      ]
     },
     "execution_count": 75,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier as KNN\n",
    "\n",
    "KNN_MODEL = {}\n",
    "\n",
    "# Définir la pipeline\n",
    "KNN_MODEL['pipeline'] = Pipeline([\n",
    "                                  ('data_cleaning', data_cleaning),\n",
    "                                  ('knn', KNN())\n",
    "                                  ])\n",
    "\n",
    "# Définir la grille\n",
    "KNN_MODEL['hyperparams'] = {}\n",
    "KNN_MODEL['hyperparams']['knn__n_neighbors'] = [1, 3, 9, 21, 51]\n",
    "KNN_MODEL['hyperparams']['knn__weights'] = ['uniform', 'distance']\n",
    "\n",
    "# Effectuer la GridSearch\n",
    "KNN_MODEL['gridsearch'] = GridSearchCV(\n",
    "    estimator=KNN_MODEL['pipeline'],\n",
    "    param_grid=KNN_MODEL['hyperparams'],\n",
    "    cv=cross_validation_design,\n",
    "    scoring='accuracy'\n",
    "    )\n",
    "\n",
    "KNN_MODEL['gridsearch'].fit(X, Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "lxs3RcAiHoZG",
    "outputId": "1b5bf071-eecc-40d8-d28c-7262ec502dd7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'knn__n_neighbors': 9, 'knn__weights': 'distance'}"
      ]
     },
     "execution_count": 76,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "KNN_MODEL['gridsearch'].best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fA5q6JKZKO5k",
    "outputId": "6f3eea07-4498-40c5-94bd-d32c1f726d32"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7205511267340405"
      ]
     },
     "execution_count": 77,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "KNN_MODEL['gridsearch'].best_score_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "T5WvSY3_Ed-y"
   },
   "source": [
    "### Pipeline 2 : RidgeRegression Classifier (un type de régression linéaire avec Feature Selection intégrée)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "F5uTTB1yEtCP"
   },
   "outputs": [],
   "source": [
    "data_cleaning = make_column_transformer(\n",
    "    ( OneHotEncoder(), colonnes_catégoriques ),\n",
    "    ( fill_missing_then_one_hot_encoder , colonnes_catégoriques_avec_valeurs_manquantes),\n",
    "    ( SimpleImputer(strategy='mean'), colonnes_numériques_avec_valeurs_manquantes),\n",
    "    ( CountVectorizer(), 'Name'),\n",
    "    ( extraire_lettre_cabine, 'Cabin'),\n",
    "    ( 'drop' , drop_colonnes),\n",
    "    ( 'passthrough' , passthrough_colonnes)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "u_yynXLWEzJM",
    "outputId": "bdfe353f-17ef-4b16-b2f7-3ea20e74220b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=KFold(n_splits=5, random_state=77, shuffle=True),\n",
       "             error_score=nan,\n",
       "             estimator=Pipeline(memory=None,\n",
       "                                steps=[('data_cleaning',\n",
       "                                        ColumnTransformer(n_jobs=None,\n",
       "                                                          remainder='drop',\n",
       "                                                          sparse_threshold=0.3,\n",
       "                                                          transformer_weights=None,\n",
       "                                                          transformers=[('onehotencoder',\n",
       "                                                                         OneHotEncoder(categories='auto',\n",
       "                                                                                       drop=None,\n",
       "                                                                                       dtype=<class 'numpy.float64'>,\n",
       "                                                                                       handle_unknown='error...\n",
       "       2.7, 2.8, 2.9, 3. , 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9,\n",
       "       4. , 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.7, 4.8, 4.9, 5. , 5.1, 5.2,\n",
       "       5.3, 5.4, 5.5, 5.6, 5.7, 5.8, 5.9, 6. , 6.1, 6.2, 6.3, 6.4, 6.5,\n",
       "       6.6, 6.7, 6.8, 6.9, 7. , 7.1, 7.2, 7.3, 7.4, 7.5, 7.6, 7.7, 7.8,\n",
       "       7.9, 8. , 8.1, 8.2, 8.3, 8.4, 8.5, 8.6, 8.7, 8.8, 8.9, 9. , 9.1,\n",
       "       9.2, 9.3, 9.4, 9.5, 9.6, 9.7, 9.8, 9.9])},\n",
       "             pre_dispatch='2*n_jobs', refit=True, return_train_score=False,\n",
       "             scoring='accuracy', verbose=0)"
      ]
     },
     "execution_count": 83,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import RidgeClassifier\n",
    "\n",
    "# Définir la pipeline\n",
    "REGRESSION_MODEL = {}\n",
    "REGRESSION_MODEL['pipeline'] = Pipeline([\n",
    "                                        ('data_cleaning', data_cleaning ),\n",
    "                                        ('reg', RidgeClassifier())\n",
    "])\n",
    "\n",
    "# Définir la grille\n",
    "REGRESSION_MODEL['hyperparams'] = {}\n",
    "REGRESSION_MODEL['hyperparams']['reg__alpha'] = np.arange(.1, 10., .1)\n",
    "\n",
    "# Faire la recherche\n",
    "REGRESSION_MODEL['gridsearch'] = GridSearchCV(\n",
    "                                      estimator=REGRESSION_MODEL['pipeline'],\n",
    "                                      param_grid=REGRESSION_MODEL['hyperparams'],\n",
    "                                      cv=cross_validation_design,\n",
    "                                      scoring='accuracy'\n",
    "                                      )\n",
    "\n",
    "REGRESSION_MODEL['gridsearch'].fit(X, Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "nO-9HQ5FL01h",
    "outputId": "664ee3a2-f50b-4b5b-cd8d-426104eae55c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'reg__alpha': 5.1}"
      ]
     },
     "execution_count": 85,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "REGRESSION_MODEL['gridsearch'].best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "cbjlX42TMBsi",
    "outputId": "c8baa17d-3bdf-4c35-ec7c-d879410c2bbf"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.830500282468144"
      ]
     },
     "execution_count": 87,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "REGRESSION_MODEL['gridsearch'].best_score_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gtg8qdSaEziV"
   },
   "source": [
    "### Pipeline 3 - RandomForest (le meilleur modèle quand on y connait rien)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yyksu6e5E5Ps"
   },
   "outputs": [],
   "source": [
    "data_cleaning = make_column_transformer(\n",
    "    ( OneHotEncoder(), colonnes_catégoriques ),\n",
    "    ( fill_missing_then_one_hot_encoder , colonnes_catégoriques_avec_valeurs_manquantes),\n",
    "    ( SimpleImputer(strategy='mean'), colonnes_numériques_avec_valeurs_manquantes),\n",
    "    ( CountVectorizer(), 'Name'),\n",
    "    ( extraire_lettre_cabine, 'Cabin'),\n",
    "    ( 'drop' , drop_colonnes),\n",
    "    ( 'passthrough' , passthrough_colonnes)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "_xW72BggG1tN",
    "outputId": "10c48f0f-fcf4-4c8d-d109-de4d462e765f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=KFold(n_splits=5, random_state=77, shuffle=True),\n",
       "             error_score=nan,\n",
       "             estimator=Pipeline(memory=None,\n",
       "                                steps=[('data_cleaning',\n",
       "                                        ColumnTransformer(n_jobs=None,\n",
       "                                                          remainder='drop',\n",
       "                                                          sparse_threshold=0.3,\n",
       "                                                          transformer_weights=None,\n",
       "                                                          transformers=[('onehotencoder',\n",
       "                                                                         OneHotEncoder(categories='auto',\n",
       "                                                                                       drop=None,\n",
       "                                                                                       dtype=<class 'numpy.float64'>,\n",
       "                                                                                       handle_unknown='error...\n",
       "                                                               n_jobs=None,\n",
       "                                                               oob_score=False,\n",
       "                                                               random_state=7,\n",
       "                                                               verbose=0,\n",
       "                                                               warm_start=False))],\n",
       "                                verbose=False),\n",
       "             iid='deprecated', n_jobs=None,\n",
       "             param_grid={'rf__max_depth': [None, 4, 7, 10, 20],\n",
       "                         'rf__max_features': [None, 'sqrt', 'log2', 0.1, 0.25,\n",
       "                                              0.5, 0.75, 0.85],\n",
       "                         'rf__n_estimators': [10, 30, 50, 100, 150]},\n",
       "             pre_dispatch='2*n_jobs', refit=True, return_train_score=False,\n",
       "             scoring='accuracy', verbose=0)"
      ]
     },
     "execution_count": 94,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier as RandomForest\n",
    "\n",
    "RF_MODEL = {}\n",
    "\n",
    "# Définir la pipe\n",
    "RF_MODEL['pipeline']=Pipeline([\n",
    "                               ('data_cleaning', data_cleaning),\n",
    "                               ('rf', RandomForest(random_state=7))])\n",
    "\n",
    "# Définir la grille d'hyperparams\n",
    "RF_MODEL['hyperparams'] = {}\n",
    "RF_MODEL['hyperparams']['rf__n_estimators'] = [10, 30, 50, 100, 150]\n",
    "RF_MODEL['hyperparams']['rf__max_features'] = [None, 'sqrt', 'log2', .1, .25, .50, .75, .85]\n",
    "RF_MODEL['hyperparams']['rf__max_depth'] = [None, 4, 7, 10, 20]\n",
    "\n",
    "# Recherche d'HP\n",
    "RF_MODEL['gridsearch'] = GridSearchCV(\n",
    "    estimator=RF_MODEL['pipeline'],\n",
    "    param_grid=RF_MODEL['hyperparams'],\n",
    "    scoring='accuracy',\n",
    "    cv=cross_validation_design\n",
    ")\n",
    "\n",
    "RF_MODEL['gridsearch'].fit(X, Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Q0ZqcndNMZal",
    "outputId": "5688fa97-d9f7-44e4-c96d-f42fcd546e6e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'rf__max_depth': 10, 'rf__max_features': 0.25, 'rf__n_estimators': 150}"
      ]
     },
     "execution_count": 95,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "RF_MODEL['gridsearch'].best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "2Mo6-ZGKM-G-",
    "outputId": "e7ef0267-2a75-4278-82cf-1695ee5de2d9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8350134957002071"
      ]
     },
     "execution_count": 96,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "RF_MODEL['gridsearch'].best_score_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PPv0MxStOhCs"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Lm-W8xaLOjdO"
   },
   "source": [
    "# On selectionne le meilleur modèle : on va réentrainer sur tout (sans cross val) avec les meilleurs params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "iDJcOhVNOpvA",
    "outputId": "f1bae091-fb4a-47c7-9724-d338a118ec39"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(memory=None,\n",
       "         steps=[('data_cleaning',\n",
       "                 ColumnTransformer(n_jobs=None, remainder='drop',\n",
       "                                   sparse_threshold=0.3,\n",
       "                                   transformer_weights=None,\n",
       "                                   transformers=[('onehotencoder',\n",
       "                                                  OneHotEncoder(categories='auto',\n",
       "                                                                drop=None,\n",
       "                                                                dtype=<class 'numpy.float64'>,\n",
       "                                                                handle_unknown='error',\n",
       "                                                                sparse=True),\n",
       "                                                  ['Sex']),\n",
       "                                                 ('pipeline-1',\n",
       "                                                  Pipeline(memory=None,\n",
       "                                                           steps=[('simpleimputer',\n",
       "                                                                   Simple...\n",
       "                 RandomForestClassifier(bootstrap=True, ccp_alpha=0.0,\n",
       "                                        class_weight=None, criterion='gini',\n",
       "                                        max_depth=10, max_features=0.25,\n",
       "                                        max_leaf_nodes=None, max_samples=None,\n",
       "                                        min_impurity_decrease=0.0,\n",
       "                                        min_impurity_split=None,\n",
       "                                        min_samples_leaf=1, min_samples_split=2,\n",
       "                                        min_weight_fraction_leaf=0.0,\n",
       "                                        n_estimators=150, n_jobs=None,\n",
       "                                        oob_score=False, random_state=7,\n",
       "                                        verbose=0, warm_start=False))],\n",
       "         verbose=False)"
      ]
     },
     "execution_count": 97,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_cleaning = make_column_transformer(\n",
    "    ( OneHotEncoder(), colonnes_catégoriques ),\n",
    "    ( fill_missing_then_one_hot_encoder , colonnes_catégoriques_avec_valeurs_manquantes),\n",
    "    ( SimpleImputer(strategy='mean'), colonnes_numériques_avec_valeurs_manquantes),\n",
    "    ( CountVectorizer(), 'Name'),\n",
    "    ( extraire_lettre_cabine, 'Cabin'),\n",
    "    ( 'drop' , drop_colonnes),\n",
    "    ( 'passthrough' , passthrough_colonnes)\n",
    ")\n",
    "\n",
    "model_final = Pipeline([('data_cleaning', data_cleaning),\n",
    "                        ('rf', RandomForest(random_state=7,\n",
    "                                            max_depth=10,\n",
    "                                            max_features=0.25,\n",
    "                                            n_estimators=150))\n",
    "                        ])\n",
    "\n",
    "\n",
    "# on fit la meilleur pipe sur toute nos données de train\n",
    "model_final.fit(X, Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dow8RocbL3rS"
   },
   "source": [
    "# Fini"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nd0sY9NzQOer"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "name": "Workflow_Ultime_2_(code).ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}