diff --git "a/notebooks/R\303\251duction_de_f\303\264rets_al\303\251atoires_with_dev-Copy1.ipynb" "b/notebooks/R\303\251duction_de_f\303\264rets_al\303\251atoires_with_dev-Copy1.ipynb"
new file mode 100644
index 0000000000000000000000000000000000000000..7cd2cee155c9bb50fc8a9edcfa45c5bb20048361
--- /dev/null
+++ "b/notebooks/R\303\251duction_de_f\303\264rets_al\303\251atoires_with_dev-Copy1.ipynb"
@@ -0,0 +1,643 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Groupe de travail\n",
+    "\n",
+    "Le but de ce notebook est de tester l'idée de réduction des random forest"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Import scikit-learn"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from statistics import mean \n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import pandas as pd\n",
+    "from sklearn.datasets import load_boston, load_breast_cancer\n",
+    "from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor\n",
+    "from sklearn.linear_model import OrthogonalMatchingPursuit, OrthogonalMatchingPursuitCV\n",
+    "from sklearn.metrics import mean_squared_error\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.neighbors.kde import KernelDensity"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Variables globales"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "NB_TREES = 100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load jeu de donnée"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X, y = load_boston(return_X_y=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def train_forest(X_train, y_train, nb_trees, random_seed):\n",
+    "    '''\n",
+    "    Function that will train a random forest with nb_tress\n",
+    "    :param X_train: list of inputs\n",
+    "    :param y_train: list of results\n",
+    "    :param nb_trees: int, number of trees in the forest\n",
+    "    :param random_seed: int, seed for the random_states\n",
+    "    :return: a RandomForestRegressor\n",
+    "    '''\n",
+    "    \n",
+    "     # Entraînement de la forêt aléatoire\n",
+    "    \n",
+    "    regressor = RandomForestRegressor(n_estimators=nb_trees, random_state = random_seed)\n",
+    "    regressor.fit(X_train, y_train)\n",
+    "    return regressor\n",
+    "\n",
+    "\n",
+    "def extract_subforest(random_forest, X_train, y_train, nb_trees_extracted):\n",
+    "    '''\n",
+    "    Function use to get the weight list of a subforest of size nb_trees_extracted for random_forest\n",
+    "    using OMP.\n",
+    "    :param random_forest: a RandomForestRegressor\n",
+    "    :param X_train: list of inputs\n",
+    "    :param y_train: list of results\n",
+    "    :param nb_trees_extracted: int, number of trees extracted \n",
+    "    :return: a list of int, weight of each tree\n",
+    "    '''\n",
+    "    \n",
+    "    # Accès à la la liste des arbres\n",
+    "\n",
+    "    tree_list = random_forest.estimators_\n",
+    "    \n",
+    "    # Création de la matrice des prédictions de chaque arbre\n",
+    "    \n",
+    "    # L'implémentation de scikit-learn est un peu différente que celle vue en réunion, D est de même taille que X \n",
+    "    # et chaque élément est composé de d signaux, d'où la création suivante de D où on créé une liste pour chaque\n",
+    "    # élément comprenant les valeurs prédites par chaque arbre\n",
+    "\n",
+    "    D = [[tree.predict([elem])[0] for tree in tree_list] for elem in X_train]\n",
+    "    \n",
+    "    # OMP\n",
+    "    \n",
+    "    omp = OrthogonalMatchingPursuit(n_nonzero_coefs=nb_trees_extracted, fit_intercept = False, normalize=False)\n",
+    "    omp.fit(D, y_train)\n",
+    "    \n",
+    "    weights = omp.coef_\n",
+    "    \n",
+    "    return weights\n",
+    "\n",
+    "\n",
+    "def compute_results(weights, random_forest, X_train, X_dev, X_test, y_train, y_dev, y_test, \n",
+    "                    nb_trees, nb_trees_extracted, random_seed):\n",
+    "    '''\n",
+    "    Compute the score of the different techniques\n",
+    "    :param weights: weights given by the OMP\n",
+    "    :param random_forest: a RandomForestRegressor\n",
+    "    :param X_train: list of inputs\n",
+    "    :param X_dev: list of inputs\n",
+    "    :param X_test: list of inputs\n",
+    "    :param y_train: list of results\n",
+    "    :param y_dev: list of results\n",
+    "    :param y_test: list of results\n",
+    "    :param nb_trees: int, number of trees in the main forest\n",
+    "    :param nb_trees_extracted: int, number of trees extracted from the main forest\n",
+    "    :param random_seed: int, seed for the random_states\n",
+    "    :return: 4 results of 4 different methods, in order: results of the main forest, \n",
+    "    results of the weighted results of the extracted trees, results of the mean results \n",
+    "    of the extracted trees, results of a random_forest train with nb_trees_extracted directly\n",
+    "    '''\n",
+    "    \n",
+    "    # Calcul des différents résultats\n",
+    "    \n",
+    "    res_base_forest = mean_squared_error(random_forest.predict(X_test), y_test)\n",
+    "    \n",
+    "    # Résultat de la forêt extraite avec l'OMP, où chaque arbre est multiplié par son poids\n",
+    "    \n",
+    "    y_pred = [sum([random_forest.estimators_[i].predict([elem])[0] * weights[i] for i in range(nb_trees)]) \n",
+    "              for elem in X_test]\n",
+    "    res_extract_weight = mean_squared_error(y_pred, y_test)\n",
+    "    \n",
+    "    # Résultat de la forêt extraite avec l'OMP, où chaque arbre est multiplié par son poids\n",
+    "    \n",
+    "    y_pred = [sum([random_forest.estimators_[i].predict([elem])[0] * weights[i] for i in range(nb_trees)])/sum(weights) \n",
+    "              for elem in X_test]\n",
+    "    res_extract_weight_norm = mean_squared_error(y_pred, y_test)\n",
+    "    \n",
+    "    # Résultat de la forêt extraite avec l'OMP, où on prends la moyenne des arbres extraits\n",
+    "    \n",
+    "    y_pred = [mean([random_forest.estimators_[i].predict([elem])[0] for i in range(nb_trees) if abs(weights[i]) >= 0.01])\n",
+    "              for elem in X_test]\n",
+    "    res_extract_mean = mean_squared_error(y_pred, y_test)\n",
+    "    \n",
+    "    # Résultat d'une forêt avec le même nombre d'arbre que le nombre d'arbre extrait\n",
+    "\n",
+    "    small_forest = train_forest(np.concatenate((X_train, X_dev)), np.concatenate((y_train, y_dev)), nb_trees_extracted, random_seed)\n",
+    "    res_small_forest = mean_squared_error(small_forest.predict(X_test), y_test)\n",
+    "    \n",
+    "    return res_base_forest, res_extract_weight, res_extract_weight_norm, res_extract_mean, res_small_forest, weights\n",
+    "\n",
+    "\n",
+    "def extract_and_get_results(random_forest, X_train, X_dev, X_test, y_train, y_dev, y_test, nb_trees, \n",
+    "                            nb_trees_extracted, random_seed):\n",
+    "    '''\n",
+    "    Extract the subforest and returns the resuts of the different methods\n",
+    "    :param X_train: list of inputs\n",
+    "    :param X_dev: list of inputs\n",
+    "    :param X_test: list of inputs\n",
+    "    :param y_train: list of results\n",
+    "    :param y_dev: list of results\n",
+    "    :param y_test: list of results\n",
+    "    :param nb_trees: int, number of trees in the main forest\n",
+    "    :param nb_trees_extracted: int, number of trees extracted from the main forest\n",
+    "    :param random_seed: int, seed for the random_states\n",
+    "    :return: 4 results of 4 different methods, in order: results of the main forest, \n",
+    "    results of the weighted results of the extracted trees, results of the mean results \n",
+    "    of the extracted trees, results of a random_forest train with nb_trees_extracted directly\n",
+    "    '''\n",
+    "    \n",
+    "    weights = extract_subforest(random_forest, X_dev, y_dev, nb_trees_extracted)\n",
+    "    \n",
+    "    res_base_forest, res_extract_weight, res_extract_weight_norm, res_extract_mean, res_small_forest = \\\n",
+    "        compute_results(weights, random_forest, X_train, X_dev, X_test, y_train, y_dev, y_test, \n",
+    "                        nb_trees, nb_trees_extracted, random_seed)\n",
+    "    \n",
+    "    return res_base_forest, res_extract_weight, res_extract_weight_norm, res_extract_mean, res_small_forest, weights\n",
+    "    \n",
+    "    \n",
+    "\n",
+    "def train_extract_subforest(X_train, X_test, y_train, y_test, nb_trees, nb_trees_extracted, random_seed):\n",
+    "    '''\n",
+    "    Function that takes data, number of trees and a random seed. Train a forest with nb_trees, extract\n",
+    "    with OMP nb_trees_extracted and compare the results of the different method\n",
+    "    :param X_train: list of inputs\n",
+    "    :param X_test: list of inputs\n",
+    "    :param y_train: list of results\n",
+    "    :param y_test: list of results\n",
+    "    :param nb_trees: int, number of trees in the main forest\n",
+    "    :param nb_trees_extracted: int, number of trees extracted from the main forest\n",
+    "    :param random_seed: int, seed for the random_states\n",
+    "    :return: 4 results of 4 different methods, in order: results of the main forest, \n",
+    "    results of the weighted results of the extracted trees, results of the mean results \n",
+    "    of the extracted trees, results of a random_forest train with nb_trees_extracted directly\n",
+    "    '''\n",
+    "    \n",
+    "    random_forest = train_forest(X_train, y_train, nb_trees, random_seed)\n",
+    "    \n",
+    "    weight = extract_subforest(random_forest, X_train, y_train, nb_trees_extracted)\n",
+    "    \n",
+    "    res_base_forest, res_extract_weight, res_extract_mean, res_small_forest = \\\n",
+    "        compute_results(weight, random_forest, X_train, X_test, y_train, y_test,\n",
+    "                        nb_trees, nb_trees_extracted, random_seed)\n",
+    "    \n",
+    "    \n",
+    "    return res_base_forest, res_extract_weight, res_extract_mean, res_small_forest"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results_global = []\n",
+    "results_dev_global = []\n",
+    "\n",
+    "nb_trees = 100\n",
+    "random_seeds = list(range(10))\n",
+    "\n",
+    "for random_seed in random_seeds:\n",
+    "    \n",
+    "    # Séparation train_test avec random_state\n",
+    "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = random_seed)\n",
+    "    X_train, X_dev, y_train, y_dev = train_test_split(X_train, y_train, test_size = 0.5, random_state = random_seed)\n",
+    "\n",
+    "    random_forest = train_forest(X_train, y_train, NB_TREES, random_seed)\n",
+    "    \n",
+    "    results = []\n",
+    "    results_dev = []\n",
+    "\n",
+    "    for nb_trees_extracted in [int(NB_TREES/k) for k in [2, 5, 10, 20, 50, 100]]:\n",
+    "        \n",
+    "        weights = extract_subforest(random_forest, X_dev, y_dev, nb_trees_extracted)\n",
+    "\n",
+    "        results.append(compute_results(weights, random_forest, X_train, X_dev, X_test, y_train, y_dev, y_test, \n",
+    "                        nb_trees, nb_trees_extracted, random_seed))\n",
+    "        \n",
+    "        \n",
+    "        results_dev.append(compute_results(weights, random_forest, X_train, X_dev, X_dev, y_train, y_dev, y_dev, \n",
+    "                           nb_trees, nb_trees_extracted, random_seed))\n",
+    "\n",
+    "    results_global.append(results)\n",
+    "    results_dev_global.append(results_dev)\n",
+    "    print('over')\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_results(results_global, title_graph):\n",
+    "    def plot_mean_and_CI(mean, lb, ub, x_value, color_mean=None, color_shading=None, label=None):\n",
+    "        # plot the shaded range of the confidence intervals\n",
+    "        plt.fill_between(x_value, ub, lb,\n",
+    "                         color=color_shading, alpha=.5)\n",
+    "        # plot the mean on top\n",
+    "        plt.plot(x_value, mean, color_mean, label = label)\n",
+    "\n",
+    "    means_results = np.array(\n",
+    "        [\n",
+    "            [mean(\n",
+    "                [results[i][k] for results in results_global] # loop over the different experiments\n",
+    "            ) for i in range(len(results_global[0]))] # loop over the different number of trees extracted\n",
+    "        for k in range(5)]) # loop over the different methods\n",
+    "    std_results = np.array(\n",
+    "        [\n",
+    "            [np.std(\n",
+    "                [results[i][k] for results in results_global]\n",
+    "            ) for i in range(len(results_global[0]))]\n",
+    "        for k in range(5)])\n",
+    "\n",
+    "    x_value = [int(NB_TREES/k) for k in [2, 5, 10, 20, 50, 100]]\n",
+    "    # plot the data\n",
+    "    fig = plt.figure(1, figsize=(15, 10))\n",
+    "    plot_mean_and_CI(means_results[0], means_results[0] + std_results[0], means_results[0] - std_results[0],\n",
+    "                     x_value, color_mean='k', color_shading='k', label='Results of the base forest (on train set)')\n",
+    "\n",
+    "    plot_mean_and_CI(means_results[1], means_results[1] + std_results[1], means_results[1] - std_results[1],\n",
+    "                     x_value, color_mean='darkorange', color_shading='darkorange', \n",
+    "                     label='Weighted results of the extracted trees')\n",
+    "    plot_mean_and_CI(means_results[2], means_results[2] + std_results[2], means_results[2] - std_results[2], \n",
+    "                     x_value, color_mean='red', color_shading='red',\n",
+    "x                    label='Weighted results of the extracted trees normalized')\n",
+    "\n",
+    "    plot_mean_and_CI(means_results[3], means_results[3] + std_results[3], means_results[3] - std_results[3], \n",
+    "                     x_value, color_mean='b', color_shading='b',\n",
+    "                    label='Mean results of the extracted trees')\n",
+    "    plot_mean_and_CI(means_results[4], means_results[4] + std_results[4], means_results[4] - std_results[4], \n",
+    "                     x_value, color_mean='g', color_shading='g',\n",
+    "                    label='Results of a forest train with number of trees extracted (train+dev set)')\n",
+    "    plt.xlabel('Number of trees extracted')\n",
+    "    plt.ylabel('MSE')\n",
+    "    plt.title(title_graph)\n",
+    "\n",
+    "    plt.legend(loc=\"upper right\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "plot_results(results_global, 'Reduction of a forest with 100 trees, 10 iterations with different seed, score on train set')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plot_results(results_dev_global, 'Reduction of a forest with 100 trees, 10 iterations with different seed, score on dev set')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "for results in results_global:\n",
+    "    x_value = [int(NB_TREES/k) for k in [5, 10, 50, 100, 500, 1000]]\n",
+    "    plt.xlabel('Number of trees extracted')\n",
+    "    plt.ylabel('MSE')\n",
+    "    plt.plot(x_value, [elem[1] for elem in results], color='darkorange',\n",
+    "             label='Weighted results of the average trees')\n",
+    "    plt.plot(x_value, [elem[2] for elem in results], color='red',\n",
+    "            label='Weighted results of the average trees normalized')\n",
+    "    plt.plot(x_value, [elem[3] for elem in results], color='blue',\n",
+    "             label='Mean results of the average trees')\n",
+    "    plt.plot(x_value, [elem[4] for elem in results], color='green',\n",
+    "             label='Results of a forest train with number of trees extracted')\n",
+    "    plt.plot(x_value, [elem[0] for elem in results], color='black',\n",
+    "             label='Results of the base forest')\n",
+    "    plt.figure(1, figsize=(15, 10))\n",
+    "\n",
+    "    plt.legend(loc=\"upper right\")\n",
+    "    \n",
+    "\n",
+    "\n",
+    "    fig_acc_rec = plt.gcf()\n",
+    "\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def weight_density(list_weight):\n",
+    "    print(list_weight)\n",
+    "    X_plot = [np.exp(elem) for elem in list_weight]\n",
+    "    fig, ax = plt.subplots()\n",
+    "\n",
+    "    for kernel in ['gaussian', 'tophat', 'epanechnikov']:\n",
+    "        kde = KernelDensity(kernel=kernel, bandwidth=0.5).fit(X_plot)\n",
+    "        log_dens = kde.score_samples(X_plot)\n",
+    "        ax.plot(X_plot[:, 0], np.exp(log_dens), '-',\n",
+    "                label=\"kernel = '{0}'\".format(kernel))\n",
+    "\n",
+    "    ax.legend(loc='upper left')\n",
+    "    ax.plot(X[:, 0], -0.005 - 0.01 * np.random.random(X.shape[0]), '+k')\n",
+    "\n",
+    "    ax.set_xlim(-4, 9)\n",
+    "    ax.set_ylim(-0.02, 0.4)\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for results in results_global:\n",
+    "    ax = pd.Series([[e for e in test[5] if e != 0] for test in results][1]).plot.kde(figsize=(15, 10))\n",
+    "    \n",
+    "legends = ['OK'] * 10\n",
+    "legends[4] = 'Problème'\n",
+    "# ax.legend(legends)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "np.array(\n",
+    "    [\n",
+    "        [\n",
+    "            [results[i][k] for results in results_global]\n",
+    "        for i in range(len(results_global[0]))]\n",
+    "    for k in range(5)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "[[sum(elem[5]) for elem in results] for results in results_global] "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results_global[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Entraînement de la forêt aléatoire"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "regressor = RandomForestRegressor(n_estimators=NB_TREES, random_state = RANDOM_SEED)\n",
+    "\n",
+    "regressor.fit(X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Accès à la la liste des arbres\n",
+    "\n",
+    "tree_list = regressor.estimators_"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Création de la matrice des prédictions de chaque arbre"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# L'implémentation de scikit-learn est un peu différente que celle vue en réunion, D est de même taille que X \n",
+    "# et chaque élément est composé de d signaux, d'où la création suivante de D où on créé une liste pour chaque\n",
+    "# élément comprenant les valeurs prédites par chaque arbre\n",
+    "\n",
+    "D = [[tree.predict([elem])[0] for tree in tree_list] for elem in X_train]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "omp = OrthogonalMatchingPursuit(n_nonzero_coefs=NB_TREES_EXTRACTED)\n",
+    "omp.fit(D, y_train)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# Matrice avec poids de chaque arbre\n",
+    "\n",
+    "omp.coef_"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Calcul des résultats des différentes méthodes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Résultat de la forêt de base"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mean_squared_error(regressor.predict(X_test), y_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Résultat de la forêt extraite avec l'OMP, où chaque arbre est multiplié par son poids"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_pred = [sum([tree_list[i].predict([elem])[0] * omp.coef_[i] for i in range(NB_TREES)]) for elem in X_test]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mean_squared_error(y_pred, y_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Résultat de la forêt extraite avec l'OMP, où on prends la moyenne des arbres extraits"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_pred = [mean([tree_list[i].predict([elem])[0] for i in range(NB_TREES) if omp.coef_[i] != 0])for elem in X_test]\n",
+    "mean_squared_error(y_pred, y_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Résultat d'une forêt avec le même nombre d'arbre que le nombre d'arbre extrait"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "regressor_small = RandomForestRegressor(n_estimators=NB_TREES_EXTRACTED, random_state=RANDOM_SEED)\n",
+    "regressor_small.fit(X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mean_squared_error(regressor_small.predict(X_test), y_test)"
+   ]
+  },
+  {
+   "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.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git "a/notebooks/R\303\251duction_de_f\303\264rets_al\303\251atoires_with_dev.ipynb" "b/notebooks/R\303\251duction_de_f\303\264rets_al\303\251atoires_with_dev.ipynb"
index b1230045c7095c727b5dd563bd5bc730cf2d3134..12771672ebfabab04cd2a126ec5bc1c2f8f13a05 100644
--- "a/notebooks/R\303\251duction_de_f\303\264rets_al\303\251atoires_with_dev.ipynb"
+++ "b/notebooks/R\303\251duction_de_f\303\264rets_al\303\251atoires_with_dev.ipynb"
@@ -18,7 +18,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -42,7 +42,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -60,7 +60,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -69,18 +69,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Séparation train_test avec random_state\n",
     "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = RANDOM_SEED)\n",
-    "X_train, X_dev, y_train, y_dev = train_test_split(X, y, test_size = 0.2, random_state = RANDOM_SEED)"
+    "X_train, X_dev, y_train, y_dev = train_test_split(X_train, y_train, test_size = 0.2, random_state = RANDOM_SEED)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -236,56 +236,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/l_bouscarrat/miniconda3/envs/groupe_travail/lib/python3.7/site-packages/sklearn/linear_model/omp.py:387: RuntimeWarning:  Orthogonal matching pursuit ended prematurely due to linear\n",
-      "dependence in the dictionary. The requested precision might not have been met.\n",
-      "\n",
-      "  copy_X=copy_X, return_path=return_path)\n",
-      "/home/l_bouscarrat/miniconda3/envs/groupe_travail/lib/python3.7/site-packages/sklearn/linear_model/omp.py:387: RuntimeWarning:  Orthogonal matching pursuit ended prematurely due to linear\n",
-      "dependence in the dictionary. The requested precision might not have been met.\n",
-      "\n",
-      "  copy_X=copy_X, return_path=return_path)\n",
-      "/home/l_bouscarrat/miniconda3/envs/groupe_travail/lib/python3.7/site-packages/sklearn/linear_model/omp.py:387: RuntimeWarning:  Orthogonal matching pursuit ended prematurely due to linear\n",
-      "dependence in the dictionary. The requested precision might not have been met.\n",
-      "\n",
-      "  copy_X=copy_X, return_path=return_path)\n",
-      "/home/l_bouscarrat/miniconda3/envs/groupe_travail/lib/python3.7/site-packages/sklearn/linear_model/omp.py:387: RuntimeWarning:  Orthogonal matching pursuit ended prematurely due to linear\n",
-      "dependence in the dictionary. The requested precision might not have been met.\n",
-      "\n",
-      "  copy_X=copy_X, return_path=return_path)\n",
-      "/home/l_bouscarrat/miniconda3/envs/groupe_travail/lib/python3.7/site-packages/sklearn/linear_model/omp.py:387: RuntimeWarning:  Orthogonal matching pursuit ended prematurely due to linear\n",
-      "dependence in the dictionary. The requested precision might not have been met.\n",
-      "\n",
-      "  copy_X=copy_X, return_path=return_path)\n",
-      "/home/l_bouscarrat/miniconda3/envs/groupe_travail/lib/python3.7/site-packages/sklearn/linear_model/omp.py:387: RuntimeWarning:  Orthogonal matching pursuit ended prematurely due to linear\n",
-      "dependence in the dictionary. The requested precision might not have been met.\n",
-      "\n",
-      "  copy_X=copy_X, return_path=return_path)\n",
-      "/home/l_bouscarrat/miniconda3/envs/groupe_travail/lib/python3.7/site-packages/sklearn/linear_model/omp.py:387: RuntimeWarning:  Orthogonal matching pursuit ended prematurely due to linear\n",
-      "dependence in the dictionary. The requested precision might not have been met.\n",
-      "\n",
-      "  copy_X=copy_X, return_path=return_path)\n",
-      "/home/l_bouscarrat/miniconda3/envs/groupe_travail/lib/python3.7/site-packages/sklearn/linear_model/omp.py:387: RuntimeWarning:  Orthogonal matching pursuit ended prematurely due to linear\n",
-      "dependence in the dictionary. The requested precision might not have been met.\n",
-      "\n",
-      "  copy_X=copy_X, return_path=return_path)\n",
-      "/home/l_bouscarrat/miniconda3/envs/groupe_travail/lib/python3.7/site-packages/sklearn/linear_model/omp.py:387: RuntimeWarning:  Orthogonal matching pursuit ended prematurely due to linear\n",
-      "dependence in the dictionary. The requested precision might not have been met.\n",
-      "\n",
-      "  copy_X=copy_X, return_path=return_path)\n",
-      "/home/l_bouscarrat/miniconda3/envs/groupe_travail/lib/python3.7/site-packages/sklearn/linear_model/omp.py:387: RuntimeWarning:  Orthogonal matching pursuit ended prematurely due to linear\n",
-      "dependence in the dictionary. The requested precision might not have been met.\n",
-      "\n",
-      "  copy_X=copy_X, return_path=return_path)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "results_global = []\n",
     "\n",
@@ -308,32 +261,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fe1ee5fda10>"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1080x720 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "def plot_mean_and_CI(mean, lb, ub, x_value, color_mean=None, color_shading=None, label=None):\n",
     "    # plot the shaded range of the confidence intervals\n",
@@ -381,132 +311,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {
     "scrolled": false
    },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdd3wUdfrA8c+TEESpoghIFxuQTiABpImASj0EEVFBVBRFUU/OcjbO0x92T89ewIqInh4neIJKFQQC0kEQCdIOAkgJNeX5/TGz6ybZTTO7G5LnrfvK7tRnZ4d55jvlGVFVjDHGmLwiwh2AMcaYsskShDHGGL8sQRhjjPHLEoQxxhi/LEEYY4zxq1K4AyhNZ555pjZt2jTcYRhjzElj6dKle1S1jr9+5SpBNG3alNTU1HCHYYwxJw0R2RKonx1iMsYY45clCGOMMX4FLUGISCMRmSUi60RkjYiMcbvXFpGZIrLR/Xt6gPGHucNsFJFhwYrTGGOMf8E8B5EF/FlVl4lIdWCpiMwEhgPfqup4EbkPuA+413dEEakNPAIkAeqOO1VVfwtivABkZmaybds2jh07FuxZGWNMyFSpUoWGDRsSFRVV5HGCliBUdSew031/SETWAQ2AfkAXd7B3gdnkSRBAT2Cmqu4DcBPLpcCkYMXrsW3bNqpXr07Tpk0RkWDPzhhjgk5V2bt3L9u2baNZs2ZFHi8k5yBEpCmQACwC6rrJw5NEzvIzSgNgq8/nbW43f9MeKSKpIpKanp7+h2M9duwYZ5xxhiUHY0y5ISKcccYZxT4yEvQEISLVgM+AO1X1YFFH89PNb9lZVX1DVZNUNalOHb+X8habJQdjTHlTku1aUBOEiEThJIcPVfVfbuddIlLf7V8f2O1n1G1AI5/PDYEdwYrzsTmP8fXPXwdr8sYYc1IK5lVMArwNrFPV53x6TQU8VyUNA/7tZ/SvgR4icrp7lVMPt1tQjP9+PDN/mRmsyRfLXXfdxQsvvOD93LNnT2688Ubv5z//+c8899xz/kb1at++faHzadq0KXv27MnXffbs2SxYsKAYERc8vWCpVq0aAGlpaXz00UelMs0pU6bQokULunbtmqt73nlMnDiR0aNHl8o8TwYTJ05kx46g7Z+ZMiyYLYgOwLXAxSKy3H1dDowHuovIRqC7+xkRSRKRtwDck9OPAUvc1988J6yDISoiiszszGBNvljat2/v3UDn5OSwZ88e1qxZ4+2/YMECOnToUOA0SrKB9yhpgiiK7OzsUp9maSaIt99+m1deeYVZs2YFbR7BkpWVFbRpF5QggvGbmjJEVcvNq3Xr1loSZz51po76cpSqqq5du7ZE0ygt27dv1wYNGqiq6sqVK/W6667T7t276759+/TYsWNas2ZNPX78uKqqPvXUU5qUlKQxMTH68MMPe6dRtWpVVVXNzs7WUaNGacuWLbVXr1562WWX6ZQpU1RVtUmTJvrwww9rQkKCRkdH67p163Tz5s1at25dPfvsszUuLk7nzp2ru3fv1gEDBmhSUpImJSXp/PnzVVV1z5492r17d42Pj9eRI0dq48aNNT09Pd/3qVq1qj700EPatm1bnTdvnqampmqnTp00MTFRe/TooTt27FBV1X/84x/aokULjYmJ0cGDB6uq6iOPPKJPP/20d1qtWrXSzZs35/qOycnJWqNGDY2Li9PnnntOV69erW3atNG4uDiNiYnRDRs25Ivpo48+0ujoaG3VqpX+5S9/UVXVcePGadWqVfX888/Xe+65J9fweecxYcIE/dOf/qQ9e/bUc889V8eOHesd9uuvv9aUlBRNSEjQgQMH6qFDh/LN/4033tCkpCSNjY3VAQMG6OHDh3X//v3apEkTzc7OVlXVw4cPa8OGDfXEiRP6888/a8+ePTUxMVEvuugiXbdunaqqDhs2TO+66y7t0qWL3n333bpo0SJt166dxsfHa7t27XT9+vXeaQ0aNEhjYmL0yiuv1LZt2+qSJUuKFO+UKVO8yyUuLk6PHDmiTZo00XHjxmmHDh100qRJAeMLtO7Mnj1b4+LiNC4uTuPj4/XgwYP5lpEJDn/bNyBVA2xTw75RL81XSRNE/Wfq643/vjH/AvxujOrHnUv39d2YQuNp0qSJbtmyRV977TV99dVX9cEHH9Rp06bp/PnztWPHjqrq/MO+6aabNCcnR7Ozs7VXr146Z84cVf194zllyhS97LLLNDs7W3fu3Km1atXKlSBefPFFVVV9+eWX9YYbblDV/BvlIUOG6Lx581RVdcuWLXrhhReqqurtt9+u48aNU1XVL7/8UgG/CQLQyZMnq6rqiRMntF27drp7925VVf3444/1+uuvd36D+vX12LFjqqr622+/+Y3FX4KYNWuW9urVyzvM6NGj9YMPPlBV1ePHj+uRI0dyxbN9+3Zt1KiR7t69WzMzM7Vr1676+eefq6pq586dvRtOX3nnMWHCBG3WrJnu379fjx49qo0bN9Zff/1V09PTtWPHjpqRkaGqquPHj/cuI1979uzxvv/rX//q/R369u2r3333nXfZeH6Tiy++2JvofvjhB+3atauqOgmiV69empWVpaqqBw4c0MzMTFVVnTlzpg4YMEBVVZ9++mkdOXKkqqquWrVKIyMjdcmSJUWON+9yadKkiT755JPez4HiC7Tu9O7d25ssDh065I3ZBF9xE0S5KtZXUlGRUWTmlI1DTAAdOnRgwYIFLFiwgLvvvpvt27ezYMECatas6T2/MGPGDGbMmEFCQgIAGRkZbNy4kU6dOnmnM3/+fAYNGkRERAT16tXLd2x9wIABALRu3Zp//etf+PPNN9+wdu1a7+eDBw9y6NAh5s6d6x2nV69enH663xviiYyM5IorrgDgp59+YvXq1XTv3h1wDk/Ur18fgNjYWIYOHUr//v3p379/8RaYj3bt2vH444+zbds2BgwYwHnnnZer/5IlS+jSpQueK96GDh3K3Llziz3Pbt26UbNmTQBatmzJli1b2L9/P2vXrvUeAjxx4gTt2rXLN+7q1at58MEH2b9/PxkZGfTs2ROAwYMHM3nyZLp27crHH3/MrbfeSkZGBgsWLGDQoEHe8Y8fP+59P2jQICIjIwE4cOAAw4YNY+PGjYgImZnOOj1//nzGjBkDQHR0NLGxsQD88MMPRYrXn8GDBwMUGF+gdadDhw7cfffdDB06lAEDBtCwYcMizdOEniUI3HMQ/hJE1xfydwsBz3mIVatWER0dTaNGjXj22WepUaMGI0aMAJyW3/3338/NN98ccDrOzkFgp5xyCuBsxAMdw87JyWHhwoWceuqp+foV5bK5KlWqeDdgqkqrVq1YuHBhvuGmTZvG3LlzmTp1Ko899hhr1qyhUqVK5OTkeIcpyjXcV199NcnJyUybNo2ePXvy1ltvcfHFF3v7F7ZMisqz7OD35aeqdO/enUmTCr6fc/jw4XzxxRfExcUxceJEZs+eDUDfvn25//772bdvH0uXLuXiiy/m8OHD1KpVi+XLl/udVtWqVb3vH3roIbp27crnn39OWloaXbp0AQJ/56LGW9B8c3JyAsYXaN2577776NWrF9OnTyclJYVvvvmGCy+8sNgxmOCzYn24LYgycpIanBbEl19+Se3atYmMjKR27drs37+fhQsXevfwevbsyTvvvENGRgYA27dvZ/fu3FcMX3TRRXz22Wfk5OSwa9cu74aoINWrV+fQoUPezz169OCf//yn97NnQ9CpUyc+/PBDAL766it++63wKigXXHAB6enp3gSRmZnJmjVryMnJYevWrXTt2pWnnnrKu2fdtGlTli1bBsCyZcvYvHlzofH+8ssvnHPOOdxxxx307duXlStX5ho+OTmZOXPmsGfPHrKzs5k0aRKdO3cu1jIJJCUlhe+//56ff/4ZgCNHjrBhw4Z8wx06dIj69euTmZnpXYbgXJnVtm1bxowZQ+/evYmMjKRGjRo0a9aMKVOmAM5GfcWKFX7nf+DAARo0cO4nnThxorf7RRddxCeffALA2rVrWbVqVbHiLej7FxRfoHVn06ZNxMTEcO+995KUlMT69ev9TtuEnyUICmhBhElMTAx79uwhJSUlV7eaNWty5plnAs4/vquvvpp27doRExPDwIED8/0jvuKKK2jYsCHR0dHcfPPNJCcnew+LBNKnTx8+//xz4uPjmTdvHi+++CKpqanExsbSsmVLXnvtNQAeeeQR5s6dS2JiIjNmzKBx48aFfq/KlSvz6aefcu+99xIXF0d8fDwLFiwgOzuba665hpiYGBISErjrrruoVasWV1xxBfv27SM+Pp5XX32V888/P980Y2NjqVSpEnFxcTz//PNMnjyZ6Oho4uPjWb9+Pdddd12u4evXr8///d//0bVrV+Li4khMTKRfv34Fxp13HoHUqVOHiRMnMmTIEGJjY0lJSfG78XvsscdITk6me/fu+facBw8ezAcffOA9hAPw4Ycf8vbbbxMXF0erVq3497/9XRkOf/nLX7j//vvp0KFDrquLbr31VtLT04mNjeXJJ58kNjaWmjVrFjne4cOHc8sttxAfH8/Ro0fz9Q8UX6B154UXXiA6Opq4uDhOPfVULrvssoDL1ISXlFaTuyxISkrSkjwwqPUbralfrT5fXv0l69ato0WLFkGILjwyMjKoVq0ae/fupW3btnz//ffUq1cv3GGZEMrOziYzM5MqVaqwadMmunXrxoYNG6hcuXK4QzMh5m/7JiJLVTXJ3/B2DoKy14IoTb1792b//v2cOHGChx56yJJDBXTkyBG6du1KZmYmqsqrr75qycEUiSUIyt45iNJUlPMOpnyrXr26PYrXlIidg6B8tyCMMaakLEFQvlsQxhhTUpYgsBaEMcb4YwkCa0EYY4w/liAoey0IEeHaa6/1fs7KyqJOnTr07t07jFGVXJcuXbwnSZ944olSmeb69euJj48nISGBTZs25ernO4+0tDSio6NLZZ4ng2BW4zUVjyUIyl4LomrVqqxevdp7U9LMmTO9d8iGSrDKR5dWgvjiiy/o168fP/74I82bNw/KPIIlmKW5C0oQwZyvKZ8sQVD2WhAAl112GdOmTQNg0qRJDBkyxNvv8OHDjBgxgjZt2pCQkOC9czUtLY2OHTuSmJhIYmKid0Mxe/ZsunTpwsCBA7nwwgsZOnSo3/o8Xbp04YEHHqBz58784x//ID09nSuuuII2bdrQpk0bvv/+ewDmzJlDfHy8dw/+0KFDzJ49O1cLZ/To0bnKPYBTg+fo0aPEx8czdOhQDh8+TK9evYiLiyM6OprJkyfni2n58uWkpKQQGxvLn/70J3777TemT5/OCy+8wFtvvZWvAGHeeYBzo9hNN91Eq1at6NGjhzfxbtq0iUsvvZTWrVvTsWNHv3cRL168mPbt25OQkED79u356aefAKdkh+9zOrp06cLSpUsD/jYTJ05k0KBB9OnThx49epCRkUG3bt1ITEwkJiYm193Rjz32GBdeeCHdu3dnyJAhPPPMM0WKNy0tjddee43nn3/eeyf88OHDufvuu+natSv33ntvwPiys7MZO3Ysbdq0ITY2ltdffx2AnTt30qlTJ+Lj44mOjmbevHn5lpEpxwKVeT0ZXyUt933jv2/U+s/UV9Xc5XDHjFHt3Ll0X2MKr/atVatW1RUrVugVV1yhR48e1bi4uFwlp++//359//33VdUpjX3eeedpRkaGHj58WI8ePaqqqhs2bFDP8pg1a5bWqFFDt27dqtnZ2ZqSkuItw+yrc+fOOmrUKO/n4pRrzlsS+7bbbtMJEyZ4p+spF+0p062q+umnn+qNN97o/bx///58McXExOjs2bNVVfWhhx7SMe4CzFsKPO/y89i8ebNGRkbqjz/+qKqqgwYN8i67QGWqfQUqof3cc895n8GxY8cOPe+881Q18G8zYcIEbdCgge7du1dVVTMzM/XAgQOqqpqenq7NmzfXnJwcXbJkife5CwcPHtRzzz3X+z2LEm/e5ZK3JHig+F5//XV97LHHVFX12LFj2rp1a/3ll1/0mWee0b///e+qqpqVlWXPbjjJWbnvEihr5b7Bqf+TlpbGpEmTuPzyy3P1mzFjBlOnTvXuWR47doxff/2Vs88+m9GjR7N8+XIiIyNzFV5r27att6xyfHw8aWlpXHTRRfnm61sDKNjlmmNiYrjnnnu499576d27Nx07dszV/8CBA+zfv99bTG/YsGG5ykoXVbNmzYiPjwec0uZpaWmFltH2jcFfCe0rr7yS7t27M27cOD755BPvdAL9NgDdu3endu3agLNj9sADDzB37lwiIiLYvn07u3btYv78+fTr189bAbVPnz5AwWW1C+NbEjxQfDNmzGDlypV8+umn3u+9ceNG2rRpw4gRI8jMzKR///7e5WgqhqAlCBF5B+gN7FbVaLfbZOACd5BawH5VzbfGiUgacAjIBrI0QJ2Q0hLokaMvhKfat1ffvn255557mD17Nnv37vV2V1U+++wzLrjgglzDP/roo9StW5cVK1aQk5NDlSpVvP38laf2x7d8dHHKNZekNPf555/P0qVLmT59Ovfffz89evTg4YcfLnS84sr73Y8ePVpgmWpfgUpoN2jQgDPOOIOVK1cyefJk7yGZQL/NokWLci3bDz/8kPT0dJYuXUpUVBRNmzbl2LFjAUtzFzVef3znGyg+VeWll17yPpvC19y5c5k2bRrXXnstY8eOzVcA0ZRfwTwHMRG41LeDqg5W1Xg3KXwG+H9KjaOrO2xQkwOUzRYEwIgRI3j44YeJiYnJ1b1nz5689NJL3o3Jjz/+CDh7ffXr1yciIoL333//Dz8vuDjlmps0acLatWs5fvw4Bw4c4Ntvv/U7zaioKO9e+I4dOzjttNO45ppruOeee7ylvT1q1qzJ6aef7j3u/f777xdamjvvPAIpahntQCW0Aa666iqeeuopDhw44P2NAv02/qZ71llnERUVxaxZs9iyZQvglOb+z3/+w7Fjx8jIyPCehypqvIWVJg8UX8+ePXn11Ve9y23Dhg0cPnyYLVu2cNZZZ3HTTTdxww035PuNTPkWtAShqnOBff76ifOkmSuB4j+pJAgCtSDCrWHDht4ngfl66KGHyMzMJDY2lujoaB566CHAKev87rvvkpKSwoYNG3LtOZZEcco1N2rUiCuvvNL7ZDjPk+7yGjlypHeYVatW0bZtW+Lj43n88cd58MEH8w3/7rvvMnbsWGJjY1m+fHmRWhi+8yhIUcpoByqhDTBw4EA+/vhjrrzySm+3QL9NXkOHDiU1NZWkpCQ+/PBDb9nvNm3a0LdvX+Li4hgwYABJSUneEu1FiTdvufa8AsV344030rJlSxITE73l4bOyspg9e7b3YoTPPvvM7/poyq+glvsWkabAl55DTD7dOwHPBWodiMhm4DdAgddV9Y0C5jESGAnQuHHj1p49seJ4eNbDPDb3MXIezmH9+vXlqty3Ofl4SrQfOXKETp068cYbb5CYmBjusEw5cLKU+x5Cwa2HDqq6Q0TOAmaKyHq3RZKPmzzeAOd5ECUJJioiCoBs/WOHZIwpDSNHjmTt2rUcO3aMYcOGWXIwYRPyBCEilYABQOtAw6jqDvfvbhH5HGgL+E0QpSEq0kkQZfEwk6l4Pvroo3CHYAwQnhvlLgHWq+o2fz1FpKqIVPe8B3oAq4MZkKcFURZPVBtjTLgELUGIyCRgIXCBiGwTkRvcXleR5/CSiJwtItPdj3WB+SKyAlgMTFPV/wYrTrAWhDHG+BO0Q0yqOiRA9+F+uu0ALnff/wLEBSsuf6wFYYwx+VktJqwFYYwx/liCoOy1ICIjI73F0fr06cP+/ftLdfoTJ05k9OjRgFMV1becxh8xZMgQYmNjef7558MyfmHS0tICngAuqF9h2rdv/0fCyue1117jvffeA5zfaseOHd5+TZs2Zc+ePaU6v+KoVq1aSOYTaF0ozfU1WEqzmvDy5cuZPn164QPm4Vti/4+wBEHZa0GceuqpLF++nNWrV1O7dm1efvnloM2rtP7B/e9//2PBggWsXLmSu+66KyTjF7d8dUkTRGHzKe3nL9xyyy3echZ5E8TJrKi/V0HrQkHra1kpZx4oQahqrnI0RVHSBFFaLEFQ9loQvtq1a8f27du9n59++mlvSeZHHnkEIGDZbN+9zdTUVG8dIY8FCxYwdepUxo4dS3x8PJs2beLFF1+kZcuWxMbGctVVV+WL59ixY1x//fXExMSQkJDArFmzAKcsx+7du/3ewfuf//yH5ORkEhISuOSSS9i1a1e+6eYd31+Zb/hjJcnvu+8+5s2bR3x8fL4907z9ilOe27NXXZSy6rt376Z1a+cK7xUrViAi3mJ+zZs358iRIzz66KM888wzfPrpp6SmpjJ06FDi4+O9Zcpfeuklbxz+SpRPnDiRAQMGcOmll3Leeefxl7/8JV+sAJ9++inDhw8HYPjw4YwaNYquXbtyzjnnMGfOHEaMGEGLFi28w3j8+c9/JjExkW7dupGeng4ELkWet9y4r+KuS/7W16KuD4HKnK9Zs8Z7N39sbCwbN27MtzxnzJhBu3btSExMZNCgQWRkZHDgwAEuuOACb/n3IUOG8Oabb+YrN5+WlkaLFi249dZbSUxMZOvWrYwaNYqkpCRatWrl/TcMsGTJEtq3b09cXBxt27blwIEDPPzww0yePJn4+HgmT54c8HscPXqUq666itjYWAYPHuxdV/6wQGVeT8ZXSct9f7HuC+VRdNmOZbnLfX81RjtP6FyqrzFfFV7v21OuOisrSwcOHKhfffWVqqp+/fXXetNNN2lOTo5mZ2drr169dM6cOQHLZjdp0kTT09NVVXXJkiXauXNnVVWdMGGC3nbbbarqlIOeMmWKd9z69evrsWPHVNUpB53XM888o8OHD1dV1XXr1mmjRo306NGjunnzZm3VqpXf77Nv3z7NyclRVdU333xT77777nzD5B0/UJnv0ixJ7itvv6KW51b9/fcqaln1li1b6oEDB/Sll17SpKQk/eCDDzQtLU1TUlJUNXfJbt9S6arOb/riiy+qqurLL7+sN9xwQ77pT5gwQZs1a6b79+/Xo0ePauPGjfXXX3/NFauq6pQpU3TYsGGq6qwHgwcP1pycHP3iiy+0evXqunLlSs3OztbExERvuXRAP/jgA1VVHTdunHc9ClSKPG+5cV8lWZfyrq9FXR8ClTkfPXq09/scP35cjxw5kmt+6enp2rFjR83IyFBV1fHjx+u4ceNUVXXGjBmakpKikyZN0p49e3rHyVtuXkR04cKF3m6edSorK0s7d+6sK1as0OPHj2uzZs108eLFqvp7mXnff6sFfY9nn31Wr7/+elVVXbFihUZGRuZabzys3HcJeA8x5WRShSqFDB18nj2QtLQ0WrduTffu3QFnT2bGjBneOkcZGRls3LiRjh07Flg2uzg8NYz69+9P//798/WfP38+t99+OwAXXnghTZo0YcOGDdSoUSPgNLdt28bgwYPZuXMnJ06coFmzZgXGUFiZ71CVJC9Kee569erlGqcoZdXbt2/P999/z9y5c3nggQf473//i6oW+XcbMGAA4JQu/9e//Ne77Natm7eGU8uWLdmyZQuNGjUqcLp9+vRBRIiJiaFu3breAoStWrUiLS2N+Ph4IiIivMv/mmuuYcCAAYWWIvctN+6rJOuSP0VZHwKVOW/Xrh2PP/4427ZtY8CAAZx33nm5pv3DDz+wdu1aOnToAMCJEydo164d4KwfU6ZM4bbbbvNbONGjSZMmpKSkeD9/8sknvPHGG2RlZbFz507Wrl2LiFC/fn3atGkDEHAZBPoec+fO5Y477gCcf8OxsbFFW3iFsASBzyGmPOcgXrg0PPW+PecgDhw4QO/evXn55Ze54447UFXuv/9+br755nzj+Cub7VuCuyjltwGmTZvG3LlzmTp1Ko899hhr1qyhUqXfVxMtQe2u22+/nbvvvpu+ffsye/ZsHn300WJPw1dJS5L/kfkEKs+dV1HKqnfs2JF58+axZcsW+vXrx5NPPomIFPmZ4555FFS2PVAcTp1MR974PeNERETkGj8iIiLgfESk0FLkgYpGlmRdKmz6gdYHDVDmvEWLFiQnJzNt2jR69uzJW2+9xcUXX5xrvO7duzNpUv7KQDk5Oaxbt45TTz2Vffv2BdwJ8Y1v8+bNPPPMMyxZsoTTTz+d4cOHe8u8+/42gQT6HkCRxi8uOwdB7hZEWVKzZk1efPFFnnnmGTIzM+nZsyfvvPMOGRkZAGzfvp3du3cHLJvdtGlTli5dCsBnn33mdx6+5aFzcnLYunUrXbt25amnnmL//v3eeXl06tSJDz/8EHBKQv/6669+V1ZfviWz33333SJ976KW+S5OSfKCSmEXViY7UHnukujUqRMffPAB5513HhEREdSuXZvp06d791KLE1dx1a1bl3Xr1pGTk8Pnn39e7PFzcnK8DxX66KOPuOiii4pcijyvkqxLhS2PQOtDoDLnv/zyC+eccw533HEHffv2ZeXKlbmml5KSwvfff8/PP/8MwJEjR7wP4nr++edp0aIFkyZN8j5UCQouN3/w4EGqVq1KzZo12bVrF1999RXgtKB27NjBkiVLADh06BBZWVn5vm+g7+G7LFevXp3ve5SUJQgCtyDKgoSEBOLi4vj444/p0aMHV199Ne3atSMmJoaBAwdy6NChgGWzH3nkEcaMGUPHjh39NvHBeabB008/TUJCAhs3buSaa67xnjS86667qFWrVq7hb731VrKzs4mJiWHw4MFMnDgx196mP48++iiDBg2iY8eOnHnmmUX63kUt812ckuSxsbFUqlSJuLi4fCepC+oHgctzl0TTpk0B5x81OM+AqFWrFqeffnq+YYcPH84tt9yS6yT1HzF+/Hh69+7NxRdfTP369Ys9ftWqVVmzZg2tW7fmu+++8/4uRSlFnldJ1iXf9XXTpk35+gdaHwKVOZ88eTLR0dHEx8ezfv36fA9DqlOnDhMnTvRedpuSksL69evZsGEDb731Fs8++ywdO3akU6dO/P3vfwcKLjcfFxdHQkICrVq1YsSIEd6dgsqVKzN58mRuv/124uLi6N69O8eOHahlznUAACAASURBVKNr166sXbvWe5I60PcYNWoUGRkZxMbG8tRTT9G2bdtCl39RBLXcd6glJSVpSa79Xbx9MclvJTPt6mk0y2pm5b6NMeVScct9WwuCst2CMMaYcLEEQdk9B2GMMeFkCQJrQRhjjD+WILAWhDHG+GMJAmtBGGOMP5YgsBaEMcb4YwmCsteCKG/lvvPO44+UIk5LSyM6OvoPxVkcY8eOpVWrVowdOzYo09+/fz+vvPJKUKZtzB9lCYKy14Iob+W+T4Ya/oG8/vrrLFu2jKeffrpIwxe35LQlCFOWBfOZ1O+IyG4RWe3T7VER2S4iy93X5QHGvVREfhKRn0XkvmDF6FHWWhC+TvZy3/7mATBlyhTatm3L+eef7x0+OzubsWPHer/f66+/7neZZGVlMWzYMGJjYxk4cCBHjhwB4G9/+xtt2rQhOjqakSNHessR+PtOgcom++rbty+HDx8mOTmZyZMns2XLFrp160ZsbCzdunXzlunOW9K6OKWl77vvPjZt2kR8fHzQWinGlFQwi/VNBP4JvJen+/Oq+kygkUQkEngZ6A5sA5aIyFRVDdouaKAWxJ133hmwAFlJxcfH88ILRSsCmJ2dzbfffssNN9wAOJUcN27cyOLFi1FV+vbty9y5c0lPT+fss89m2rRpgFM3qCjat29P37596d27NwMHDgScUgybN2/mlFNO8Xtoy9OaWbVqFevXr6dHjx5s2LCBqVOn0rt373zLy988wNnIL168mOnTpzNu3Di++eYb3n77bWrWrMmSJUs4fvw4HTp0oEePHvmqv/7000+8/fbbdOjQgREjRvDKK69wzz33MHr0aG/ph2uvvZYvv/ySPn36+P1Ojz/+OBdffDHvvPMO+/fvp23btlxyySW5CqtNnTqVatWqeb9Tnz59uO666xg2bBjvvPMOd9xxB1988QXg1BL65ptviIyM5IEHHvA77ddee40xY8YwdOhQTpw4QXZ2NuPHj2f16tWlvp4ZUxqC1oJQ1bnAvhKM2hb4WVV/UdUTwMdAv1INLo9IceoUlZUWhKfc9xlnnMG+ffv8lvtOTExk/fr1bNy4kZiYGL755hvuvfde5s2b5y3zXBKeGjIffPBBriquHvPnz+faa68FcpdoLi7fktVpaWne7/fee+8RHx9PcnIye/fu9fsAl0aNGnlr2FxzzTXMnz8fgFmzZpGcnExMTAzfffcda9asCfidZsyYwfjx44mPj6dLly7esskFWbhwIVdffTXgJCDPfCF3SetA027Xrh1PPPEETz75JFu2bMlXcdSYsiYc5b5Hi8h1QCrwZ1X9LU//BsBWn8/bgORAExORkcBIgMaNG5coIBEhKiIqXwuiqHv6pa28lfv2x1/JalXlpZdeomfPngWOm7essYhw7Ngxbr31VlJTU2nUqBGPPvqo9zv7+04FlU0uKt84fFsexSktfc4555R4/sYEW6hPUr8KNAfigZ3As36G8VfUPOBWSVXfUNUkVU2qU6dOiQOLioziRPaJEo8fDOWl3HdRS1b37NmTV1991VsqecOGDRw+fDjfcL/++isLFy4EYNKkSVx00UXeZHDmmWeSkZHhLUkd6DsFKptckPbt2/Pxxx8DTvXSvA8C8v0eRS0tXdrlvI0pTSFNEKq6S1WzVTUHeBPncFJe2wDfR181BIL+1PaoiKgyc4jJV3ko911YiWaPG2+8kZYtW5KYmEh0dDQ333yz36uCWrRowbvvvktsbCz79u1j1KhR1KpVi5tuuomYmBj69+/vfTJXdna23+8UqGxyQV588UUmTJhAbGws77//Pv/4xz/8Dlec0tJnnHEGHTp0IDo62k5SmzInqOW+RaQp8KWqRruf66vqTvf9XUCyql6VZ5xKwAagG7AdWAJcraprCptfSct9A9R5ug6DWg7i9nNut3LfxphyqbjlvoN2DkJEJgFdgDNFZBvwCNBFROJxDhmlATe7w54NvKWql6tqloiMBr4GIoF3ipIc/qiy2oIwxphwCVqCUNUhfjq/HWDYHcDlPp+nA9ODFJpfUZH5T1IbY0xFZndSu3yvYipPT9kzxhgo2XbNEoQrKtI5xFSlShX27t1rScIYU26oKnv37qVKlSrFGi8c90GUSZ4WRMOGDdm2bRvp6enhDskYY0pNlSpVaNiwYbHGsQTh8rQgoqKi8pV2MMaYisgOMbn83UltjDEVmSUIl6cFYYwxxmEJwmUtCGOMyc0ShMtaEMYYk5slCJe1IIwxJjdLEC5rQRhjTG6WIFzWgjDGmNwsQbisBWGMMblZgnBZC8IYY3KzBOGyct/GGJObJQiXlfs2xpjcLEG4rAVhjDG5WYJwWQvCGGNyswThshaEMcbkFrQEISLviMhuEVnt0+1pEVkvIitF5HMRqRVg3DQRWSUiy0UkNVgx+vK0IOxBQcYY4whmC2IicGmebjOBaFWNBTYA9xcwfldVjVfVpCDFl0tURBQA2ZoditkZY0yZF7QEoapzgX15us1Q1Sz34w9A8R5vFERRkU6CsMNMxhjjCOc5iBHAVwH6KTBDRJaKyMiCJiIiI0UkVURS/8hjQj0tCDtRbYwxjrAkCBH5K5AFfBhgkA6qmghcBtwmIp0CTUtV31DVJFVNqlOnToljqlq5KgAHjh0o8TSMMaY8CXmCEJFhQG9gqAY4I6yqO9y/u4HPgbbBjiu+XjwAqTtCck7cGGPKvJAmCBG5FLgX6KuqRwIMU1VEqnveAz2A1f6GLU0J9RKoHFmZH7b9EOxZGWPMSSGYl7lOAhYCF4jINhG5AfgnUB2Y6V7C+po77NkiMt0dtS4wX0RWAIuBaar632DF6XFKpVNIqJfAD9stQRhjDEClYE1YVYf46fx2gGF3AJe7738B4oIVV0GSGyTz1o9vkZWTRaWIoC0aY4w5Kdid1D5SGqZwJPMIq3cH/YiWMcaUeZYgfKQ0TAGw8xDGGIMliFya1mpKndPqsGj7onCHYowxYWcJwoeIkNIwxVoQxhiDJYh8khsks37Pen47+lu4QzHGmLCyBJGH5zzEkh1LwhyJMcaElyWIPNo0aIMgdpjJGFPhWYLIo8YpNWhZp6UlCGNMhVdgghCRa3zed8jTb3Swggq3lIYpLNq+yB4eZIyp0AprQdzt8/6lPP1GlHIsZUZKwxT2Hd3Hz/t+DncoxhgTNoUlCAnw3t/nciO5QTJgN8wZYyq2whKEBnjv73O50bJOS6pVrmY3zBljKrTCKtJdKCIrcVoLzd33uJ/PCWpkYRQZEUnbBm2tBWGMqdAKSxAtQhJFGZTcIJmnFzzN0cyjnBp1arjDMcaYkCvwEJOqbvF9ARlAInCm+7ncSmmYQlZOFst2Lgt3KMYYExaFXeb6pYhEu+/r4zzZbQTwvojcGYL4wsZOVBtjKrrCTlI3U1XPwxGuB2aqah8gmXJ8mStA3Wp1aVqrqZ2oNsZUWIUliEyf992A6QCqegjIKWziIvKOiOwWkdU+3WqLyEwR2ej+PT3AuMPcYTaKyLDCv0rps8quxpiKrLAEsVVEbheRP+Gce/gvgIicCkQVYfoTgUvzdLsP+FZVzwO+dT/nIiK1gUdwWiptgUcCJZJgSm6QzNaDW9lxaEeoZ22MMWFXWIK4AWgFDAcGq+p+t3sKMKGwiavqXGBfns79gHfd9+8C/f2M2hPncNY+Vf0NmEn+RBN0nsqui7bZYSZjTMVT2FVMu1X1FlXtp6ozfLrPUtVnSjjPuqq6053OTuAsP8M0ALb6fN7mdstHREaKSKqIpKanp5cwJP8S6iVQObKyHWYyxlRIBd4HISJTC+qvqn1LN5zfZ+1vdgFieAN4AyApKalkd3dPHQjn9ILo63N1PqXSKcTXi+eH7ZYgjDEVT2E3yrXD2ZOfBCyidOov7RKR+qq60710drefYbYBXXw+NwRml8K8/dsyA6o38tsrpUEKb/34Flk5WVSKKGxxGWNM+VHYOYh6wANANPAPoDuwR1XnqOqcEs5zKuC5KmkY8G8/w3wN9BCR092T0z3cbsFR6VTIOuq3V0rDFI5kHmH17tV++xtjTHlV2DmIbFX9r6oOwzkx/TMwW0RuL8rERWQSsBC4QES2icgNwHigu4hsxEk4491hk0TkLXe++4DHgCXu629ut+AoIEEkN7Qb5owxFVOhx0xE5BSgFzAEaAq8CPyrKBNX1SEBenXzM2wqcKPP53eAd4oynz+sgATRrFYz6pxWh0XbF3FL0i0hCccYY8qCwk5Sv4tzeOkrYJzPXdXlSwEJQkTshjljTIVU2DmIa4HzgTHAAhE56L4OicjB4IcXIgUkCHBumFu/Zz2/Hf0thEEZY0x4FXYOIkJVq7uvGj6v6qpaI1RBBl0hCcJzw9ySHUtCFZExxoRdYS2IiqGQBNGmQRsEscNMxpgKxRIEFJogapxSg5Z1WlqCMMZUKJYgoNAEAc5hpkXbF6Fabh/FbYwxuViCgCIliOQGyew7uo+f9/0coqCMMSa8LEFAkVsQYDfMGWMqDksQUKQE0bJOS6pVrmZPmDPGVBiWIMBJEDlZziuAyIhI2pzdxloQxpgKwxIEOAkCinSYacWuFRzNLHg4Y4wpDyxBQLESRFZOFst2LgtBUMYYE16WIOD3BJF5pMDBkhtYZVdjTMVhCQKK3IKoW60uTWs1tSfMGWMqBEsQUOQEAe4Nc9vsSiZjTPlnCQIgqugJIrlBMlsPbmX7we1BDsoYY8KrwieIgwdh8O0JvL/0miK3IAC7H8IYU+5V+ARRvTqs/6Ua//ft/eScKDxBxNeLJyoiyg4zGWPKvZAnCBG5QESW+7wOisideYbpIiIHfIZ5OHjxwH1j9rJud0v+M/P0QoevUqkKCfUT7ES1MabcC3mCUNWfVDVeVeOB1sAR4HM/g87zDKeqfwtmTIMGnKBZ7V944rULyMwsfPiUBimk7kglq4A7r40x5mQX7kNM3YBNqrolnEFUqnIqD13yGItX1aFDB/jpp4KHT26YzJHMI6zeXT4f0W2MMRD+BHEVMClAv3YiskJEvhKRVoEmICIjRSRVRFLT09NLFkWlU7m+7UQ+Gf8lmzZBQgK8/DIEevSDVXY1xlQEYUsQIlIZ6AtM8dN7GdBEVeOAl4AvAk1HVd9Q1SRVTapTp07JgnHvgxjUZSWrVkGnTjB6NFx2GezYkX/wZrWaUee0OnYlkzGmXAtnC+IyYJmq7srbQ1UPqmqG+346ECUiZwYtkshTAIGso5x9Nnz1FbzyCsydCzExMCVPChMRkhsmWwvCGFOuVQrjvIcQ4PCSiNQDdqmqikhbnES2N2iRiEClKuBWaRWBUaOgWze49lq48koYOhT++U+oVcsZJaVBCl9u+JLfjv7G6acWfvWTr507YdEi2L8fIiMhIiL336K8L86wxRlPpLQXrjHmZBWWBCEipwHdgZt9ut0CoKqvAQOBUSKSBRwFrtJgPwy60mn5bpQ7/3z4/nt44gn4299gzhx49124+OLfz0PcNv02nur+FA1rNPQ72cxMWL4cFi78/bUlrKfkCyYS/CQUikRXluKJiHDOZ3nWYM97f5+LMky4xjmZYq1o3696dfi//6PUSbC3u6GUlJSkqampJRv59UbQpDtc+o7f3kuWOK2Jn36CO++Evz+ew9++v58XFr1AhERwZ/Kd3HfRfRw7UNObCBYsgNRUOHbMmUbDhtCu3e+vevUgO9t55eTkf++vW1HeB2vYk2G8crQ6m3JG5PdX3s/+uhXn81lnwbp1JY1Llqpqkt9+liBc75wPZ7WG3oEuqoIjR+Dee51DTS1bwsSJ8L9jafxt/oOknviQiGNnkDP7QVgyiqiIU2jdOndCaOi/kWFKkWrZS5Y5OcX7h1+SjUWoxjmZYi0r36+sswRRFO/FQY1m0D/gBVNeM2bA9dfnvsKpTsyPSI972V19JvWrNOWJ7o9zXcJVREi4ryQ2xpjACkoQtvXyqHRqkYr1AfToAatWwdNPw8cfO+cUdq1IYNczM/j6mq85q2ZNrv/PUNq82YZvf/k2yIEbY0xwWILwKEaCAKhdG+65BwYPhsaNf29K9mjeg2U3L+P9P73P3iN7ueT9S7j0g0tZ8b8VQQrcGGOCwxKERzETREEiJIJrYq9h/ej1PNP9GRZvX0zC6wkM+2IYvx74tVTmYYwxwWYJwqMUE4RHlUpV+HP7P7Ppjk2MbT+Wyasnc/5L5zN2xlh+O/pbqc7LGGNKm52k9ph+DexYCDduKt2gfPx64FcenvUw7614j5pVanJR44sQBBEhQiK87wX3s/s+b3+/w5bWdIowXnGGLa14TubYPe8jJML78nTP2y9vd2OCraCT1OG8k7psCUILIq/GNRszsf9E7m53N+PmjGPzb5tRFFUlR3O87xX3s/s+b/9QDWvCz1+CKUpyKck4f6T7H55WqOdXzpZnpYhKnHla6VcjsgThEYIE4RFbN5bPrvwsJPP6IwIlkrKSwHyHLWi8cA/r6e772bdbsLp7+1H688vKyQo8vyB+J9/ueftVZHWr1uV/9/yv1KdrCQK48847WT7nCzh0AD7tEu5wjCnzItz/yiJFcf7XgN28/fJ2U3L1D/W0Ak6/kGk1vbBpyRZWISxBeEiE1WkwphwQBOd/yduj3GpZp2VQpmsJAnjhhRdgcX2Ydx/cMR2iTgt3SMYYE3Zls40YDqfUdP4eLv3jeMYYczKyBOHR6GLn7y/TwhuHMcaUEZYgPGqfD7UvhE3/DnckxhhTJliC8HVuf9g6G47ZXc7GGGMJwlfzfqDZsHl6uCMxxpiwC1uCEJE0EVklIstFJF99DHG8KCI/i8hKEUkMelD120LVevBz4c+EMMaY8i7cl7l2VdU9AfpdBpznvpKBV92/wSMR0LwvrPsIso5DpVOCOjtjjCnLyvIhpn7Ae+r4AaglIvWDPtfm/SAzA7Z+F/RZGWNMWRbOBKHADBFZKiIj/fRvAGz1+bzN7RZcjS+GqGp2mMkYU+GFM0F0UNVEnENJt4lIpzz9/d0Yn68WhoiMFJFUEUlNT0//41FVqgLNLoVNU6GCFwAzxlRsYUsQqrrD/bsb+Bxom2eQbUAjn88NgR1+pvOGqiapalKdOnVKJ7hz+zt3VO9cXDrTM8aYk1BYEoSIVBWR6p73QA9gdZ7BpgLXuVczpQAHVHVnSAJsdjlIpN00Z4yp0MLVgqgLzBeRFcBiYJqq/ldEbhGRW9xhpgO/AD8DbwK3hiy6KqdDo87wsyUIY0zFFZbLXFX1FyDOT/fXfN4rcFso48qleX+YdQfs2+CU4TDGmAqmLF/mGl7n9nX+2mEmY0wFZQkikBpN4KwEu9zVGFNhWYIoSPN+sGMhHN4V7kiMMSbkLEEU5Nz+gMIvX4Y7EmOMCTlLEAWpE+scarLDTMaYCsgSREFEnMNMW2bCiYxwR2OMMSFlCaIw5/aH7OOwZUa4IzHGmJCyBFGYhh2dG+fspjljTAVjCaIwEZXgnN7OieqcrHBHY4wxIWMJoiia94Nj+2D7/HBHYowxIWMJoiia9oTIU+wwkzGmQrEEURSVq0GTS5zLXTXfIymMMaZcsgRRVM37wcE02LMq3JEYY0xIWIIoquZ9ALHDTMaYCsMSRFFVrQf1U+yuamNMhWEJojjO7Q+7l8HBreGOxBhjgs4SRHGc28/5a8+IMMZUAJYgiqP2BXD6BXYewhhTIYQ8QYhIIxGZJSLrRGSNiIzxM0wXETkgIsvd18OhjjOgc/vDttlwbH+4IzHGmKAKRwsiC/izqrYAUoDbRKSln+HmqWq8+/pbaEMswLn9nJIbm6eHOxJjjAmqkCcIVd2pqsvc94eAdUCDUMdRYvWT4bS6dpjJGFPuhfUchIg0BRKARX56txORFSLylYi0KmAaI0UkVURS09PTgxSp7wwjoHlfpwWRdTz48zPGmDAJW4IQkWrAZ8CdqnowT+9lQBNVjQNeAgLefKCqb6hqkqom1alTJ3gB+zq3H2RmwNZZoZmfMcaEQaVwzFREonCSw4eq+q+8/X0ThqpOF5FXRORMVd0TyjgDatwNoqo6l7s2uzTc0ZiyJPMoHPkfHP4fHN7p/D1uFzSYIIuqCon5rvf5w0KeIEREgLeBdar6XIBh6gG7VFVFpC1OS2dvCMMsWKUq0PRS5zxEt5edw06m/NIcOLo390bf+9fn/ZH/wfED4Y7WVESn1S0fCQLoAFwLrBKR5W63B4DGAKr6GjAQGCUiWcBR4CrVMlZG9dz+sPEzWPkmxI50nl9tTi6ZR3Nv3DN25t/7P/w/OLLL/8Oioqo5JViq1oc6sVC1h/O+ar3fu1etB6ecbuuHOSlJWdvu/hFJSUmampoampllHoZPe8KO7+GcXnDJa1C9YWjmbQLTHDi6J//evb/3J/Ke+sJpDZ521u8b99PqQbX6uf96EkDlaqH/fsaUMhFZqqpJ/vqF5RxEuRBVFQbPgeX/hHkPwMRW0PlpiLnJ9haDIfOI/0M6nr1+797/LtDs/ONHVft9A18n1nkIlO9evuf9qWdCRGTov58xZZAliD8iItI57ndOH5h5E8y8GdZ/DD3ehFrNwx1d2Zdrb9/d6Ac6zBNwb7/u7xv4s+Jzb/S9e/11bW/fmBKwBFEaap0DA7+BVW/BnHvg3Ri46AlIuL1i7o1mHin40I5n7z/Q3n7l6r9v4OvEQ1M/e/pV69nevjFBZgmitIhA7E3Q7DL45haYfRf89An0fBvOaBHu6P44zYEj6bkP7QQ6uXviUP7xc+3t13f39v1s9KvWcw7fGWPCzhJEaaveEPr/B9Z/BN+Ngffjod0jkDQWIqPCHV1+mYeLdkL3yO6C9/ar1nf29ptd9vuJXN+Tura3b8xJxxJEMIhAi6HQpDt8ezvM/yv8NAV6vgN1E4I//5zs/Mf2817D79nj97u3H5n7Sp6zEvzv6dvevjHlmiWIYDrtLOgzGTZeBd/eCh+2gbb3QspDzs12xeXZ28935U7e6/YL2tv3bPQTc5/I9X1f5Qzb2zfGWIIIifP+BI26wOy7YdETsPFfTmvi7Hbu3n564Sd0M3Y69Z/ykkioWtfduJ/9+4Y/3/H9ura3b4wpFksQoVLldLh0Alx4FcwYCZM6OBvtI7udE8B5Va7hc0I3EZoVcCWPlfowxgSBJYhQa9oThq+GxeOdyzxz3Z3reyXPaeGO1BhTwVmCCIfK1eGix8MdhTHGFMiOTRhjjPHLEoQxxhi/LEEYY4zxyxKEMcYYvyxBGGOM8csShDHGGL8sQRhjjPHLEoQxxhi/ytUzqUUkHdhSzNHOBPYEIZzSUFZjs7iKx+IqvrIaW3mMq4mq1vHXo1wliJIQkdRAD+wOt7Iam8VVPBZX8ZXV2CpaXHaIyRhjjF+WIIwxxvhlCQLeCHcABSirsVlcxWNxFV9Zja1CxVXhz0EYY4zxz1oQxhhj/LIEYYwxxq8KnSBE5FIR+UlEfhaR+8IYRyMRmSUi60RkjYiMcbs/KiLbRWS5+7o8DLGlicgqd/6pbrfaIjJTRDa6f08PcUwX+CyT5SJyUETuDNfyEpF3RGS3iKz26eZ3GYnjRXedWykiiSGO62kRWe/O+3MRqeV2byoiR32W3Wshjivgbyci97vL6ycR6RniuCb7xJQmIsvd7qFcXoG2D8Ffx1S1Qr6ASGATcA5QGVgBtAxTLPWBRPd9dWAD0BJ4FLgnzMspDTgzT7engPvc9/cBT4b5d/wf0CRcywvoBCQCqwtbRsDlwFeAACnAohDH1QOo5L5/0ieupr7DhWF5+f3t3H8HK4BTgGbuv9nIUMWVp/+zwMNhWF6Btg9BX8cqcguiLfCzqv6iqieAj4F+4QhEVXeq6jL3/SFgHdAgHLEUUT/gXff9u0D/MMbSDdikqsW9g77UqOpcYF+ezoGWUT/gPXX8ANQSkfqhiktVZ6hqlvvxB6BhMOZd3LgK0A/4WFWPq+pm4Gecf7shjUtEBLgSmBSMeRekgO1D0NexipwgGgBbfT5vowxslEWkKZAALHI7jXabie+E+lCOS4EZIrJUREa63eqq6k5wVl7grDDE5XEVuf/Rhnt5eQRaRmVpvRuBs6fp0UxEfhSROSLSMQzx+Pvtysry6gjsUtWNPt1CvrzybB+Cvo5V5AQhfrqF9ZpfEakGfAbcqaoHgVeB5kA8sBOniRtqHVQ1EbgMuE1EOoUhBr9EpDLQF5jidioLy6swZWK9E5G/AlnAh26nnUBjVU0A7gY+EpEaIQwp0G9XJpYXMITcOyIhX15+tg8BB/XTrUTLrCIniG1AI5/PDYEdYYoFEYnC+fE/VNV/AajqLlXNVtUc4E2C1LQuiKrucP/uBj53Y9jlabK6f3eHOi7XZcAyVd3lxhj25eUj0DIK+3onIsOA3sBQdQ9au4dw9rrvl+Ic6z8/VDEV8NuVheVVCRgATPZ0C/Xy8rd9IATrWEVOEEuA80SkmbsnehUwNRyBuMc33wbWqepzPt19jxv+CVidd9wgx1VVRKp73uOc4FyNs5yGuYMNA/4dyrh85NqrC/fyyiPQMpoKXOdeaZICHPAcJggFEbkUuBfoq6pHfLrXEZFI9/05wHnALyGMK9BvNxW4SkROEZFmblyLQxWX6xJgvapu83QI5fIKtH0gFOtYKM7Cl9UXztn+DTjZ/69hjOMinCbgSmC5+7oceB9Y5XafCtQPcVzn4FxBsgJY41lGwBnAt8BG92/tMCyz04C9QE2fbmFZXjhJaieQibP3dkOgZYTT/H/ZXedWAUkhjutnnOPTnvXsNXfYK9zfeAWwDOgT4rgC/nbAX93l9RNwWSjjcrtPBG7JM2wol1eg7UPQ1zErtWGMMcavinyIyRhjTAEsQRhjjPHLEoQxxhi/LEEYY4zxyxKEMcYYvyxBmKATERWRZ30+3yMij5bStCeKyMDSmFYh8xnkVtOclad7UxG5Otjz/yNEpL+ItCzF6T1QgnGGi8g/92/AhwAABK9JREFUSysGExqWIEwoHAcGiMiZ4Q7El+dGpyK6AbhVVbvm6d4U8Jsg3Dtwy4L+ONU/8ylhjMVOEObkZAnChEIWzjNz78rbI28LQEQy3L9d3CJon4jIBhEZLyJDRWSxOM+naO4zmUtEZJ47XG93/Ehxnn2wxC0Ad7PPdGeJyEc4NxHljWeIO/3VIvKk2+1hnJuVXhORp/OMMh7oKM4zAe5y95SniMh/gBnu+GN94hjnM69r3O+zXERed2OOdJfJajcOf8usjoh85k5ziYh0cLu/6MaKiPQUkbki0h6nXtXT7nyai8hsEXlCROYAY0Skj4gsEqfw3DciUtedRjURmeDGsVJErhCR8cCp7rQ+DPQ93O7Xu7/JHKCD/1XDlGnBuvvPXvbyvIAMoAbOsyVqAvcAj7r9JgIDfYd1/3YB9uPUwj8F2A6Mc/uNAV7wGf+/ODs75+HcAVsFGAk86A5zCpCK8zyBLsBhoJmfOM8GfgXqAJWA74D+br/Z+Lkj1Z3elz6fh7sxeO5q7YGTHMWN8Uuc5w60AP4DRLnDvQJcB7QGZvpMr5afeX4EXOS+b4xTggGcu8vXAF1x7jpuHmAZzwZe8fl8Or8/n/5G4Fn3/ZOe5ewZzvc3ct8H+h71fZZlZeB74J/hXhftVbxXWWkCm3JOVQ+KyHvAHcDRIo62RN0aMiKyCXePHGfP3/dQzyfqFHnbKCK/ABfibJhjfVonNXESyAlgsTrPFsirDTBbVdPdeX6IszH/oojxesxUVc9zBXq4rx/dz9XcOGJxksESp9QOp+IUW/sPcI6IvARM8/nOvi4BWrrjAdQQkeqqekhEbgLmAnep6qYCYpzs874hMFmcekiVAc+yuQSnRhkAqvqbn+l0C/A9ksm9LCcTwuJ/pnRYgjCh9AJO3ZoJPt2ycA91ukXJKvv0O+7zPsfncw6519289WIUZ4/9dlX92reHiHTBaUH4469Mckn4Tl+A/1PV1/PEcTvwrqreny8IkTigJ3AbzkNqRuQZJAJop6r+Em0MTo2qs4sR40vAc6o61V0+j/rEXlgtHsHP9xCR/kUY15Rxdg7ChIy7V/0JzglfjzScPVBwnoQVVYJJDxKRCPe8xDk4h1e+BkaJUyYZETlfnIq0BVkEdBaRM93j6EOAOYWMcwjnMZCBfA2MEKeWPyLSQETOwimuNtB973m+cBP3RH6Eqn4GPITzCMy8ZgCjPR9EJN792wT4M84DZS4TkeQixlgT5xAe/F4d1N98PA/xyfQs10DfA2dZdhGRM9xhBxUwf1NGWYIwofYs4Hs105s4G+XFOIclAu3dF+QnnA35VzhVN48BbwFrgWXiPIT+dQppMbuHs+4HZuFW6VTVwkqZrwSyRGSFvxPKqjoD55zBQhFZBXwKVFfVtcCDOE/rWwnMxDlu3wCYLSLLcc4d5Gth4BymS3JPHK8FbnFbX2/jPNd5B04SfktEquA8TnesexK6uZ/pPQpMEZF5wB6f7n8HTndPmK/g98N6bwArReTDQN/DXZaPAguBb3BajuYkY9VcjTHG+GUtiP9vrw4EAAAAAAT5Wy8wQkkEwBIEAEsQACxBALAEAcASBABLEACsANOmplThlJ4WAAAAAElFTkSuQmCC\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "for results in results_global:\n",
     "    x_value = [int(NB_TREES/k) for k in [5, 10, 50, 100, 500, 1000]]\n",
@@ -581,21 +390,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "OrthogonalMatchingPursuit(fit_intercept=True, n_nonzero_coefs=3, normalize=True,\n",
-       "                          precompute='auto', tol=None)"
-      ]
-     },
-     "execution_count": 25,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "omp = OrthogonalMatchingPursuit(n_nonzero_coefs=NB_TREES_EXTRACTED)\n",
     "omp.fit(D, y_train)"
@@ -603,221 +400,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "metadata": {
     "scrolled": true
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.53669413,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.20332286, 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.26974158, 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
-       "       0.        , 0.        , 0.        , 0.        , 0.        ])"
-      ]
-     },
-     "execution_count": 26,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Matrice avec poids de chaque arbre\n",
     "\n",
@@ -840,20 +427,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "6.079654025784307"
-      ]
-     },
-     "execution_count": 27,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "mean_squared_error(regressor.predict(X_test), y_test)"
    ]