{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# 2018-10-09 Ensemble, Gradient, Boosting...\n", "\n", "Le noteboook explore quelques particularit\u00e9s des algorithmes d'apprentissage pour expliquer certains r\u00e9sultats num\u00e9riques. L'algoithme [AdaBoost](https://fr.wikipedia.org/wiki/AdaBoost) surpond\u00e8re les exemples sur lequel un mod\u00e8le fait des erreurs."]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [{"data": {"text/html": ["<div id=\"my_id_menu_nb\">run previous cell, wait for 2 seconds</div>\n", "<script>\n", "function repeat_indent_string(n){\n", "    var a = \"\" ;\n", "    for ( ; n > 0 ; --n)\n", "        a += \"    \";\n", "    return a;\n", "}\n", "// look up into all sections and builds an automated menu //\n", "var update_menu_string = function(begin, lfirst, llast, sformat, send, keep_item, begin_format, end_format) {\n", "    var anchors = document.getElementsByClassName(\"section\");\n", "    if (anchors.length == 0) {\n", "        anchors = document.getElementsByClassName(\"text_cell_render rendered_html\");\n", "    }\n", "    var i,t;\n", "    var text_menu = begin;\n", "    var text_memo = \"<pre>\\nlength:\" + anchors.length + \"\\n\";\n", "    var ind = \"\";\n", "    var memo_level = 1;\n", "    var href;\n", "    var tags = [];\n", "    var main_item = 0;\n", "    var format_open = 0;\n", "    for (i = 0; i <= llast; i++)\n", "        tags.push(\"h\" + i);\n", "\n", "    for (i = 0; i < anchors.length; i++) {\n", "        text_memo += \"**\" + anchors[i].id + \"--\\n\";\n", "\n", "        var child = null;\n", "        for(t = 0; t < tags.length; t++) {\n", "            var r = anchors[i].getElementsByTagName(tags[t]);\n", "            if (r.length > 0) {\n", "child = r[0];\n", "break;\n", "            }\n", "        }\n", "        if (child == null) {\n", "            text_memo += \"null\\n\";\n", "            continue;\n", "        }\n", "        if (anchors[i].hasAttribute(\"id\")) {\n", "            // when converted in RST\n", "            href = anchors[i].id;\n", "            text_memo += \"#1-\" + href;\n", "            // passer \u00e0 child suivant (le chercher)\n", "        }\n", "        else if (child.hasAttribute(\"id\")) {\n", "            // in a notebook\n", "            href = child.id;\n", "            text_memo += \"#2-\" + href;\n", "        }\n", "        else {\n", "            text_memo += \"#3-\" + \"*\" + \"\\n\";\n", "            continue;\n", "        }\n", "        var title = child.textContent;\n", "        var level = parseInt(child.tagName.substring(1,2));\n", "\n", "        text_memo += \"--\" + level + \"?\" + lfirst + \"--\" + title + \"\\n\";\n", "\n", "        if ((level < lfirst) || (level > llast)) {\n", "            continue ;\n", "        }\n", "        if (title.endsWith('\u00b6')) {\n", "            title = title.substring(0,title.length-1).replace(\"<\", \"&lt;\")\n", "         .replace(\">\", \"&gt;\").replace(\"&\", \"&amp;\");\n", "        }\n", "        if (title.length == 0) {\n", "            continue;\n", "        }\n", "\n", "        while (level < memo_level) {\n", "            text_menu += end_format + \"</ul>\\n\";\n", "            format_open -= 1;\n", "            memo_level -= 1;\n", "        }\n", "        if (level == lfirst) {\n", "            main_item += 1;\n", "        }\n", "        if (keep_item != -1 && main_item != keep_item + 1) {\n", "            // alert(main_item + \" - \" + level + \" - \" + keep_item);\n", "            continue;\n", "        }\n", "        while (level > memo_level) {\n", "            text_menu += \"<ul>\\n\";\n", "            memo_level += 1;\n", "        }\n", "        text_menu += repeat_indent_string(level-2);\n", "        text_menu += begin_format + sformat.replace(\"__HREF__\", href).replace(\"__TITLE__\", title);\n", "        format_open += 1;\n", "    }\n", "    while (1 < memo_level) {\n", "        text_menu += end_format + \"</ul>\\n\";\n", "        memo_level -= 1;\n", "        format_open -= 1;\n", "    }\n", "    text_menu += send;\n", "    //text_menu += \"\\n\" + text_memo;\n", "\n", "    while (format_open > 0) {\n", "        text_menu += end_format;\n", "        format_open -= 1;\n", "    }\n", "    return text_menu;\n", "};\n", "var update_menu = function() {\n", "    var sbegin = \"\";\n", "    var sformat = '<a href=\"#__HREF__\">__TITLE__</a>';\n", "    var send = \"\";\n", "    var begin_format = '<li>';\n", "    var end_format = '</li>';\n", "    var keep_item = -1;\n", "    var text_menu = update_menu_string(sbegin, 2, 4, sformat, send, keep_item,\n", "       begin_format, end_format);\n", "    var menu = document.getElementById(\"my_id_menu_nb\");\n", "    menu.innerHTML=text_menu;\n", "};\n", "window.setTimeout(update_menu,2000);\n", "            </script>"], "text/plain": ["<IPython.core.display.HTML object>"]}, "execution_count": 2, "metadata": {}, "output_type": "execute_result"}], "source": ["from jyquickhelper import add_notebook_menu\n", "add_notebook_menu()"]}, {"cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": ["%matplotlib inline"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Skewed split train test\n", "\n", "Lorsqu'une classe est sous repr\u00e9sent\u00e9e, il est difficile de pr\u00e9dire les r\u00e9sultats d'un mod\u00e8le de machine learning."]}, {"cell_type": "code", "execution_count": 3, "metadata": {"scrolled": false}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["n= 1\n", "n= 2\n", "n= 5\n", "n= 10\n", "n= 20\n", "n= 50\n", "n= 80\n", "n= 90\n", "n= 100\n", "n= 110\n"]}], "source": ["import numpy, numpy.random\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.linear_model import LogisticRegression\n", "from sklearn.tree import DecisionTreeClassifier\n", "from sklearn.neural_network import MLPClassifier\n", "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier\n", "from sklearn.metrics import confusion_matrix\n", "\n", "N = 1000\n", "\n", "res = []\n", "\n", "for n in [1, 2, 5, 10, 20, 50, 80, 90, 100, 110]:\n", "    print(\"n=\", n)\n", "    for k in range(10):\n", "\n", "        X = numpy.zeros((N, 2))\n", "        X[:, 0] = numpy.random.randint(0, 2, (N,))\n", "        X[:, 1] = numpy.random.randint(0, n+1, (N,))\n", "        Y = X[:, 0] + X[:, 1] + numpy.random.normal(size=(N,)) / 2\n", "        Y[Y < 1.5] = 0\n", "        Y[Y >= 1.5] = 1\n", "\n", "        X_train, X_test, y_train, y_test = train_test_split(X, Y)\n", "\n", "        stat = dict(N=N, n=n, ratio_train=y_train.sum()/y_train.shape[0],\n", "                    k=k, ratio_test=y_test.sum()/y_test.shape[0])\n", "        \n", "        for model in [LogisticRegression(solver=\"liblinear\"),\n", "                      MLPClassifier(max_iter=500),\n", "                      RandomForestClassifier(n_estimators=10),\n", "                      AdaBoostClassifier(DecisionTreeClassifier(), n_estimators=10)]:\n", "            obs = stat.copy()\n", "            obs[\"model\"] = model.__class__.__name__\n", "            if obs[\"model\"] == \"AdaBoostClassifier\":\n", "                obs[\"model\"] = \"AdaB-\" + model.base_estimator.__class__.__name__\n", "            try:\n", "                model.fit(X_train, y_train)\n", "            except ValueError as e:\n", "                obs[\"erreur\"] = str(e)\n", "                res.append(obs)\n", "                continue\n", "            sc = model.score(X_test, y_test)\n", "            obs[\"accuracy\"] = sc\n", "            conf = confusion_matrix(y_test, model.predict(X_test))\n", "            try:\n", "                obs[\"Error-0|1\"] = conf[0, 1] / conf[0, :].sum()\n", "                obs[\"Error-1|0\"] = conf[1, 0] / conf[1, :].sum()\n", "            except Exception:\n", "                pass\n", "            res.append(obs)"]}, {"cell_type": "code", "execution_count": 4, "metadata": {}, "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>N</th>\n", "      <th>n</th>\n", "      <th>ratio_train</th>\n", "      <th>k</th>\n", "      <th>ratio_test</th>\n", "      <th>model</th>\n", "      <th>accuracy</th>\n", "      <th>Error-0|1</th>\n", "      <th>Error-1|0</th>\n", "      <th>diff_ratio</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>1000</td>\n", "      <td>1</td>\n", "      <td>0.273333</td>\n", "      <td>0</td>\n", "      <td>0.300</td>\n", "      <td>AdaB-DecisionTreeClassifier</td>\n", "      <td>0.860</td>\n", "      <td>0.062857</td>\n", "      <td>0.320000</td>\n", "      <td>0.026667</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>1000</td>\n", "      <td>1</td>\n", "      <td>0.274667</td>\n", "      <td>1</td>\n", "      <td>0.328</td>\n", "      <td>AdaB-DecisionTreeClassifier</td>\n", "      <td>0.916</td>\n", "      <td>0.029762</td>\n", "      <td>0.195122</td>\n", "      <td>0.053333</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>1000</td>\n", "      <td>1</td>\n", "      <td>0.304000</td>\n", "      <td>2</td>\n", "      <td>0.284</td>\n", "      <td>AdaB-DecisionTreeClassifier</td>\n", "      <td>0.860</td>\n", "      <td>0.072626</td>\n", "      <td>0.309859</td>\n", "      <td>0.020000</td>\n", "    </tr>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>1000</td>\n", "      <td>1</td>\n", "      <td>0.285333</td>\n", "      <td>3</td>\n", "      <td>0.268</td>\n", "      <td>AdaB-DecisionTreeClassifier</td>\n", "      <td>0.896</td>\n", "      <td>0.027322</td>\n", "      <td>0.313433</td>\n", "      <td>0.017333</td>\n", "    </tr>\n", "    <tr>\n", "      <th>4</th>\n", "      <td>1000</td>\n", "      <td>1</td>\n", "      <td>0.297333</td>\n", "      <td>4</td>\n", "      <td>0.256</td>\n", "      <td>AdaB-DecisionTreeClassifier</td>\n", "      <td>0.888</td>\n", "      <td>0.053763</td>\n", "      <td>0.281250</td>\n", "      <td>0.041333</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["      N  n  ratio_train  k  ratio_test                        model  accuracy  \\\n", "0  1000  1     0.273333  0       0.300  AdaB-DecisionTreeClassifier     0.860   \n", "1  1000  1     0.274667  1       0.328  AdaB-DecisionTreeClassifier     0.916   \n", "2  1000  1     0.304000  2       0.284  AdaB-DecisionTreeClassifier     0.860   \n", "3  1000  1     0.285333  3       0.268  AdaB-DecisionTreeClassifier     0.896   \n", "4  1000  1     0.297333  4       0.256  AdaB-DecisionTreeClassifier     0.888   \n", "\n", "   Error-0|1  Error-1|0  diff_ratio  \n", "0   0.062857   0.320000    0.026667  \n", "1   0.029762   0.195122    0.053333  \n", "2   0.072626   0.309859    0.020000  \n", "3   0.027322   0.313433    0.017333  \n", "4   0.053763   0.281250    0.041333  "]}, "execution_count": 5, "metadata": {}, "output_type": "execute_result"}], "source": ["from pandas import DataFrame\n", "df = DataFrame(res)\n", "df = df.sort_values(['n', 'model', 'model', \"k\"]).reset_index(drop=True)\n", "df[\"diff_ratio\"] = (df[\"ratio_test\"] - df[\"ratio_train\"]).abs()\n", "df.head(n=5)"]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "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>N</th>\n", "      <th>n</th>\n", "      <th>ratio_train</th>\n", "      <th>k</th>\n", "      <th>ratio_test</th>\n", "      <th>model</th>\n", "      <th>accuracy</th>\n", "      <th>Error-0|1</th>\n", "      <th>Error-1|0</th>\n", "      <th>diff_ratio</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>395</th>\n", "      <td>1000</td>\n", "      <td>110</td>\n", "      <td>0.982667</td>\n", "      <td>5</td>\n", "      <td>0.996</td>\n", "      <td>RandomForestClassifier</td>\n", "      <td>0.996</td>\n", "      <td>0.0</td>\n", "      <td>0.004016</td>\n", "      <td>0.013333</td>\n", "    </tr>\n", "    <tr>\n", "      <th>396</th>\n", "      <td>1000</td>\n", "      <td>110</td>\n", "      <td>0.990667</td>\n", "      <td>6</td>\n", "      <td>0.980</td>\n", "      <td>RandomForestClassifier</td>\n", "      <td>0.996</td>\n", "      <td>0.2</td>\n", "      <td>0.000000</td>\n", "      <td>0.010667</td>\n", "    </tr>\n", "    <tr>\n", "      <th>397</th>\n", "      <td>1000</td>\n", "      <td>110</td>\n", "      <td>0.985333</td>\n", "      <td>7</td>\n", "      <td>0.988</td>\n", "      <td>RandomForestClassifier</td>\n", "      <td>1.000</td>\n", "      <td>0.0</td>\n", "      <td>0.000000</td>\n", "      <td>0.002667</td>\n", "    </tr>\n", "    <tr>\n", "      <th>398</th>\n", "      <td>1000</td>\n", "      <td>110</td>\n", "      <td>0.985333</td>\n", "      <td>8</td>\n", "      <td>0.992</td>\n", "      <td>RandomForestClassifier</td>\n", "      <td>1.000</td>\n", "      <td>0.0</td>\n", "      <td>0.000000</td>\n", "      <td>0.006667</td>\n", "    </tr>\n", "    <tr>\n", "      <th>399</th>\n", "      <td>1000</td>\n", "      <td>110</td>\n", "      <td>0.985333</td>\n", "      <td>9</td>\n", "      <td>0.992</td>\n", "      <td>RandomForestClassifier</td>\n", "      <td>0.996</td>\n", "      <td>0.5</td>\n", "      <td>0.000000</td>\n", "      <td>0.006667</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["        N    n  ratio_train  k  ratio_test                   model  accuracy  \\\n", "395  1000  110     0.982667  5       0.996  RandomForestClassifier     0.996   \n", "396  1000  110     0.990667  6       0.980  RandomForestClassifier     0.996   \n", "397  1000  110     0.985333  7       0.988  RandomForestClassifier     1.000   \n", "398  1000  110     0.985333  8       0.992  RandomForestClassifier     1.000   \n", "399  1000  110     0.985333  9       0.992  RandomForestClassifier     0.996   \n", "\n", "     Error-0|1  Error-1|0  diff_ratio  \n", "395        0.0   0.004016    0.013333  \n", "396        0.2   0.000000    0.010667  \n", "397        0.0   0.000000    0.002667  \n", "398        0.0   0.000000    0.006667  \n", "399        0.5   0.000000    0.006667  "]}, "execution_count": 6, "metadata": {}, "output_type": "execute_result"}], "source": ["df.tail(n=5)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["La r\u00e9partition train/test est loin d'\u00eatre statisfaisante lorsqu'il existe une classe sous repr\u00e9sent\u00e9e."]}, {"cell_type": "code", "execution_count": 6, "metadata": {}, "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>n</th>\n", "      <th>ratio_test</th>\n", "      <th>ratio_train</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>320</th>\n", "      <td>100</td>\n", "      <td>0.980</td>\n", "      <td>0.992000</td>\n", "    </tr>\n", "    <tr>\n", "      <th>321</th>\n", "      <td>100</td>\n", "      <td>0.984</td>\n", "      <td>0.980000</td>\n", "    </tr>\n", "    <tr>\n", "      <th>322</th>\n", "      <td>100</td>\n", "      <td>0.988</td>\n", "      <td>0.984000</td>\n", "    </tr>\n", "    <tr>\n", "      <th>323</th>\n", "      <td>100</td>\n", "      <td>0.988</td>\n", "      <td>0.986667</td>\n", "    </tr>\n", "    <tr>\n", "      <th>324</th>\n", "      <td>100</td>\n", "      <td>0.976</td>\n", "      <td>0.986667</td>\n", "    </tr>\n", "    <tr>\n", "      <th>325</th>\n", "      <td>100</td>\n", "      <td>0.984</td>\n", "      <td>0.985333</td>\n", "    </tr>\n", "    <tr>\n", "      <th>326</th>\n", "      <td>100</td>\n", "      <td>0.984</td>\n", "      <td>0.981333</td>\n", "    </tr>\n", "    <tr>\n", "      <th>327</th>\n", "      <td>100</td>\n", "      <td>0.988</td>\n", "      <td>0.982667</td>\n", "    </tr>\n", "    <tr>\n", "      <th>328</th>\n", "      <td>100</td>\n", "      <td>0.984</td>\n", "      <td>0.989333</td>\n", "    </tr>\n", "    <tr>\n", "      <th>329</th>\n", "      <td>100</td>\n", "      <td>0.992</td>\n", "      <td>0.989333</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["       n  ratio_test  ratio_train\n", "320  100       0.980     0.992000\n", "321  100       0.984     0.980000\n", "322  100       0.988     0.984000\n", "323  100       0.988     0.986667\n", "324  100       0.976     0.986667\n", "325  100       0.984     0.985333\n", "326  100       0.984     0.981333\n", "327  100       0.988     0.982667\n", "328  100       0.984     0.989333\n", "329  100       0.992     0.989333"]}, "execution_count": 7, "metadata": {}, "output_type": "execute_result"}], "source": ["df[df.n==100][[\"n\", \"ratio_test\", \"ratio_train\"]].head(n=10)"]}, {"cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": ["#df.to_excel(\"data.xlsx\")"]}, {"cell_type": "code", "execution_count": 8, "metadata": {}, "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>n</th>\n", "      <th>N</th>\n", "      <th>model</th>\n", "      <th>ratio_train</th>\n", "      <th>k</th>\n", "      <th>ratio_test</th>\n", "      <th>accuracy</th>\n", "      <th>Error-0|1</th>\n", "      <th>Error-1|0</th>\n", "      <th>diff_ratio</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>35</th>\n", "      <td>100</td>\n", "      <td>1000</td>\n", "      <td>RandomForestClassifier</td>\n", "      <td>0.985733</td>\n", "      <td>4.5</td>\n", "      <td>0.9848</td>\n", "      <td>0.9956</td>\n", "      <td>0.185000</td>\n", "      <td>0.001216</td>\n", "      <td>0.004933</td>\n", "    </tr>\n", "    <tr>\n", "      <th>36</th>\n", "      <td>110</td>\n", "      <td>1000</td>\n", "      <td>AdaB-DecisionTreeClassifier</td>\n", "      <td>0.986533</td>\n", "      <td>4.5</td>\n", "      <td>0.9900</td>\n", "      <td>0.9972</td>\n", "      <td>0.130000</td>\n", "      <td>0.000810</td>\n", "      <td>0.007200</td>\n", "    </tr>\n", "    <tr>\n", "      <th>37</th>\n", "      <td>110</td>\n", "      <td>1000</td>\n", "      <td>LogisticRegression</td>\n", "      <td>0.986533</td>\n", "      <td>4.5</td>\n", "      <td>0.9900</td>\n", "      <td>0.9960</td>\n", "      <td>0.346667</td>\n", "      <td>0.000402</td>\n", "      <td>0.007200</td>\n", "    </tr>\n", "    <tr>\n", "      <th>38</th>\n", "      <td>110</td>\n", "      <td>1000</td>\n", "      <td>MLPClassifier</td>\n", "      <td>0.986533</td>\n", "      <td>4.5</td>\n", "      <td>0.9900</td>\n", "      <td>0.9956</td>\n", "      <td>0.346667</td>\n", "      <td>0.000810</td>\n", "      <td>0.007200</td>\n", "    </tr>\n", "    <tr>\n", "      <th>39</th>\n", "      <td>110</td>\n", "      <td>1000</td>\n", "      <td>RandomForestClassifier</td>\n", "      <td>0.986533</td>\n", "      <td>4.5</td>\n", "      <td>0.9900</td>\n", "      <td>0.9980</td>\n", "      <td>0.090000</td>\n", "      <td>0.000810</td>\n", "      <td>0.007200</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["      n     N                        model  ratio_train    k  ratio_test  \\\n", "35  100  1000       RandomForestClassifier     0.985733  4.5      0.9848   \n", "36  110  1000  AdaB-DecisionTreeClassifier     0.986533  4.5      0.9900   \n", "37  110  1000           LogisticRegression     0.986533  4.5      0.9900   \n", "38  110  1000                MLPClassifier     0.986533  4.5      0.9900   \n", "39  110  1000       RandomForestClassifier     0.986533  4.5      0.9900   \n", "\n", "    accuracy  Error-0|1  Error-1|0  diff_ratio  \n", "35    0.9956   0.185000   0.001216    0.004933  \n", "36    0.9972   0.130000   0.000810    0.007200  \n", "37    0.9960   0.346667   0.000402    0.007200  \n", "38    0.9956   0.346667   0.000810    0.007200  \n", "39    0.9980   0.090000   0.000810    0.007200  "]}, "execution_count": 9, "metadata": {}, "output_type": "execute_result"}], "source": ["columns = [\"n\", \"N\", \"model\"]\n", "agg = df.groupby(columns, as_index=False).mean().sort_values([\"n\", \"model\"]).reset_index(drop=True)\n", "agg.tail()"]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [{"data": {"image/png": "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", "text/plain": ["<Figure size 720x288 with 2 Axes>"]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["import matplotlib.pyplot as plt\n", "fig, ax = plt.subplots(1, 2, figsize=(10,4))\n", "agg.plot(x=\"n\", y=\"diff_ratio\", ax=ax[0])\n", "agg.plot(x=\"n\", y=\"ratio_train\", ax=ax[1])\n", "agg.plot(x=\"n\", y=\"ratio_test\", ax=ax[1])\n", "ax[0].set_title(\"Maximum difference between\\nratio of first class on train and test\")\n", "ax[1].set_title(\"Ratio of first class on train and test\")\n", "ax[0].legend();"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Une astuce pour \u00e9viter les doublons avant d'effecturer un pivot."]}, {"cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": ["agg2 = agg.copy()\n", "agg2[\"ratio_test2\"] = agg2[\"ratio_test\"] + agg2[\"n\"] / 100000"]}, {"cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [{"data": {"image/png": "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", "text/plain": ["<Figure size 1008x288 with 3 Axes>"]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["import matplotlib.pyplot as plt\n", "fig, ax = plt.subplots(1, 3, figsize=(14,4))\n", "agg2.pivot(\"ratio_test2\", \"model\", \"accuracy\").plot(ax=ax[0])\n", "agg2.pivot(\"ratio_test2\", \"model\", \"Error-0|1\").plot(ax=ax[1])\n", "agg2.pivot(\"ratio_test2\", \"model\", \"Error-1|0\").plot(ax=ax[2])\n", "ax[0].plot([0.5, 1.0], [0.5, 1.0], '--', label=\"constant\")\n", "ax[0].set_title(\"Accuracy\")\n", "ax[1].set_title(\"Error-0|1\")\n", "ax[2].set_title(\"Error-1|0\")\n", "ax[0].legend();"]}, {"cell_type": "code", "execution_count": 12, "metadata": {}, "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>model</th>\n", "      <th>AdaB-DecisionTreeClassifier</th>\n", "      <th>LogisticRegression</th>\n", "      <th>MLPClassifier</th>\n", "      <th>RandomForestClassifier</th>\n", "    </tr>\n", "    <tr>\n", "      <th>ratio_test2</th>\n", "      <th></th>\n", "      <th></th>\n", "      <th></th>\n", "      <th></th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0.29721</th>\n", "      <td>0.052249</td>\n", "      <td>0.052249</td>\n", "      <td>0.052249</td>\n", "      <td>0.052249</td>\n", "    </tr>\n", "    <tr>\n", "      <th>0.50682</th>\n", "      <td>0.110686</td>\n", "      <td>0.110686</td>\n", "      <td>0.110686</td>\n", "      <td>0.110686</td>\n", "    </tr>\n", "    <tr>\n", "      <th>0.75525</th>\n", "      <td>0.119578</td>\n", "      <td>0.119578</td>\n", "      <td>0.119578</td>\n", "      <td>0.119578</td>\n", "    </tr>\n", "    <tr>\n", "      <th>0.86690</th>\n", "      <td>0.099333</td>\n", "      <td>0.099333</td>\n", "      <td>0.099333</td>\n", "      <td>0.099333</td>\n", "    </tr>\n", "    <tr>\n", "      <th>0.92900</th>\n", "      <td>0.088095</td>\n", "      <td>0.113095</td>\n", "      <td>0.113095</td>\n", "      <td>0.088095</td>\n", "    </tr>\n", "    <tr>\n", "      <th>0.96970</th>\n", "      <td>0.106349</td>\n", "      <td>0.253968</td>\n", "      <td>0.220635</td>\n", "      <td>0.163492</td>\n", "    </tr>\n", "    <tr>\n", "      <th>0.98120</th>\n", "      <td>0.125000</td>\n", "      <td>0.310000</td>\n", "      <td>0.200000</td>\n", "      <td>0.175000</td>\n", "    </tr>\n", "    <tr>\n", "      <th>0.98490</th>\n", "      <td>0.110000</td>\n", "      <td>0.155000</td>\n", "      <td>0.155000</td>\n", "      <td>0.170000</td>\n", "    </tr>\n", "    <tr>\n", "      <th>0.98580</th>\n", "      <td>0.185000</td>\n", "      <td>0.335000</td>\n", "      <td>0.268333</td>\n", "      <td>0.185000</td>\n", "    </tr>\n", "    <tr>\n", "      <th>0.99110</th>\n", "      <td>0.130000</td>\n", "      <td>0.346667</td>\n", "      <td>0.346667</td>\n", "      <td>0.090000</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["model        AdaB-DecisionTreeClassifier  LogisticRegression  MLPClassifier  \\\n", "ratio_test2                                                                   \n", "0.29721                         0.052249            0.052249       0.052249   \n", "0.50682                         0.110686            0.110686       0.110686   \n", "0.75525                         0.119578            0.119578       0.119578   \n", "0.86690                         0.099333            0.099333       0.099333   \n", "0.92900                         0.088095            0.113095       0.113095   \n", "0.96970                         0.106349            0.253968       0.220635   \n", "0.98120                         0.125000            0.310000       0.200000   \n", "0.98490                         0.110000            0.155000       0.155000   \n", "0.98580                         0.185000            0.335000       0.268333   \n", "0.99110                         0.130000            0.346667       0.346667   \n", "\n", "model        RandomForestClassifier  \n", "ratio_test2                          \n", "0.29721                    0.052249  \n", "0.50682                    0.110686  \n", "0.75525                    0.119578  \n", "0.86690                    0.099333  \n", "0.92900                    0.088095  \n", "0.96970                    0.163492  \n", "0.98120                    0.175000  \n", "0.98490                    0.170000  \n", "0.98580                    0.185000  \n", "0.99110                    0.090000  "]}, "execution_count": 13, "metadata": {}, "output_type": "execute_result"}], "source": ["agg2.pivot(\"ratio_test2\", \"model\", \"Error-0|1\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Le mod\u00e8le [AdaBoost](http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) construit 10 arbres tout comme la for\u00eat al\u00e9atoire \u00e0 ceci pr\u00e8s que le poids associ\u00e9 \u00e0 chacun des arbres des diff\u00e9rents et non uniforme."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Apprentissage continu\n", "\n", "Apprendre une for\u00eat al\u00e9atoire, puis ajouter un arbre, encore un tout en gardant le r\u00e9sultat des apprentissages pr\u00e9c\u00e9dents."]}, {"cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": ["from sklearn.datasets import load_diabetes\n", "data = load_diabetes()\n", "X, y = data.data, data.target"]}, {"cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": ["X_train, X_test, y_train, y_test = train_test_split(X, y)"]}, {"cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": ["from sklearn.ensemble import RandomForestRegressor\n", "\n", "model = None\n", "res = []\n", "for i in range(0, 20):\n", "    if model is None:\n", "        model = RandomForestRegressor(n_estimators=1, warm_start=True)\n", "    else:\n", "        model.set_params(**dict(n_estimators=model.n_estimators+1))\n", "    model.fit(X_train, y_train)\n", "    score = model.score(X_test, y_test)\n", "    res.append(dict(n_estimators=model.n_estimators, score=score))"]}, {"cell_type": "code", "execution_count": 16, "metadata": {}, "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>n_estimators</th>\n", "      <th>score</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>1</td>\n", "      <td>0.128906</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>2</td>\n", "      <td>0.323854</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>3</td>\n", "      <td>0.352876</td>\n", "    </tr>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>4</td>\n", "      <td>0.389476</td>\n", "    </tr>\n", "    <tr>\n", "      <th>4</th>\n", "      <td>5</td>\n", "      <td>0.429992</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["   n_estimators     score\n", "0             1  0.128906\n", "1             2  0.323854\n", "2             3  0.352876\n", "3             4  0.389476\n", "4             5  0.429992"]}, "execution_count": 17, "metadata": {}, "output_type": "execute_result"}], "source": ["df = DataFrame(res)\n", "df.head()"]}, {"cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [{"data": {"image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAEmCAYAAABs7FscAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAA2S0lEQVR4nO3deXwddb3/8dc7e9qmS9rQfYUW2lJKIS2igIClFETg6hVBuIKiCAqCgMpVQeTK77qCCwhyr70VtwLiUqHsm4JWGujeAt1oku5Nuidpts/vj5mk00OWk2Y5yTmf5+NxHmf2+cycOZ8z5zvf+Y7MDOecc8krLdEBOOec61ye6J1zLsl5onfOuSTnid4555KcJ3rnnEtynuidcy7JeaJ3SU/SSklnJjqO7kLS6ZLeTnQcruvI69G7eEl6GZgKDDGzgwkOp0mS5gKlZvbNRMfSXUgyYLyZrU10LC4x/IzexUXSGOB0wIALO3E9GZ21bOdSlSd6F69PAQuBucCV0RGS5kp6UNJzkvZJekXS6Mh4k/QlSesl7ZT0A0lp4birJL0m6V5JZcCdkrIl/VBSsaRt4bJzw+nPlFQq6RZJ2yVtkfTpcNw1wOXAVyXtl/TXcPi7kmaG3TMkFUnaGy77nnB4jqTfSCqTtFvSIkmDw3GflrQ63Lb1kj4fs/1fDePYLOmz4fYeE45rdluaIulzkXWtknRSOHyipJfD2FZKujAyz1xJ90t6MpzvX5KODsf9LZxsabhPPtGwDyPzvyvpVknLJO2R9IiknMjn82pMjI3b53oIM/OXv1p9AWuBLwAnAzXA4Mi4ucA+4AwgG/gJ8GpkvAEvAfnAKOAd4LPhuKuAWuAGIAPIBe4F5ofT5wF/Bf47nP7McPq7gEzgfKACGBCJ5Tsxsb8LzAy7/wn8R9jdB3hf2P35cD29gPRwO/uG4z4MHA0I+GC4vpPCcbOBrcDkcN7fhNt7TDi+2W1pYh9/HNgETA/XdQwwOtzOtcDXgSzg7HB/HxvZ5jJgRrgPfwvMi9n/x0T6zyQo3orun9eBYWGcq4FrI5/PqzFxHrY8f3X/l5/Ru1ZJOo0g4TxqZm8A64BPxkz2pJn9zYKy+28Ap0oaGRn/PTMrN7Ni4MfAZZFxm83sZ2ZWC1QB1wBfDqffB/w/4NLI9DXAXWZWY2YLgP3AsXFuTg1wjKRBZrbfzBZGhg8kSGB1ZvaGme0FMLMnzWydBV4BniUoxgK4BPg/M1tpZhXAnZH9pji2JeqzwPfNbFG4rrVmthF4H8GP0nfNrNrMXgSeiNmHfzKz18N9+FvgxDj3R4OfmtlmMysn+DFq6/yuG/NE7+JxJfCsme0M+39HTPENUNLQYWb7gXKCM8T3jAc2tjCugODM+I2wmGI38HQ4vEFZmNAaVBAkwnhcDUwA3gqLZy4Ih/8aeAaYFxbBfF9SJoCk8yQtlFQexnM+MCicb1hM/G3dlqiRBD+isYYBJWZWHxm2ERge6d8a6W7L/uio+V035he+XIvC8uRLgHRJDckgG+gvaaqZLQ2HjYzM04egCGBzZFEjgZVh96iYcdGqXzuBSmCymW06gpBbrEZmZmuAy8JrBB8F/iBpoJkdAL4NfDu88LwAeFvSb4DHCa5R/MXMaiT9maBoBWALMCKyiui/mLZuSwlBEVGszcBISWmRZN9QBNbZDhD8WAEgaUgXrNN1MD+jd625GKgDJhH8nT8RmAj8nSD5NThf0mmSsoD/AhaaWfTs9iuSBoTFOTcCjzS1sjCR/Q9wr6SjACQNl3RunPFuA8Y1N1LSFZIKwvXsDgfXSzpL0hRJ6cBegqKceoIy8WxgB1Ar6TxgVmSRjwKfDi+W9gJub8e2/C9wq6STFThGwUXtfxGcZX9VUqaCewI+AszriH3SiqXAZEknhhdo7zzC5bgE8kTvWnMlQRl0sZltbXgB9wGX61B1yN8B3yIosjkZuCJmOX8B3gCWAE8Cv2xhnV8juPi4UNJe4HniL4P/JTApLCr5cxPjZwMrJe0nuGh8qZlVAkOAPxAk+dXAK8Cvw3L1LxEk9F0E1ybmNyzMzJ4CfkpwsXktQc0kgIb7DOLeFjN7DLibYF/uA/4M5JtZNUFiP4/gX8LPgU+Z2Vtx7pM7gV+F++SSOOdpiOkdggvfzwNrgFdbnsN1R37DlGs3tXKTklLohh1JE4EVQHbMdQTnEsbP6J1rJ0n/FtaXHwB8D/irJ3nXnXiid679Pg9sJ6gxUwdcl9hwnDucF90451yS8zN655xLcp7oU4CkO8P64Ecyb2M7MYkWloWXhG22TEt0PF1B0s2S/tDOZbynvZruSNJTkmJvxGtu2vsl3d0JMeyXdKRVUbstT/SuJ/khcL2Z9TGzxYkOpiuYWUOja/+e6Fg6m5mdZ2a/gpZ/nBQ0XldtZt9oz/rCRuI+GxNDHzNb357ldkd+Z2w3F7aXopjb31OKpIywFstoDt1d29ZlpJtZXcdG1mU+w+Ht2qQ0M3uotWkix4wDb70y9kXQkt9XgGUEt3//EhgMPEVwE8vzhC0lhtO/D/gHwV2WS4EzI+OuAtaH820ALg+H3wn8JjLdGIJb9zPC/pcJbpx5jeAW+mOA44DnCG5Iehu4pIVtGEtww8++cJ77YtbXbMzN7I+Glh9nELT+uJvg1v/7gKxm5mvYpmsIbuHfAtwaGZ8G3EZQU6WM4Iak/Jh5rwaKw3XuD4cdANaF000M99Vugh+ACyPLnws8QNCUwQFg5hF8to8RtAGzB/gbQVMG0eXfT3Dz1z6Cu1ePjoyfHPm8tgFfb227m9iHAwgaL9tBcLPWE8CIFj6rkcAfw+nLgPsix+GrBP+IdhEci+dF5vs0wU1i+wiO18/HLPcr4ee3meBHJ9o658uELZFG1xXpb8tx+zJBw24TCRq3qws/993h+OxwG4rDffogkBuOOxMoJbhBbStB20XN7j+C71dduJ79kX0V3bZ+wMPh/BuBbwJp8ezT7vZKeADd7UWQDBYSJIDhBNXm3gSmATnAi8C3wmmHh1+o88Mv8DlhfwHQm+Auy4amZIcSJgriS/TFBMkiIzzgSsIvZEYYy05gUjPb8E/gnvCLcQbBF/g3rcXcwv5oSPQnE/xIZIQxrwZuama+hm36fbgvpoRfmIZl3Rju5xFhnL8Afh8z78PhvA1f5uiXMJ6me/cAHwi3M6ctn224jM8QNC2cTdDi5pLIuLk00zRwOM8W4JZwuXnAKa1tdxP7cCDwMYK2ZvIIfnj+3My06QQ/2veG+ywHOC0cdxVBkw6fC6e7jiBpN9S6a60Z5m3A8eFyf0eciT6cvi3HbeOyaLp55GabfOZQ89XfC/drbmv7Lzb2Jo6xhwnu6M4jOCbfAa6OZ592t1fCA+huL4JkcHmk/3HggUj/DQ0HC8HZw69j5n+GoNmA3gRnmh8jTFSRae6k9UR/V2T8J4C/xyzjF0SSUmT4qPCA7x0Z9jsOJfpmY25hf8xsZtxNBM3jNjWuYZuOiwz7PvDLsHs18KHIuKHhFycjMu+4mGVGv4SnE5y5pUXG/x64M+yeCzx8pJ9tE9vTP1x/v8jy/zcy/nzgrbD7MmBxM8tpdrvjODZPBHY1M+5Ugh/S9yyHICmtjfT3CrdlSDPL+jNwY9g9h6B55IZxE4g/0cd93MYui/f+MxDBv7Dov6ZTgQ1h95lANZAT7/6LjT16jBEk72oiP0oE90u8fCT7NNEvL6Nv2rZId2UT/Q1NuI4GPi7pI5HxmcBLZnZA0ieAW4FfSnoNuMXib58k2iDYaOCUsJnbBhkEf09jDSM4mA9Ehm3kUKuKzcbcWkCSJhD8UygkOLAzCNqvaUls88RTInH8SVL02kMdwdl2U/PGiqfp3qbmj+uzDRs3u5vgYSAFBA2cQdA88Z6wu7mmfZtrbhha3u7DWrgMG0m7l+CsekA4OK+Z6w0jgY3WfLl0Y6xmVhFc+mnc1vMI2imaQPDvpxewPJx8GId/xhubWX5T2nLctiba5HPDMBEk5AY7zKyqcWTb9l+sQQTfi+j2Nts0dOw+7W681k37lBCcHfePvHqb2XcBzOwZMzuH4KztLYKWDCGm6VeCBrViWcx6XolZTx8za+oOzC3AAEm9I8NGxRtzKx4It2O8mfUlKDZRy7Mc1mxvtHniEoIyzWgcOXZ4c77RfRCrsenemOXHO39rPglcRFC234/gXwa0vr0QbFtzVfTi2e4GtxA0gHZKuL/PaCGGEmCU2vjMXUnZBP9sfkjw1LD+BNc1os0wx36GUS0dy205bmPFfnbRJp8bltXPzPq0ME9r+6+l42MnwT+t0ZFhscdXj+GJvn1+A3xE0rmS0hU8d/RMSSMkDZZ0UZhwDxJc8Gk4i1sCnCFplKR+wH+2sp4ngAmS/iNspjZT0vSwAa3DWPBEoiKCdtWzFDwdKnr23mzMcWxvHsF1h/2SjiO+W/1vl9RL0mSCstqG5okfBO4Om+FFUoGki+JYXoP2Nt3bmjyCz62MIJH9vzbM+wQwVNJNYRs4eZJOCce1ZbvzCJLbbkn5BGfdzXmdICl/V1Lv8HP9QByxxtMM81WSJoVnyLExLAE+Gn7GxxBcQG8Q93HbhG3ACAXNXmNH1nx1a/uv2eabwzP+Rwk+q7zw87qZ4PvT43iibwcL2lu/iODMdgfBGcxXCPZrGsGBsZmgxsEHCROjmT1HkPCWEfwtfqKV9ewj+PJdGi5vK4cuOjXlk8Ap4Xq/RXBRKZ6YW3NruOx9BF+6JtuUj/EKwUXTF4Afmtmz4fCfEFxYe1bSPoILlKc0vYj3svY33duahwn+qm8CVnGo+eF4YttHcJH7IwSf1RrgrHB0W7b7xwQXFXeG0z3dwjrrwvUdQ3Ahv5SgjDyeWFtrhvnHBBeq14bvUfcSlGVvA35FcFE6uuy2HLdRLxLUpNoqqeHJZm1tvvrHtLz/fgL8u6Rdkn7axPw3EPxjWU9Qw+Z3BNcsehxv68Z1CgVPadoAZLZQbux6oFRqdjpZ+Bm9c84lOU/0zjmX5Lzoxjnnkpyf0TvnXJLrdjdMDRo0yMaMGZPoMJxzrkd54403dppZQVPjul2iHzNmDEVFRYkOwznnehRJzd617EU3zjmX5DzRO+dckvNE75xzSa7bldE751y8ampqKC0tpaqqqvWJk0ROTg4jRowgMzMz7nk80TvneqzS0lLy8vIYM2YMkeaLk5aZUVZWRmlpKWPHjo17Pi+6cc71WFVVVQwcODAlkjyAJAYOHNjmfzBxJXpJsyW9LWmtpNtamO5jkkxSYdg/RlKlpCXh68E2Reecc61IlSTf4Ei2t9Wim/BJO/cTNLtaCiySNN/MVsVMl0fwPMx/xSxinZmd2ObInEsBZsb2fQfZWFZBSXkFvbLSGT+4D6MH9iYz3f9wu44RTxn9DIJnI64HkDSPoD3zVTHT/RdBW9Nf6dAInevhDtbWUVJeSXH5AYrLKthYHiT1jWUVlOyqoKqm/j3zZKSJsYN6M35wH445Ko9jjurD+KP6MHZQb3Iy05tYi3PNiyfRD+fwZ2+WEvOgBEknASPN7ElJsYl+rKTFBE8m+qaZ/T12BZKuAa4BGDUq9kllzvUMJeUVLC7ZTXHZATaWVVBcHry27q0i2nZgr6x0RuX3Yuyg3px5bAGj8nsxamBvRuX34sDBWtZs38eabftZs30/q7fs4+kVW6kP508TjB7Ym2OO6tOY/McflcfRR/WmV1brX2czo67eqKkzquvqqQlftWH/kL459M72OhqJUFtbS0ZG5+z7di81fGbnPQRPRY+1BRhlZmWSTgb+LGmyme2NTmRmDwEPARQWFnpzmq7HeXXNTj778KLGs/Oj8rIZld+LU48eyOj83owamMuo/CCZD+qT1WI56/HD+x3WX1VTx7tlBxqT/9rwh+Clt7ZTW3/o6zK8fy59czPDxF1/eDKvDfpr6utpqcHarIw0TjtmELMmDWbmpMEM6hPPw6BS14EDB7jkkksoLS2lrq6O22+/nXHjxnHjjTdy4MABsrOzeeGFF8jMzOS6666jqKiIjIwM7rnnHs466yzmzp3LH//4R/bv309dXR0LFizghhtuYMWKFdTU1HDnnXdy0UVtecJm0+JJ9Js4/OHAIzj8Abl5wPHAy+HBOwSYL+lCMysieO4mZvaGpHUET5r3xmxc0nhh9Tau++2bjBvUmx9dMpVxg/qQm9VxxSs5mekcN6Qvxw3pe9jwmrp6NpZVNCb+Ndv3U1lTR1Z6GpnpIiM9jcz0NLLSRWZ6GpkZh/rfMy49jfQ0sax0D8+s3MqLb20n7U/LKRydz6zJg5k1aQijBvZqJsLu4dt/XcmqzXtbn7ANJg3ry7c+MrnZ8U8//TTDhg3jySefBGDPnj1MmzaNRx55hOnTp7N3715yc3P5yU9+giSWL1/OW2+9xaxZs3jnnXcAePPNN1m2bBn5+fl8/etf5+yzz2bOnDns3r2bGTNmMHPmTHr37t2u7Ygn0S8CxksaS5DgLyV4riQAZrYHGNTQL+ll4FYzK5JUAJSbWZ2kccB4gucvOpcUFizfwpd+v5hJw/ry8Gdm0L9XVpetOzM9rbEIZ/bxHbPMi6cN5/YLJrJqy16eWbmNZ1du5TtPruY7T67muCF5nDt5CLMmD2bS0L4pV9ulKVOmTOGWW27ha1/7GhdccAH9+/dn6NChTJ8+HYC+fYMf51dffZUbbrgBgOOOO47Ro0c3JvpzzjmH/Px8AJ599lnmz5/PD3/4QyCoPlpcXMzEifE8T715rSZ6M6uVdD3wDJAOzDGzlZLuAorMbH4Ls58B3CWpBqgHrjWz8nZF7Fw38afFpdzy6FJOGjWAOZ+eTt+c+O9U7M4kMXlYPyYP68fN50xgY9kBnlu1jWdWbuWnL67hJy+sYcSAXGZNGsK5kwdTOCaf9LTEJ/2Wzrw7y4QJE3jzzTdZsGAB3/zmNzn77LPbvIzo2bqZ8fjjj3PssS0987zt4iqjN7MFwIKYYXc0M+2Zke7HgcfbEZ9z3dK814v5zz8t59RxA/mfTxUm9QXM0QN789nTx/HZ08exc/9Bng+T/m8WbmTOaxvI753FzIlHMWvSEE4bPyilagVt3ryZ/Px8rrjiCvr378/Pf/5ztmzZwqJFi5g+fTr79u0jNzeX008/nd/+9recffbZvPPOOxQXF3Psscfy5ptvHra8c889l5/97Gf87Gc/QxKLFy9m2rRp7Y4zeY9O5zrJ/722gW//dRVnHlvAg1ecnFKJbVCfbC6dMYpLZ4xi/8FaXn57O8+u3MZTy7fyaFEpfbIzmDnxKM6fMpQzJhQk/b5Zvnw5X/nKV0hLSyMzM5MHHngAM+OGG26gsrKS3Nxcnn/+eb7whS9w3XXXMWXKFDIyMpg7dy7Z2e+90H377bdz0003ccIJJ1BfX8/YsWN54okn2h1nt3tmbGFhofmDR1x39cDL6/je029x7uTB/PSyaWRnJHcii9fB2jr+ua6Mp5Zv5emVW9lTWUOf7AzOmTSYD08ZyukTBnXKvlq9enW7y697oqa2W9IbZlbY1PR+Ru8A2FNRw+qte8nvncXRBX26RZlrd2Jm3Pv8Gn76whounDqMH10y1e9cjcjOSOfMY4/izGOP4jv/djz/WFfGk8s288zKbfxp8SbyGpL+CUM5bXznJH3XPE/0KWh3RTUrNu1l+aY9rNi0h+Wb9lBcXtE4PjcznUnD+nL8sL4cP7wfU0b045iCPmSkaGIzM7771Fv84m/r+fjJI/jux07wH8IWZKan8cEJBXxwQgHfubief6zbyZPLtvDMyq38cfEm8nKCpH/BCUM57ZgCsjJS87jqSl50k+R2V1SzPEzmDUm9pLyycfzI/FymDO/H8cP7MXFoX3YdqG6cduXmvVRU1wGQnZHGxKF9w2mDH4AJg/OS/qy2vt64868refifG/mP943m2xdOJs2T/BGprq3ntUjS31dVS15OBrMmDeGCE4bygWMGtTnpr169muOOOy6lqnqaGW+99Vabim480SeRPZU1LC3ZfVhSL911KKmPyu/VmNQbEnZL9b7r6o0NOw80Lqsh+e8/WAsEd1FOHJLH5IblDetHXk4GNXX1VIe31deEd2jW1NVTW19Pde2h7pra4E7N6F2bedkZFORlM6hPduN7omq01NUbX//jch4pKuFzp4/l6+dPTKmE0pmqa+t5be1Onli2hWdXBUm/b04Gp48vYOrIfkwd0Z/jh/dr9bPfsGEDeXl5KdNUcUN79Pv27XtPe/Se6FPA5t2VfPinf2dXRQ0Aowf2akzoDUm4X6/21/OurzfeLTvAis17gx+A0j2s2LyHfVW17V52c3plpUcSf9Z7fggK8rIpCN87qpZHbV09tzy2lL8s2cyXPjSeL88cnxKJJBEO1tbx2tqdPLlsK//aUNZ4cpImmDA4jxNH9mfqyP5MHdGfCYMPL0L0J0wd4ok+yZkZV/+qiH+uK+PnV5zESaMG0C+3627eMTOKyytYuXkvVTV1jbfUZ4a312ekK7wtv+nujIZb9tPS2Hewhp37qtmx/yA79h1kZ8x7Q3fDD1qsYf1yOP6wfy39KMhrW3st1bX1fOn3i3l65Va+OvtYvnDmMR2xm1ycdu4/yLLS3Swp2cPSkt0sLd3N7vDzzslMY8rw4Ix/6sj+nDiyPyMG5HbIj3BDLuypP+ie6JPcX5Zs4sZ5S7j9gklcfVr8jxfryapr6yk/UH3Yj8D2fVW8s20/KzbtYf3OA43TDu6bzZThwZ2eDcl/cN/sJr/QVTV1XPebN3jp7R186yOT+PQHUmN/dmcNJxJLSnazpGQ3S0t2s2LzXqprgwbk8ntnMXVEP6aO7M9ReTlU1tRRWV0bvtdTWVNHVU0dldV1VNTUUVVdF4wLhzW8V9XWkd8rixlj85kxNp/pY/KZOLRvj7nw7ok+iZUfqGbmPa8wKr8Xj1/3/h5zUHa2fVU1rNoc1CxaGb6v27G/seXGQX2yOX5430M/ACP6MaBXJp97uIh/rCvj7oun8MlTvMns7qqmrp63t+5rTPxLS3ezZvv+w1rmTBP0ysogJzOdXlnp5Gamk5OVTm5mGrmZ6eRmpZObmUFuVtCfk5nOpl2VvP5ueWPxUV52BoVjBjBj7EBmjM1nyvB+3baWkCf6JHbTvMU8uXwLT9xwOscOyUt0ON1aRXUtq8JrCw3XGNZs309d2NRvVkYatXX1/PDjU/noSSMSHK1rq/0Ha9lfVRsm8HQy03XExTCbdleyaEM5/9pQzqJ3y1m7fT8QFB1NGzmAGWPzOWVsPtNGDejQlkrbwxN9knrxrW18Zm4RN35oPF8+Z0Kiw+mRqmrqWL1lLys27+XtrXv50HGDOeu4oxIdlutmdu4/SNG7hxL/qs17qbfgSWBTRvRrTPwTBufRLzeTPtkZXV7W74k+Ce0/WMuse16hd3YGT3zpNL/T0LkutLeqhjc27uL1DeW8vqGcZaW7qak7lEvT00TfnAz65WbSNzfz8Pec4L1f4/CMxu7+vbKOuCKFN4GQhL7/9Fts2VvFH659vyd557pY35xMzjr2KM46Nvj3V1VTx+Li3RSXH2BPZQ17K2vZU1nT+NpbVcOm3ZXsDfujPwpRJ4zox/zrT+vweD3R90CL3i3n1ws3cuWpYzh59IBEh+NcysvJTOfUowdy6tEDW53WzKiqqT/shyD4cajptJsDPdH3MFU1dXzt8WUM65fLV87t2IcTOOc6n6TggnFWOkP65XTJOj3R9zD3vbiW9TsO8PBnZiT1wy6ccx2ne1YIdU1atXkvD76yjo+eNJwzJhQkOhznXA/hib6HqK2r52uPL6N/r0xu//CkRIfjnOtB/L9/DzHntQ0s37SH+z45jQG9m29x0jnnYvkZfQ+wsewA9zz3DjMnBo9lc865tvBE382ZGbc9vpzMtDS+c/HxPbZlPedc4sSV6CXNlvS2pLWSbmthuo9JMkmFkWH/Gc73tqRzOyLoVPLIohL+ub6M/zx/YpdVxXLOJZdWy+glpQP3A+cApcAiSfPNbFXMdHnAjcC/IsMmAZcCk4FhwPOSJphZXcdtQvLatreKuxes5pSx+Vw6fWSiw3HO9VDxnNHPANaa2XozqwbmARc1Md1/Ad8Doo96uQiYZ2YHzWwDsDZcnmuFmXH7n1dQXVvPdz92gj+n1Dl3xOJJ9MOBkkh/aTiskaSTgJFm9mRb5w3nv0ZSkaSiHTt2xBV4sntqxVaeXbWNm2ZOYOyg3okOxznXg7X7YqykNOAe4JYjXYaZPWRmhWZWWFDgNwLtrqjmjr+s5Pjhffnc6f6EI+dc+8RTj34TEC0gHhEOa5AHHA+8HNYIGQLMl3RhHPO6Jtz95Gp2VVTzq89MP+xByM45dyTiySKLgPGSxkrKIri4Or9hpJntMbNBZjbGzMYAC4ELzawonO5SSdmSxgLjgdc7fCuSyKtrdvLYG6Vcc8Y4Jg/rl+hwnHNJoNUzejOrlXQ98AyQDswxs5WS7gKKzGx+C/OulPQosAqoBb7oNW6aV1Fdy21/XMa4Qb258UPjEx2Ocy5JxNUEgpktABbEDLujmWnPjOm/G7j7CONLKT969h1Kd1XyyDXvIyfTHybinOsYXgDcTSxcX8ac1zZw+SmjOGVc6w8vcM65eHmi7wb2VNTw5UeWMDq/F18/f2Kiw3HOJRlvvTLBzIyv/2k5O/Yd5PHr3u8PE3HOdTg/o0+wx94o5cnlW/jyOROYOrJ/osNxziUhT/QJtGHnAe6cv5JTxuZz7QePTnQ4zrkk5Yk+QWrq6rlp3mIy09O49xMnku5t2TjnOokXCCfIvc+9w9LSPfz88pMY1j830eE455KYn9EnwD/XlfHAK+u4pHAE5/sTo5xzncwTfRfbXVHNzY8uYczA3nzrI5MTHY5zLgV40U0X8qqUzrlE8DP6LvRYUSkLlm/l5lleldI513U80XeRDTsPcOdfV/K+cfl8/gyvSumc6zqe6LtAdW09N3pVSudcgnghcRf48fPvsKx0Dw9cfhJD+3lVSudc1/Iz+k7WUJXyE4UjOc+rUjrnEsATfSeKVqW84yOTEh2Ocy5FedFNJ4lWpfzjF7wqpXMucfyMvpM0VKW8ZdaxnDCif6LDcc6lME/0naChKuWp4wby+TPGJToc51yK80TfwaJVKe/5xFTSvCqlcy7BvOC4g90bVqV88AqvSumc6x7iOqOXNFvS25LWSrqtifHXSlouaYmkVyVNCoePkVQZDl8i6cGO3oDu5B/rdvLgK+u4dPpIZh/vVSmdc91Dq2f0ktKB+4FzgFJgkaT5ZrYqMtnvzOzBcPoLgXuA2eG4dWZ2YodG3Q1t21vFzY8sZaxXpXTOdTPxnNHPANaa2XozqwbmARdFJzCzvZHe3oB1XIjd357KGq6c8zr7qmr42Sen0SvLS8Scc91HPIl+OFAS6S8Nhx1G0hclrQO+D3wpMmqspMWSXpF0erui7Yaqaur43MNFrNuxn1/8RyGTh/VLdEjOOXeYDqt1Y2b3m9nRwNeAb4aDtwCjzGwacDPwO0l9Y+eVdI2kIklFO3bs6KiQOl1dvXHTvCW8vqGcH11yIqeNH5TokJxz7j3iSfSbgJGR/hHhsObMAy4GMLODZlYWdr8BrAMmxM5gZg+ZWaGZFRYUFMQZemKZGXfOX8nTK7dy+wWTuHDqsESH5JxzTYon0S8CxksaKykLuBSYH51A0vhI74eBNeHwgvBiLpLGAeOB9R0ReKLd9+Jafr1wI5//4DiuPm1sosNxzrlmtXrV0MxqJV0PPAOkA3PMbKWku4AiM5sPXC9pJlAD7AKuDGc/A7hLUg1QD1xrZuWdsSFdad7rxfzouXf46EnDuW32cYkOxznnWiSz7lVBprCw0IqKihIdRrOeW7WNz/+6iNPHF/C/VxaSme43FzvnEk/SG2ZW2NQ4z1JtUPRuOdf/7k2mDO/Hzy8/yZO8c65H8EwVpzXb9nH1r4oY1j+XOVdN92aHnXM9hif6OGzZU8mn5rxOVkYaD39mBgP7ZCc6JOeci5sn+lbsqWi467WWuZ+ezsj8XokOyTnn2sQTfQuqaur47MOLeHdnBQ996mS/69U51yN5QXMzauvqueH3iynauIv7LjuJ9x/td70653omP6Nvgplx+19W8tyqbdz5kcl8+ARvctg513N5om/Cj59fw+9fL+aLZx3Nle8fk+hwnHOuXTzRx/jNwo385IU1fPzkEdw669hEh+Occ+3miT7i6RVbueMvKzj7uKP4749OQfLnvTrnej5P9KEDB2v58iNLmDqyP/d/8iQy/K5X51yS8GwWerfsAJU1dVxz+jhys9ITHY5zznUYT/ShkvIKAL8hyjmXdDzRhzaWBYl+1EBP9M655OKJPlRcXsGAXpn0zclMdCjOOdehPNGHissrGOXFNs65JOSJPlRcXuHl8865pOSJnqBdm027Khnt5fPOuSTkiR7YsqeK2nrzohvnXFLyRE9QbAMwKr93giNxzrmO54meSKL3ohvnXBLyRE+Q6DPTxZC+OYkOxTnnOlxciV7SbElvS1or6bYmxl8rabmkJZJelTQpMu4/w/nelnRuRwbfUYrLKhg5oBfpad6ImXMu+bSa6CWlA/cD5wGTgMuiiTz0OzObYmYnAt8H7gnnnQRcCkwGZgM/D5fXrXjVSudcMovnjH4GsNbM1ptZNTAPuCg6gZntjfT2BizsvgiYZ2YHzWwDsDZcXrfiN0s555JZPM+MHQ6URPpLgVNiJ5L0ReBmIAs4OzLvwph5hzcx7zXANQCjRo2KJ+4Os6eihj2VNV6H3jmXtDrsYqyZ3W9mRwNfA77ZxnkfMrNCMyssKCjoqJDiUuytVjrnklw8iX4TMDLSPyIc1px5wMVHOG+X21h+AMCLbpxzSSueRL8IGC9prKQsgour86MTSBof6f0wsCbsng9cKilb0lhgPPB6+8PuOIdulvJE75xLTq2W0ZtZraTrgWeAdGCOma2UdBdQZGbzgeslzQRqgF3AleG8KyU9CqwCaoEvmlldJ23LESkpr2BQnyx6Z8dzucI553qeuLKbmS0AFsQMuyPSfWML894N3H2kAXa2jWVetdI5l9xS/s7Y4vIKRnuid84lsZRO9DV19WzeXenl8865pJbSiX7TrkrqzatWOueSW0on+oYaN6MHevPEzrnk5Yker1rpnEtuKZ/oszLSOCovO9GhOOdcp0ntRF8WNGaW5s0TO+eSWGonem+10jmXAlI20ZuZJ3rnXEpI2US/q6KG/QdrPdE755Jeyib6jWXeaqVzLjWkbKI/VIfeE71zLrmlbKIvCRP9iAGe6J1zyS1lE/3GsgqOyssmN6vbPavcOec6VMom+uLyCi+2cc6lhJRN9CXl3g69cy41pGSiP1hbx5a9VV7jxjmXElIy0ZfuqsTMa9w451JDSiZ6b7XSOZdKUjPRlwWJ3svonXOpIDUTfXkFuZnpFPTx5omdc8kvJRP9xrB5YsmbJ3bOJb+4Er2k2ZLelrRW0m1NjL9Z0ipJyyS9IGl0ZFydpCXha35HBn+kvGqlcy6VtJroJaUD9wPnAZOAyyRNiplsMVBoZicAfwC+HxlXaWYnhq8LOyjuI9bQPLHXuHHOpYp4zuhnAGvNbL2ZVQPzgIuiE5jZS2ZWEfYuBEZ0bJgdZ8f+g1TW1HmNG+dcyogn0Q8HSiL9peGw5lwNPBXpz5FUJGmhpIubmkHSNeE0RTt27IgjpCNX4lUrnXMpJqMjFybpCqAQ+GBk8Ggz2yRpHPCipOVmti46n5k9BDwEUFhYaB0ZU6zGOvRedOOcSxHxnNFvAkZG+keEww4jaSbwDeBCMzvYMNzMNoXv64GXgWntiLfdNpZVIMHw/rmJDMM557pMPIl+ETBe0lhJWcClwGG1ZyRNA35BkOS3R4YPkJQddg8CPgCs6qjgj0RxeQVD+uaQk+nNEzvnUkOrRTdmVivpeuAZIB2YY2YrJd0FFJnZfOAHQB/gsbBuenFYw2Yi8AtJ9QQ/Kt81s4Qm+hJ/ILhzLsXEVUZvZguABTHD7oh0z2xmvn8AU9oTYEfbWFbBBycUJDoM55zrMil1Z2xldR3b9x30OvTOuZSSUom+dJc3ZuacSz0pleg3lnkdeudc6kmpRN9Qh370wN4JjsQ557pOyiX6PtkZDOiVmehQnHOuy6Rcoh/pzRM751JMyiX60V4+75xLMSmT6Ovrg+aJvY0b51yqSZlEv33fQapr671qpXMu5aRMom+sceOJ3jmXYlIm0W8sOwB4HXrnXOpJmURfUl5BmmCYN0/snEsxKZPoi8srGNY/l6yMlNlk55wDUijRb/TmiZ1zKSplEr23Q++cS1UpkegPHKxl5/5qr0PvnEtJKZHoGx8I7mf0zrkU5IneOeeSXGok+rKGm6W8eWLnXOpJjURfXkHfnAz6efPEzrkUlDKJ3i/EOudSVVyJXtJsSW9LWivptibG3yxplaRlkl6QNDoy7kpJa8LXlR0ZfLyC5om92MY5l5paTfSS0oH7gfOAScBlkibFTLYYKDSzE4A/AN8P580HvgWcAswAviVpQMeF37q6eqN0V4W3WumcS1nxnNHPANaa2XozqwbmARdFJzCzl8ysIuxdCIwIu88FnjOzcjPbBTwHzO6Y0OOzdW8VNXXGaC+6cc6lqHgS/XCgJNJfGg5rztXAU22ZV9I1kookFe3YsSOOkOLnrVY651Jdh16MlXQFUAj8oC3zmdlDZlZoZoUFBQUdGRIlXofeOZfi4kn0m4CRkf4R4bDDSJoJfAO40MwOtmXezlRcXkFGmhjaL6crV+ucc91GPIl+ETBe0lhJWcClwPzoBJKmAb8gSPLbI6OeAWZJGhBehJ0VDusyG8sqGD4gl4z0lKhJ6pxz75HR2gRmVivpeoIEnQ7MMbOVku4CisxsPkFRTR/gMUkAxWZ2oZmVS/ovgh8LgLvMrLxTtqQZ3mqlcy7VtZroAcxsAbAgZtgdke6ZLcw7B5hzpAG2V3F5BedPGZqo1TvnXMIldXnG3qoadlXU+Bm9cy6lJXWib2jMzBO9cy6VJXeib6ha6TdLOedSWEokem/+wDmXypI+0Q/olUnfHG+e2DmXupI70ZdVMGqgt1rpnEttyZ3ovQ69c84lb6Kvratn0+5KRuXnJjoU55xLqKRN9Jt3V1FXb/7AEedcykvaRO81bpxzLpD0id7r0DvnUl3SJvqN5QfISk9jSF9vntg5l9qSNtGXlFcwYkAu6WlKdCjOOZdQSZvoi8srvNjGOedI0kRvZmws8zr0zjkHSZro91TWsK+q1hO9c86RpIl+ozdP7JxzjZIy0XvVSuecOySpE/3IAZ7onXMuORN9WQWD+mTTOzuuR+I651xSS85EX17hjZk551woiRO9F9s45xzEmeglzZb0tqS1km5rYvwZkt6UVCvp32PG1UlaEr7md1TgzamurWfLnkp/4IhzzoVaLcSWlA7cD5wDlAKLJM03s1WRyYqBq4Bbm1hEpZmd2P5Q47NpdyX15lUrnXOuQTxXK2cAa81sPYCkecBFQGOiN7N3w3H1nRBjmzRWrfRE75xzQHxFN8OBkkh/aTgsXjmSiiQtlHRxUxNIuiacpmjHjh1tWPR7FZcdAGC016F3zjmgay7GjjazQuCTwI8lHR07gZk9ZGaFZlZYUFDQrpUVl1eQnZFGQZ/sdi3HOeeSRTyJfhMwMtI/IhwWFzPbFL6vB14GprUhvjbbWFbByPxepHnzxM45B8SX6BcB4yWNlZQFXArEVXtG0gBJ2WH3IOADRMr2O0NxeQWjvXzeOecatZrozawWuB54BlgNPGpmKyXdJelCAEnTJZUCHwd+IWllOPtEoEjSUuAl4LsxtXU6lJlRUl7hz4l1zrmIuNoIMLMFwIKYYXdEuhcRFOnEzvcPYEo7Y4xb2YFqDlTXeY0b55yLSKo7YxuqVnqNG+ecOySpEn2J16F3zrn3SKpE3/DAES+jd865Q5Iq0ReXVzC4bzY5memJDsU557qNpEv0XmzjnHOHS65EX1bBqHxvtdI556KSJtFX1dSxdW+Vn9E751yMpEn0+6pqOXXcQCYOzUt0KM45160kzUNVC/Ky+f0170t0GM451+0kzRm9c865pnmid865JOeJ3jnnkpwneuecS3Ke6J1zLsl5onfOuSTnid4555KcJ3rnnEtyMrNEx3AYSTuAjYmOowWDgJ2JDqIFHl/7eHzt4/G1T3viG21mBU2N6HaJvruTVGRmhYmOozkeX/t4fO3j8bVPZ8XnRTfOOZfkPNE751yS80Tfdg8lOoBWeHzt4/G1j8fXPp0Sn5fRO+dckvMzeuecS3Ke6J1zLsl5oo8haaSklyStkrRS0o1NTHOmpD2SloSvOxIQ57uSlofrL2pivCT9VNJaScskndSFsR0b2TdLJO2VdFPMNF26DyXNkbRd0orIsHxJz0laE74PaGbeK8Np1ki6sgvj+4Gkt8LP70+S+jczb4vHQifGd6ekTZHP8Pxm5p0t6e3wWLytC+N7JBLbu5KWNDNvV+y/JvNKlx2DZuavyAsYCpwUducB7wCTYqY5E3giwXG+CwxqYfz5wFOAgPcB/0pQnOnAVoKbORK2D4EzgJOAFZFh3wduC7tvA77XxHz5wPrwfUDYPaCL4psFZITd32sqvniOhU6M707g1jg+/3XAOCALWBr7feqs+GLG/wi4I4H7r8m80lXHoJ/RxzCzLWb2Zti9D1gNDE9sVEfkIuBhCywE+ksamoA4PgSsM7OE3u1sZn8DymMGXwT8Kuz+FXBxE7OeCzxnZuVmtgt4DpjdFfGZ2bNmVhv2LgRGdPR649XM/ovHDGCtma03s2pgHsF+71AtxSdJwCXA7zt6vfFqIa90yTHoib4FksYA04B/NTH6VElLJT0laXLXRgaAAc9KekPSNU2MHw6URPpLScwP1qU0/wVL9D4cbGZbwu6twOAmpuku+/EzBP/QmtLasdCZrg+LluY0U+zQHfbf6cA2M1vTzPgu3X8xeaVLjkFP9M2Q1Ad4HLjJzPbGjH6ToChiKvAz4M9dHB7AaWZ2EnAe8EVJZyQghhZJygIuBB5rYnR32IeNLPiP3C3rGkv6BlAL/LaZSRJ1LDwAHA2cCGwhKB7pji6j5bP5Ltt/LeWVzjwGPdE3QVImwYfxWzP7Y+x4M9trZvvD7gVApqRBXRmjmW0K37cDfyL4ixy1CRgZ6R8RDutK5wFvmtm22BHdYR8C2xqKs8L37U1Mk9D9KOkq4ALg8jARvEccx0KnMLNtZlZnZvXA/zSz3kTvvwzgo8AjzU3TVfuvmbzSJcegJ/oYYXneL4HVZnZPM9MMCadD0gyC/VjWhTH2lpTX0E1w0W5FzGTzgU8p8D5gT+QvYldp9kwq0fswNB9oqMFwJfCXJqZ5BpglaUBYNDErHNbpJM0GvgpcaGYVzUwTz7HQWfFFr/n8WzPrXQSMlzQ2/Id3KcF+7yozgbfMrLSpkV21/1rIK11zDHbmleae+AJOI/j7tAxYEr7OB64Frg2nuR5YSVCDYCHw/i6OcVy47qVhHN8Ih0djFHA/QY2H5UBhF8fYmyBx94sMS9g+JPjB2QLUEJRxXg0MBF4A1gDPA/nhtIXA/0bm/QywNnx9ugvjW0tQNttwHD4YTjsMWNDSsdBF8f06PLaWESSsobHxhf3nE9QyWdeV8YXD5zYcc5FpE7H/mssrXXIMehMIzjmX5LzoxjnnkpwneuecS3Ke6J1zLsl5onfOuSTnid4555KcJ3rnnEtynuidAySdGG1mV9KFHdWkrqSbJPXqiGU5dyS8Hr1zNDY1UGhm13fCst8Nl72zDfOkm1ldR8fiUpOf0bseRdIYSasl/U/4AIdnJeU2M+3Rkp4OWyX8u6TjwuEfl7QibDnzb+Gt+XcBnwgfPvEJSVdJui+cfq6kByQtlLRewUNT5oRxzI2s7wFJRWFc3w6HfYngTsyXJL0UDrtMwYMuVkj6XmT+/ZJ+JGkpQcue31XwoIplkn7YOXvUpYTOuN3XX/7qrBcwhqAlxxPD/keBK5qZ9gVgfNh9CvBi2L0cGB529w/frwLui8zb2E9wG/08gmYlLgL2AlMITpTeiMTScPt6OvAycELY/y7hgy0Ikn4xUABkAC8CF4fjDLgk7B4IvM2hf939E73v/dVzX35G73qiDWa2JOx+gyD5HyZsDvb9wGMKHiH3C4Kn/AC8BsyV9DmCpByPv5qZEfxIbDOz5Ra02rgysv5LJL0JLAYmEzxBKNZ04GUz22HBQ0V+S/B0JIA6gtYNAfYAVcAvJX0UaLJRM+fikZHoAJw7Agcj3XVAU0U3acBuMzsxdoSZXSvpFODDwBuSTm7DOutj1l8PZEgaC9wKTDezXWGRTk4cy42qsrBc3sxqw1Y9PwT8O0EjcGe3cXnOAV5G75KUBQ912CDp49D4sPSpYffRZvYvM7sD2EHQ1vc+gmd5Hqm+wAFgj6TBBG3xN4gu+3Xgg5IGSUonaMr5ldiFhf9I+lnQVv+XgantiM2lOD+jd8nscuABSd8EMgnK2ZcCP5A0nqDM/YVwWDFwW1jM899tXZGZLZW0GHiLoGnh1yKjHwKelrTZzM4Kq22+FK7/STNrqg3yPOAvknLC6W5ua0zONfDqlc45l+S86MY555KcF924Hk/S/cAHYgb/xMz+LxHxONfdeNGNc84lOS+6cc65JOeJ3jnnkpwneuecS3Ke6J1zLsn9f+UgK6J/BkdeAAAAAElFTkSuQmCC", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["ax = df.plot(x=\"n_estimators\", y=\"score\")\n", "ax.set_title(\"Apprentissage continu\\nmesure de la performance \u00e0 chaque it\u00e9ration\");"]}, {"cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": []}, {"cell_type": "code", "execution_count": 19, "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.9.5"}}, "nbformat": 4, "nbformat_minor": 2}