{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# Rappels sur scikit-learn et le machine learning (correction)\n", "\n", "Quelques exercices simples sur *scikit-learn*. Le notebook est long pour ceux qui d\u00e9butent en machine learning et sans doute sans suspens pour ceux qui en ont d\u00e9j\u00e0 fait."]}, {"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": ["## Des donn\u00e9es synth\u00e9tiques\n", "\n", "On simule un jeu de donn\u00e9es al\u00e9atoires."]}, {"cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([[0.33151303, 0.70686719],\n", "       [0.13039027, 0.58941167],\n", "       [0.612744  , 0.37799233],\n", "       [0.20215973, 0.11095186],\n", "       [0.56857961, 0.10783821]])"]}, "execution_count": 4, "metadata": {}, "output_type": "execute_result"}], "source": ["from numpy import random\n", "n = 1000\n", "X = random.rand(n, 2)\n", "X[:5]"]}, {"cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([0.10121972, 0.49414321, 2.19975264, 0.74372472, 2.27103021])"]}, "execution_count": 5, "metadata": {}, "output_type": "execute_result"}], "source": ["y = X[:, 0] * 3 - 2 * X[:, 1] ** 2 + random.rand(n)\n", "y[:5]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Exercice 1 : diviser en base d'apprentissage et de test\n", "\n", "Simple [train_test_split](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html)."]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": ["from sklearn.model_selection import train_test_split\n", "X_train, X_test, y_train, y_test = train_test_split(X, y)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Exercice 2 : caler une r\u00e9gression lin\u00e9aire\n", "\n", "Et calculer le coefficient $R^2$. Pour ceux qui ne savent pas se servir d'un moteur de recherche : [LinearRegression](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html), [r2_score](http://scikit-learn.org/stable/modules/generated/sklearn.metrics.r2_score.html)."]}, {"cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [{"data": {"text/plain": ["LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)"]}, "execution_count": 7, "metadata": {}, "output_type": "execute_result"}], "source": ["from sklearn.linear_model import LinearRegression\n", "reg = LinearRegression()\n", "reg.fit(X_train, y_train)"]}, {"cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [{"data": {"text/plain": ["0.908988490753245"]}, "execution_count": 8, "metadata": {}, "output_type": "execute_result"}], "source": ["from sklearn.metrics import r2_score\n", "score = r2_score(y_test, reg.predict(X_test))\n", "score"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Exercice 3 : am\u00e9liorer le mod\u00e8le en appliquant une transformation bien choisie\n", "\n", "Le mod\u00e8le de d\u00e9part est : $Y = 3 X_1 - 2 X_2^2 + \\epsilon$. Il suffit de rajouter des featues polyn\u00f4miales avec [PolynomialFeatures](http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.PolynomialFeatures.html)."]}, {"cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [{"data": {"text/plain": ["LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)"]}, "execution_count": 9, "metadata": {}, "output_type": "execute_result"}], "source": ["from sklearn.preprocessing import PolynomialFeatures\n", "poly = PolynomialFeatures()\n", "poly.fit(X_train)\n", "X_train2 = poly.transform(X_train)\n", "reg2 = LinearRegression()\n", "reg2.fit(X_train2, y_train)"]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [{"data": {"text/plain": ["0.9362394073926681"]}, "execution_count": 10, "metadata": {}, "output_type": "execute_result"}], "source": ["score2 = r2_score(y_test, reg2.predict(poly.transform(X_test)))\n", "score2"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Le coefficient $R^2$ est plus \u00e9lev\u00e9 car on utilise les m\u00eames variables que le mod\u00e8le. Il n'est th\u00e9oriquement pas possible d'aller au del\u00e0."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Exercice 4 : caler une for\u00eat al\u00e9atoire"]}, {"cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [{"data": {"text/plain": ["RandomForestRegressor(bootstrap=True, criterion='mse', max_depth=None,\n", "           max_features='auto', max_leaf_nodes=None,\n", "           min_impurity_decrease=0.0, min_impurity_split=None,\n", "           min_samples_leaf=1, min_samples_split=2,\n", "           min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=1,\n", "           oob_score=False, random_state=None, verbose=0, warm_start=False)"]}, "execution_count": 11, "metadata": {}, "output_type": "execute_result"}], "source": ["from sklearn.ensemble import RandomForestRegressor\n", "rf = RandomForestRegressor()\n", "rf.fit(X_train, y_train)"]}, {"cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [{"data": {"text/plain": ["0.9153506166386053"]}, "execution_count": 12, "metadata": {}, "output_type": "execute_result"}], "source": ["r2_score(y_test, rf.predict(X_test))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Le mod\u00e8le lin\u00e9aire est le meilleur mod\u00e8le dans notre cas puisque les donn\u00e9es ont \u00e9t\u00e9 construites de la sorte. Il est attendu que le $R^2$ ne soit pas plus \u00e9lev\u00e9 tout du moins pas significativement plus \u00e9lev\u00e9. On regarde avec les features polyn\u00f4miales..."]}, {"cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [{"data": {"text/plain": ["0.9119002367619022"]}, "execution_count": 13, "metadata": {}, "output_type": "execute_result"}], "source": ["rf2 = RandomForestRegressor()\n", "rf2.fit(X_train2, y_train)\n", "r2_score(y_test, rf2.predict(poly.transform(X_test)))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Avant de tirer des conclusions h\u00e2tives, il faudrait recommencer plusieurs fois l'exp\u00e9rience avant de dire que la performance est plus ou moins \u00e9lev\u00e9e avec ces features ce que ce notebook ne fera pas puisque la r\u00e9ponse th\u00e9orique est connue dans ce cas."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Exercice 5 : un peu de math\n", "\n", "Comparer les deux mod\u00e8les sur les donn\u00e9es suivantes ? Que remarquez-vous ? Expliquez pourquoi ?"]}, {"cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": ["X_test2 = random.rand(n, 2) + 0.5\n", "y_test2 = X_test2[:, 0] * 3 - 2 * X_test2[:, 1] ** 2 + random.rand(n)"]}, {"cell_type": "code", "execution_count": 14, "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>name</th>\n", "      <th>r2</th>\n", "      <th>r2_jeu2</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>LinearRegression</td>\n", "      <td>0.908988</td>\n", "      <td>0.682467</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>LinearRegression + X^2</td>\n", "      <td>0.936239</td>\n", "      <td>0.948110</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>RandomForestRegressor</td>\n", "      <td>0.915351</td>\n", "      <td>0.493273</td>\n", "    </tr>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>RandomForestRegressor + X^2</td>\n", "      <td>0.911900</td>\n", "      <td>0.517105</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["                          name        r2   r2_jeu2\n", "0             LinearRegression  0.908988  0.682467\n", "1       LinearRegression + X^2  0.936239  0.948110\n", "2        RandomForestRegressor  0.915351  0.493273\n", "3  RandomForestRegressor + X^2  0.911900  0.517105"]}, "execution_count": 15, "metadata": {}, "output_type": "execute_result"}], "source": ["res = []\n", "for model in [reg, reg2, rf, rf2]:\n", "    name = model.__class__.__name__\n", "    try:\n", "        pred = model.predict(X_test)\n", "        pred2 = model.predict(X_test2)\n", "    except Exception:\n", "        pred = model.predict(poly.transform(X_test))\n", "        pred2 = model.predict(poly.transform(X_test2))\n", "        name += \" + X^2\"\n", "    res.append(dict(name=name, r2=r2_score(y_test, pred),\n", "                    r2_jeu2=r2_score(y_test2, pred2)))\n", "\n", "import pandas\n", "df = pandas.DataFrame(res)\n", "df"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Le seul mod\u00e8le qui s'en tire vraiment est la r\u00e9gression lin\u00e9aire avec les features polyn\u00f4miales. Comme il \u00e9quivaut au mod\u00e8le th\u00e9orique, il est normal qu'il ne se plante pas trop m\u00eame si ses coefficients ne sont pas identique au mod\u00e8le th\u00e9orique (il faudrait plus de donn\u00e9es pour que cela converge)."]}, {"cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [{"data": {"text/plain": ["(array([ 0.        ,  2.81692538, -0.29768531,  0.08662761,  0.13367719,\n", "        -1.7515442 ]), 0.5889925538787228)"]}, "execution_count": 16, "metadata": {}, "output_type": "execute_result"}], "source": ["reg2.coef_, reg2.intercept_"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Pour les autes mod\u00e8les, voyons d\u00e9j\u00e0 visuellement ce qu'il se passe."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Exercice 6 : faire un graphe avec...\n", "\n", "Je laisse le code d\u00e9crire l'approche choisie pour illustrer les carences des mod\u00e8les pr\u00e9c\u00e9dents. Le commentaire suit le graphique pour les paresseux."]}, {"cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["<Figure size 1008x288 with 2 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["import matplotlib.pyplot as plt\n", "fig, ax = plt.subplots(1, 2, figsize=(14, 4))\n", "\n", "a, b = 0.9, 1.1\n", "index1 = (X_test2[:, 0] >= a) & (X_test2[:, 0] <= b)\n", "index2 = (X_test2[:, 1] >= a) & (X_test2[:, 1] <= b)\n", "yth = X_test2[:, 0] * 3 - 2 * X_test2[:, 1]\n", "\n", "\n", "ax[0].set_xlabel(\"X1\")\n", "ax[0].set_ylabel(\"Y\")\n", "ax[0].plot(X_test2[index2, 0], yth[index2], '.', label='Y th\u00e9orique')\n", "ax[1].set_xlabel(\"X2\")\n", "ax[1].set_ylabel(\"Y\")\n", "ax[1].plot(X_test2[index1, 1], yth[index1], '.', label='Y th\u00e9orique')\n", "\n", "for model in [reg, reg2, rf, rf2]:\n", "    name = model.__class__.__name__\n", "    try:\n", "        pred2 = model.predict(X_test2)\n", "    except Exception:\n", "        pred2 = model.predict(poly.transform(X_test2))\n", "        name += \" + X^2\"\n", "    ax[0].plot(X_test2[index2, 0], pred2[index2], '.', label=name)\n", "    ax[1].plot(X_test2[index1, 1], pred2[index1], '.', label=name)\n", "ax[0].legend()\n", "ax[1].legend();"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Le graphe \u00e9tudie les variables des mod\u00e8les selon une coordonn\u00e9es tout en restreignant l'autre dans un intervalle donn\u00e9. On voit tout de suite que la for\u00eat al\u00e9atoire devient constante au del\u00e0 d'un certain seuil. C'est encore une fois tout \u00e0 fait normal puisque la base d'apprentissage ne contient des $X_1, X_2$ que dans l'intervalle $[0, 1]$. En dehors, chaque arbre de d\u00e9cision produit une valeur constante tout simplement parce que ce sont des fonctions en escalier : une for\u00eat al\u00e9atoire est une moyenne de fonctions en escalier, elle est born\u00e9e. Quant \u00e0 la premi\u00e8re r\u00e9gression lin\u00e9aire, elle ne peut saisir les effets du second degr\u00e9, elle est lin\u00e9aire par rapport aux variables de d\u00e9part. Elle s'\u00e9carte moins mais elle s'\u00e9carte quand m\u00eame de la variable \u00e0 pr\u00e9dire.\n", "\n", "Cet exercice a pour but d'illustrer qu'un mod\u00e8le de machine learning est estim\u00e9 sur un jeu de donn\u00e9es qui suit une certaine distribution. Lorsque les donn\u00e9es sur lesquelles le mod\u00e8le est utilis\u00e9 pour pr\u00e9dire ne suivent plus cette loi, les mod\u00e8les retournent des r\u00e9ponses qui ont toutes les chances d'\u00eatre fausses et ce, de mani\u00e8re diff\u00e9rente selon les mod\u00e8les.\n", "\n", "C'est pour cela qu'on dit qu'il faut r\u00e9apprendre r\u00e9guli\u00e8rement les mod\u00e8les de machine learning, surtout s'ils sont appliqu\u00e9s sur des donn\u00e9es g\u00e9n\u00e9r\u00e9es par l'activit\u00e9 humaine et non des donn\u00e9es issues de probl\u00e8mes physiques."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Exercice 7 : illuster l'overfitting avec un arbre de d\u00e9cision\n", "\n", "Sur le premier jeu de donn\u00e9es."]}, {"cell_type": "code", "execution_count": 17, "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>profondeur</th>\n", "      <th>r2_test</th>\n", "      <th>r2_train</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>1</td>\n", "      <td>0.380103</td>\n", "      <td>0.446387</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>2</td>\n", "      <td>0.636346</td>\n", "      <td>0.672284</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>3</td>\n", "      <td>0.786778</td>\n", "      <td>0.826594</td>\n", "    </tr>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>4</td>\n", "      <td>0.872799</td>\n", "      <td>0.892911</td>\n", "    </tr>\n", "    <tr>\n", "      <th>4</th>\n", "      <td>5</td>\n", "      <td>0.896276</td>\n", "      <td>0.931297</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["   profondeur   r2_test  r2_train\n", "0           1  0.380103  0.446387\n", "1           2  0.636346  0.672284\n", "2           3  0.786778  0.826594\n", "3           4  0.872799  0.892911\n", "4           5  0.896276  0.931297"]}, "execution_count": 18, "metadata": {}, "output_type": "execute_result"}], "source": ["from sklearn.tree import DecisionTreeRegressor\n", "\n", "res = []\n", "for md in range(1, 20):\n", "    tree = DecisionTreeRegressor(max_depth=md)\n", "    tree.fit(X_train, y_train)\n", "    r2_train = r2_score(y_train, tree.predict(X_train))\n", "    r2_test = r2_score(y_test, tree.predict(X_test))\n", "    res.append(dict(profondeur=md, r2_train=r2_train, r2_test=r2_test))\n", "\n", "df = pandas.DataFrame(res)\n", "df.head()"]}, {"cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["ax = df.plot(x='profondeur', y=['r2_train', 'r2_test'])\n", "ax.set_title(\"Evolution du R2 selon la profondeur\");"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Exercice 8  : augmenter le nombre de features et r\u00e9gulariser une r\u00e9gression logistique\n", "\n", "L'objectif est de regarder l'impact de la r\u00e9gularisation des coefficients d'une r\u00e9gression logistique lorsque le nombre de features augmentent. On utilise les features polyn\u00f4miales et une r\u00e9gression [Ridge](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Ridge.html) ou [Lasso](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Lasso.html)."]}, {"cell_type": "code", "execution_count": 19, "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>degre</th>\n", "      <th>nb_features</th>\n", "      <th>nnul_las</th>\n", "      <th>nnul_reg</th>\n", "      <th>nnul_rid</th>\n", "      <th>norm_las</th>\n", "      <th>norm_reg</th>\n", "      <th>norm_rid</th>\n", "      <th>r2_las</th>\n", "      <th>r2_reg</th>\n", "      <th>r2_rid</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>1</td>\n", "      <td>3</td>\n", "      <td>2</td>\n", "      <td>2</td>\n", "      <td>2</td>\n", "      <td>3.403924</td>\n", "      <td>3.568168e+00</td>\n", "      <td>3.079896</td>\n", "      <td>0.906854</td>\n", "      <td>0.908988</td>\n", "      <td>0.892232</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>2</td>\n", "      <td>6</td>\n", "      <td>4</td>\n", "      <td>5</td>\n", "      <td>5</td>\n", "      <td>3.280738</td>\n", "      <td>3.334211e+00</td>\n", "      <td>2.350989</td>\n", "      <td>0.934247</td>\n", "      <td>0.936239</td>\n", "      <td>0.919758</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>3</td>\n", "      <td>10</td>\n", "      <td>4</td>\n", "      <td>9</td>\n", "      <td>9</td>\n", "      <td>3.280888</td>\n", "      <td>5.090698e+00</td>\n", "      <td>2.072340</td>\n", "      <td>0.934247</td>\n", "      <td>0.935657</td>\n", "      <td>0.921656</td>\n", "    </tr>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>4</td>\n", "      <td>15</td>\n", "      <td>4</td>\n", "      <td>14</td>\n", "      <td>14</td>\n", "      <td>3.280963</td>\n", "      <td>1.180973e+01</td>\n", "      <td>1.992448</td>\n", "      <td>0.934248</td>\n", "      <td>0.934934</td>\n", "      <td>0.921532</td>\n", "    </tr>\n", "    <tr>\n", "      <th>4</th>\n", "      <td>5</td>\n", "      <td>21</td>\n", "      <td>4</td>\n", "      <td>20</td>\n", "      <td>20</td>\n", "      <td>3.281022</td>\n", "      <td>6.657031e+01</td>\n", "      <td>1.972762</td>\n", "      <td>0.934248</td>\n", "      <td>0.935177</td>\n", "      <td>0.921656</td>\n", "    </tr>\n", "    <tr>\n", "      <th>5</th>\n", "      <td>6</td>\n", "      <td>28</td>\n", "      <td>4</td>\n", "      <td>27</td>\n", "      <td>26</td>\n", "      <td>3.281037</td>\n", "      <td>3.242570e+02</td>\n", "      <td>1.965189</td>\n", "      <td>0.934248</td>\n", "      <td>0.934388</td>\n", "      <td>0.921823</td>\n", "    </tr>\n", "    <tr>\n", "      <th>6</th>\n", "      <td>7</td>\n", "      <td>36</td>\n", "      <td>4</td>\n", "      <td>35</td>\n", "      <td>35</td>\n", "      <td>3.281040</td>\n", "      <td>1.428490e+03</td>\n", "      <td>1.958965</td>\n", "      <td>0.934248</td>\n", "      <td>0.933246</td>\n", "      <td>0.921927</td>\n", "    </tr>\n", "    <tr>\n", "      <th>7</th>\n", "      <td>8</td>\n", "      <td>45</td>\n", "      <td>4</td>\n", "      <td>44</td>\n", "      <td>43</td>\n", "      <td>3.281041</td>\n", "      <td>1.441240e+04</td>\n", "      <td>1.952981</td>\n", "      <td>0.934248</td>\n", "      <td>0.931307</td>\n", "      <td>0.921976</td>\n", "    </tr>\n", "    <tr>\n", "      <th>8</th>\n", "      <td>9</td>\n", "      <td>55</td>\n", "      <td>4</td>\n", "      <td>55</td>\n", "      <td>53</td>\n", "      <td>3.281041</td>\n", "      <td>4.893616e+13</td>\n", "      <td>1.947737</td>\n", "      <td>0.934248</td>\n", "      <td>0.616562</td>\n", "      <td>0.921997</td>\n", "    </tr>\n", "    <tr>\n", "      <th>9</th>\n", "      <td>10</td>\n", "      <td>66</td>\n", "      <td>4</td>\n", "      <td>65</td>\n", "      <td>65</td>\n", "      <td>3.281041</td>\n", "      <td>4.659569e+05</td>\n", "      <td>1.943600</td>\n", "      <td>0.934248</td>\n", "      <td>0.929751</td>\n", "      <td>0.922013</td>\n", "    </tr>\n", "    <tr>\n", "      <th>10</th>\n", "      <td>11</td>\n", "      <td>78</td>\n", "      <td>4</td>\n", "      <td>77</td>\n", "      <td>75</td>\n", "      <td>3.281041</td>\n", "      <td>2.360073e+06</td>\n", "      <td>1.940623</td>\n", "      <td>0.934248</td>\n", "      <td>0.925344</td>\n", "      <td>0.922035</td>\n", "    </tr>\n", "    <tr>\n", "      <th>11</th>\n", "      <td>12</td>\n", "      <td>91</td>\n", "      <td>4</td>\n", "      <td>91</td>\n", "      <td>88</td>\n", "      <td>3.281041</td>\n", "      <td>1.708086e+07</td>\n", "      <td>1.938666</td>\n", "      <td>0.934248</td>\n", "      <td>0.921123</td>\n", "      <td>0.922067</td>\n", "    </tr>\n", "    <tr>\n", "      <th>12</th>\n", "      <td>13</td>\n", "      <td>105</td>\n", "      <td>4</td>\n", "      <td>105</td>\n", "      <td>99</td>\n", "      <td>3.281041</td>\n", "      <td>9.955733e+07</td>\n", "      <td>1.937518</td>\n", "      <td>0.934248</td>\n", "      <td>0.874136</td>\n", "      <td>0.922108</td>\n", "    </tr>\n", "    <tr>\n", "      <th>13</th>\n", "      <td>14</td>\n", "      <td>120</td>\n", "      <td>4</td>\n", "      <td>120</td>\n", "      <td>111</td>\n", "      <td>3.281041</td>\n", "      <td>6.854497e+08</td>\n", "      <td>1.936961</td>\n", "      <td>0.934248</td>\n", "      <td>0.927716</td>\n", "      <td>0.922158</td>\n", "    </tr>\n", "    <tr>\n", "      <th>14</th>\n", "      <td>15</td>\n", "      <td>136</td>\n", "      <td>4</td>\n", "      <td>136</td>\n", "      <td>127</td>\n", "      <td>3.281041</td>\n", "      <td>3.786997e+09</td>\n", "      <td>1.936808</td>\n", "      <td>0.934248</td>\n", "      <td>0.842488</td>\n", "      <td>0.922212</td>\n", "    </tr>\n", "    <tr>\n", "      <th>15</th>\n", "      <td>16</td>\n", "      <td>153</td>\n", "      <td>4</td>\n", "      <td>153</td>\n", "      <td>145</td>\n", "      <td>3.281041</td>\n", "      <td>4.467998e+10</td>\n", "      <td>1.936913</td>\n", "      <td>0.934248</td>\n", "      <td>0.664588</td>\n", "      <td>0.922269</td>\n", "    </tr>\n", "    <tr>\n", "      <th>16</th>\n", "      <td>17</td>\n", "      <td>171</td>\n", "      <td>4</td>\n", "      <td>171</td>\n", "      <td>161</td>\n", "      <td>3.281041</td>\n", "      <td>2.361809e+11</td>\n", "      <td>1.937165</td>\n", "      <td>0.934248</td>\n", "      <td>-0.726442</td>\n", "      <td>0.922325</td>\n", "    </tr>\n", "    <tr>\n", "      <th>17</th>\n", "      <td>18</td>\n", "      <td>190</td>\n", "      <td>4</td>\n", "      <td>190</td>\n", "      <td>179</td>\n", "      <td>3.281041</td>\n", "      <td>1.599035e+12</td>\n", "      <td>1.937489</td>\n", "      <td>0.934248</td>\n", "      <td>0.582385</td>\n", "      <td>0.922379</td>\n", "    </tr>\n", "    <tr>\n", "      <th>18</th>\n", "      <td>19</td>\n", "      <td>210</td>\n", "      <td>4</td>\n", "      <td>210</td>\n", "      <td>203</td>\n", "      <td>3.281041</td>\n", "      <td>4.455355e+13</td>\n", "      <td>1.937834</td>\n", "      <td>0.934248</td>\n", "      <td>-25.406536</td>\n", "      <td>0.922429</td>\n", "    </tr>\n", "    <tr>\n", "      <th>19</th>\n", "      <td>20</td>\n", "      <td>231</td>\n", "      <td>4</td>\n", "      <td>231</td>\n", "      <td>223</td>\n", "      <td>3.281041</td>\n", "      <td>2.262080e+13</td>\n", "      <td>1.938168</td>\n", "      <td>0.934248</td>\n", "      <td>-21.684447</td>\n", "      <td>0.922475</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["    degre  nb_features  nnul_las  nnul_reg  nnul_rid  norm_las      norm_reg  \\\n", "0       1            3         2         2         2  3.403924  3.568168e+00   \n", "1       2            6         4         5         5  3.280738  3.334211e+00   \n", "2       3           10         4         9         9  3.280888  5.090698e+00   \n", "3       4           15         4        14        14  3.280963  1.180973e+01   \n", "4       5           21         4        20        20  3.281022  6.657031e+01   \n", "5       6           28         4        27        26  3.281037  3.242570e+02   \n", "6       7           36         4        35        35  3.281040  1.428490e+03   \n", "7       8           45         4        44        43  3.281041  1.441240e+04   \n", "8       9           55         4        55        53  3.281041  4.893616e+13   \n", "9      10           66         4        65        65  3.281041  4.659569e+05   \n", "10     11           78         4        77        75  3.281041  2.360073e+06   \n", "11     12           91         4        91        88  3.281041  1.708086e+07   \n", "12     13          105         4       105        99  3.281041  9.955733e+07   \n", "13     14          120         4       120       111  3.281041  6.854497e+08   \n", "14     15          136         4       136       127  3.281041  3.786997e+09   \n", "15     16          153         4       153       145  3.281041  4.467998e+10   \n", "16     17          171         4       171       161  3.281041  2.361809e+11   \n", "17     18          190         4       190       179  3.281041  1.599035e+12   \n", "18     19          210         4       210       203  3.281041  4.455355e+13   \n", "19     20          231         4       231       223  3.281041  2.262080e+13   \n", "\n", "    norm_rid    r2_las     r2_reg    r2_rid  \n", "0   3.079896  0.906854   0.908988  0.892232  \n", "1   2.350989  0.934247   0.936239  0.919758  \n", "2   2.072340  0.934247   0.935657  0.921656  \n", "3   1.992448  0.934248   0.934934  0.921532  \n", "4   1.972762  0.934248   0.935177  0.921656  \n", "5   1.965189  0.934248   0.934388  0.921823  \n", "6   1.958965  0.934248   0.933246  0.921927  \n", "7   1.952981  0.934248   0.931307  0.921976  \n", "8   1.947737  0.934248   0.616562  0.921997  \n", "9   1.943600  0.934248   0.929751  0.922013  \n", "10  1.940623  0.934248   0.925344  0.922035  \n", "11  1.938666  0.934248   0.921123  0.922067  \n", "12  1.937518  0.934248   0.874136  0.922108  \n", "13  1.936961  0.934248   0.927716  0.922158  \n", "14  1.936808  0.934248   0.842488  0.922212  \n", "15  1.936913  0.934248   0.664588  0.922269  \n", "16  1.937165  0.934248  -0.726442  0.922325  \n", "17  1.937489  0.934248   0.582385  0.922379  \n", "18  1.937834  0.934248 -25.406536  0.922429  \n", "19  1.938168  0.934248 -21.684447  0.922475  "]}, "execution_count": 20, "metadata": {}, "output_type": "execute_result"}], "source": ["from sklearn.linear_model import Ridge, Lasso\n", "import numpy.linalg as nplin\n", "import numpy\n", "\n", "def coef_non_nuls(coef):\n", "    return sum(numpy.abs(coef) > 0.001)\n", "\n", "res = []\n", "for d in range(1, 21):\n", "    poly = PolynomialFeatures(degree=d)    \n", "    poly.fit(X_train)\n", "    X_test2 = poly.transform(X_test)\n", "    \n", "    reg = LinearRegression()\n", "    reg.fit(poly.transform(X_train), y_train)\n", "    r2_reg = r2_score(y_test, reg.predict(X_test2))\n", "    \n", "    rid = Ridge(alpha=10)\n", "    rid.fit(poly.transform(X_train), y_train)\n", "    r2_rid = r2_score(y_test, rid.predict(X_test2))\n", "    \n", "    las = Lasso(alpha=0.01)\n", "    las.fit(poly.transform(X_train), y_train)\n", "    r2_las = r2_score(y_test, las.predict(X_test2))\n", "    \n", "    res.append(dict(degre=d, nb_features=X_test2.shape[1],\n", "                    r2_reg=r2_reg, r2_las=r2_las, r2_rid=r2_rid,\n", "                    norm_reg=nplin.norm(reg.coef_),\n", "                    norm_rid=nplin.norm(rid.coef_),\n", "                    norm_las=nplin.norm(las.coef_),\n", "                    nnul_reg=coef_non_nuls(reg.coef_),\n", "                    nnul_rid=coef_non_nuls(rid.coef_),\n", "                    nnul_las=coef_non_nuls(las.coef_),\n", "                    ))\n", "\n", "df = pandas.DataFrame(res)\n", "df"]}, {"cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["<Figure size 864x288 with 2 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["fig, ax = plt.subplots(1, 2, figsize=(12, 4))\n", "df.plot(x=\"nb_features\", y=[\"r2_reg\", \"r2_las\", \"r2_rid\"], ax=ax[0])\n", "ax[0].set_xlabel(\"Nombre de features\")\n", "ax[0].set_ylim([0, 1])\n", "ax[0].set_title(\"r2\")\n", "df.plot(x=\"nb_features\", y=[\"nnul_reg\", \"nnul_las\", \"nnul_rid\"], ax=ax[1])\n", "ax[1].set_xlabel(\"Nombre de features\")\n", "ax[1].set_title(\"Nombre de coefficients non nuls\");"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Num\u00e9riquement, la r\u00e9gression lin\u00e9aire devient difficile \u00e0 estimer lorsque le nombre de features augmente. Th\u00e9oriquement, il ne devrait pas y avoir de baisse de performances mais le graphe montre des erreurs \u00e9videntes. Cela se traduit par une norme des coefficients qui explose. La r\u00e9gularisation parvient \u00e0 contraindre les mod\u00e8les. La r\u00e9gression *Ridge* produira beaucoup de petits coefficients non nuls, la r\u00e9gression *Lasso* pr\u00e9f\u00e8rera concentrer la norme sur quelques coefficients seulement. Cette observation n'est vraie que dans le cas d'une r\u00e9gression lin\u00e9aire avec une erreur quadratique."]}, {"cell_type": "code", "execution_count": 21, "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.0"}}, "nbformat": 4, "nbformat_minor": 2}