{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# 1A.e - Enonc\u00e9 23 octobre 2018 (1)\n", "\n", "Correction du premier \u00e9nonc\u00e9 de l'examen du 23 octobre 2018. L'\u00e9nonc\u00e9 propose une m\u00e9thode pour renseigner les valeurs manquantes dans une base de deux variables."]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [{"data": {"text/html": ["
run previous cell, wait for 2 seconds
\n", ""], "text/plain": [""]}, "execution_count": 2, "metadata": {}, "output_type": "execute_result"}], "source": ["from jyquickhelper import add_notebook_menu\n", "add_notebook_menu()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["On sait d'apr\u00e8s les derni\u00e8res questions qu'il faudra tout r\u00e9p\u00e9ter plusieurs fois. On prend le soin d'\u00e9crire chaque question dans une fonction."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Q1 - \u00e9chantillon al\u00e9atoire\n", "\n", "G\u00e9n\u00e9rer un ensemble de $N=1000$ couples al\u00e9atoires $(X_i,Y_i)$ qui v\u00e9rifient :\n", "\n", "* $X_i$ suit une loi normale de variance 1.\n", "* $Y_i = 2 X_i + \\epsilon_i$ o\u00f9 $\\epsilon_i$ suit une loi normale de variance 1."]}, {"cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([[-0.21542897, -1.02478399],\n", " [-0.89552004, -2.24733264],\n", " [-1.393163 , -5.40164738],\n", " [ 1.32997878, 2.70660631],\n", " [-1.20765567, -2.43301488]])"]}, "execution_count": 3, "metadata": {}, "output_type": "execute_result"}], "source": ["import numpy.random as rnd\n", "import numpy\n", "\n", "def random_mat(N):\n", " mat = numpy.zeros((N, 2))\n", " mat[:, 0] = rnd.normal(size=(N,))\n", " mat[:, 1] = mat[:, 0] * 2 + rnd.normal(size=(N,))\n", " return mat\n", "\n", "N = 1000\n", "mat = random_mat(N)\n", "mat[:5]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Remarque 1 :** Un \u00e9l\u00e8ve a retourn\u00e9 cette r\u00e9ponse, je vous laisse chercher pourquoi ce code produit deux variables tout-\u00e0-fait d\u00e9corr\u00e9l\u00e9es.\n", "\n", "```\n", "def random_mat(N=1000):\n", " A = np.random.normal(0,1,(N,2))\n", " A[:,1] = 2*A[:,1] + np.random.normal(0,1,N)/10\n", " return A\n", "```\n", "\n", "Cela peut se v\u00e9rifier en calculant la corr\u00e9lation.\n", "\n", "**Remarque 2 :** Un \u00e9l\u00e8ve a g\u00e9n\u00e9r\u00e9 le nuage $X + 2\\epsilon$ ce qui produit un nuage de points dont les deux variable sont moins corr\u00e9l\u00e9es. Voir \u00e0 la fin pour plus de d\u00e9tail."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Q2 - matrice m1\n", "\n", "On d\u00e9finit la matrice $M \\in \\mathbb{M}_{N,2}(\\mathbb{R})$ d\u00e9finie par les deux vecteurs colonnes $(X_i)$ et $(Y_i)$. Choisir al\u00e9atoirement 20 valeurs dans cette matrice et les remplacer par ``numpy.nan``. On obtient la matrice $M_1$."]}, {"cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([[ 0.26184685, 0.41751593],\n", " [-0.53354327, 0.34849608],\n", " [-1.96298222, nan],\n", " [ 1.51815696, 1.58374784],\n", " [ 0.71569523, 3.12326482]])"]}, "execution_count": 4, "metadata": {}, "output_type": "execute_result"}], "source": ["import random\n", "\n", "def build_m1(mat, n=20):\n", " mat = mat.copy()\n", " positions = []\n", " while len(positions) < n:\n", " h = random.randint(0, mat.shape[0] * mat.shape[1] - 1)\n", " pos = h % mat.shape[0], h // mat.shape[0]\n", " if pos in positions:\n", " # La position est d\u00e9j\u00e0 tir\u00e9e.\n", " continue\n", " positions.append(pos)\n", " mat[pos] = numpy.nan\n", " return mat, positions\n", "\n", "m1, positions = build_m1(mat)\n", "p = positions[0][0]\n", "m1[max(p-2, 0):min(p+3, mat.shape[0])]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Remarque 1:** l'\u00e9nonc\u00e9 ne pr\u00e9cisait pas s'il fallait choisir les valeurs al\u00e9atoires sur une ou deux colonnes, le faire sur une seule colonne est sans doute plus rapide et ne change rien aux conclusions des derni\u00e8res questions.\n", "\n", "**Remarque 2:** il ne faut pas oublier de copier la matrice ``mat.copy()``, dans le cas contraire, la fonction modifie la matrice originale. Ce n'est pas n\u00e9cessairement un probl\u00e8me except\u00e9 pour les derni\u00e8res questions qui requiert de garder cette matrice.\n", "\n", "**Remarque 3:** l'\u00e9nonc\u00e9 ne pr\u00e9cisait pas avec ou sans remise. L'impl\u00e9mentation pr\u00e9c\u00e9dente le fait sans remise."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Q3 - moyenne\n", "\n", "Calculer $\\mathbb{E}{X} = \\frac{1}{N}\\sum_i^N X_i$ et $\\mathbb{E}Y = \\frac{1}{N}\\sum_i^N Y_i$. Comme on ne tient pas compte des valeurs manquantes, les moyennes calcul\u00e9es se font avec moins de $N$ termes. Si on d\u00e9finit $V_x$ et $V_y$ l'ensemble des valeurs non manquantes, on veut calculer $\\mathbb{E}{X} = \\frac{\\sum_{i \\in V_x} X_i}{\\sum_{i \\in V_x} 1}$ et $\\mathbb{E}Y = \\frac{\\sum_{i \\in V_y} Y_i}{\\sum_{i \\in V_y} 1}$."]}, {"cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([0.05543522, 0.0564421 ])"]}, "execution_count": 5, "metadata": {}, "output_type": "execute_result"}], "source": ["def mean_no_nan(mat):\n", " res = []\n", " for i in range(mat.shape[1]):\n", " ex = numpy.mean(mat[~numpy.isnan(mat[:, i]), i])\n", " res.append(ex)\n", " return numpy.array(res)\n", "\n", "mean_no_nan(m1)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Remarque 1 :** il \u00e9tait encore plus simple d'utiliser la fonction [nanmean](https://docs.scipy.org/doc/numpy/reference/generated/numpy.nanmean.html#numpy.nanmean).\n", "\n", "**Remarque 2 :** Il fallait diviser par le nombre de valeurs non nulles et non le nombre de lignes de la matrice."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Q4 - matrice m2\n", "\n", "Remplacer les valeurs manquantes de la matrice $M_1$ par la moyenne de leurs colonnes respectives. On obtient la matrice $M_2$."]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([[ 0.26184685, 0.41751593],\n", " [-0.53354327, 0.34849608],\n", " [-1.96298222, 0.0564421 ],\n", " [ 1.51815696, 1.58374784],\n", " [ 0.71569523, 3.12326482]])"]}, "execution_count": 6, "metadata": {}, "output_type": "execute_result"}], "source": ["def build_m2(mat):\n", " means = mean_no_nan(mat)\n", " m2 = mat.copy()\n", " for i in range(len(means)):\n", " m2[numpy.isnan(m2[:, i]), i] = means[i]\n", " return m2\n", "\n", "m2 = build_m2(m1)\n", "m2[max(p-2, 0):min(p+3, mat.shape[0])]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Q5 - matrice m3\n", "\n", "On trie la matrice $M_1$ selon la premi\u00e8re colonne. On remplace chaque $y$ manquant par la moyenne des deux valeurs qui l'entourent. On recommence avec les $x$ manquant. On obtient la matrice $M_3$."]}, {"cell_type": "code", "execution_count": 6, "metadata": {"scrolled": false}, "outputs": [{"data": {"text/plain": ["array([[ 0.26184685, 0.41751593],\n", " [-0.53354327, 0.34849608],\n", " [-1.96298222, -3.18717541],\n", " [ 1.51815696, 1.58374784],\n", " [ 0.71569523, 3.12326482]])"]}, "execution_count": 7, "metadata": {}, "output_type": "execute_result"}], "source": ["def fill_column(mat, col):\n", " nlin, ncol = mat.shape\n", " order = numpy.argsort(mat[:, 1-col])\n", " reverse_order = numpy.arange(0, nlin)\n", " for i, v in enumerate(order):\n", " reverse_order[v] = i\n", " bmat = mat[order, :]\n", " last = None\n", " replace = []\n", " for i in range(0, nlin):\n", " if numpy.isnan(bmat[i, col]):\n", " replace.append(i)\n", " else:\n", " if replace:\n", " current = bmat[i, col]\n", " if last is None:\n", " for r in replace:\n", " bmat[r, col] = current\n", " else:\n", " for k, r in enumerate(replace):\n", " bmat[r, col] = last + (current - last) * float(k + 1) / (len(replace) + 1)\n", " last = bmat[i, col]\n", " replace = []\n", " \n", " if len(replace) > 0:\n", " # Il reste des valeurs manquantes \u00e0 la fin.\n", " for r in replace:\n", " bmat[r, col] = last \n", " \n", " return bmat[reverse_order, :]\n", "\n", "def build_m3(mat):\n", " m3 = mat.copy()\n", " for i in range(0, mat.shape[1]):\n", " m3 = fill_column(m3, i)\n", " return m3\n", "\n", "m3 = build_m3(m1)\n", "m3[max(p-2, 0):min(p+3, mat.shape[0])]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["On v\u00e9rifie avec *pandas* que tout s'est bien passe."]}, {"cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [{"data": {"text/html": ["
"], "text/plain": ["Empty DataFrame\n", "Columns: [0, 1]\n", "Index: []"]}, "execution_count": 9, "metadata": {}, "output_type": "execute_result"}], "source": ["df[df.iloc[:, 1].isnull()]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Tout va bien."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Q6 - norme\n", "\n", "On a deux m\u00e9thodes pour compl\u00e9ter les valeurs manquantes, quelle est la meilleure ? Il faut v\u00e9rifier num\u00e9riquement en comparant $\\parallel M-M_2 \\parallel^2$ et $\\parallel M-M_3 \\parallel^2$."]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [{"data": {"text/plain": ["(115.16303767944946, 12.990990757306854)"]}, "execution_count": 10, "metadata": {}, "output_type": "execute_result"}], "source": ["def distance(m1, m2):\n", " d = m1.ravel() - m2.ravel()\n", " return d @ d\n", "\n", "d2 = distance(mat, m2)\n", "d3 = distance(mat, m3)\n", "d2, d3"]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Remarque :** Un \u00e9l\u00e8ve a \u00e9crit avoir trouv\u00e9 ces r\u00e9sultats :\n", "\n", "```\n", "Calcul_norme(M - M2) = 56,57 \n", "Calcul_norme(M- M3) = 0.0 \n", "```\n", "\n", "Un r\u00e9sultat nul doit automatiquement mettre la puce \u00e0 l'oreille puisque car il est hautement improbable que la matrice ``M`` et la matrice ``M3`` soit identique \u00e0 moins que la matrice ``M`` n'ait \u00e9t\u00e9 modifi\u00e9e. On en d\u00e9duit que le premier nombre est en fait la distance ``Calcul_norme(M2 - M3)``."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Q7 - r\u00e9p\u00e9tition\n", "\n", "Une experience r\u00e9ussie ne veut pas dire que cela fonctionne. Recommencer 10 fois en changeant le nuages de points et les valeurs manquantes ajout\u00e9es."]}, {"cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([[ 49.25531314, 19.070392 ],\n", " [ 76.57432808, 18.73422968],\n", " [ 43.43834865, 15.07553875],\n", " [ 50.49648148, 10.11340377],\n", " [116.28344822, 23.90363643],\n", " [ 52.90465816, 14.88595361],\n", " [117.28824424, 28.05673836],\n", " [ 83.37972659, 14.28703801],\n", " [ 48.97835736, 13.49136146],\n", " [ 99.70723528, 27.34848088]])"]}, "execution_count": 11, "metadata": {}, "output_type": "execute_result"}], "source": ["def repetition(N=1000, n=20, nb=10):\n", " res = []\n", " for i in range(nb):\n", " mat = random_mat(N)\n", " m1, _ = build_m1(mat, n)\n", " m2 = build_m2(m1)\n", " m3 = build_m3(m1) \n", " d2, d3 = distance(mat, m2), distance(mat, m3)\n", " res.append((d2, d3))\n", " return numpy.array(res)\n", "\n", "repetition()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Q8 - plus de valeurs manquantes\n", "\n", "Et si on augmente le nombre de valeurs manquantes, l'\u00e9cart se creuse-t-il ou se r\u00e9duit -il ? Montrez-le num\u00e9riquement."]}, {"cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([[3.10112512, 1.1306255 ],\n", " [2.94022724, 0.91916954],\n", " [2.96721215, 1.14121786],\n", " [3.35629971, 0.99870181],\n", " [3.48138722, 1.00467304]])"]}, "execution_count": 12, "metadata": {}, "output_type": "execute_result"}], "source": ["diff = []\n", "ns = []\n", "for n in range(10, 1000, 10):\n", " res = repetition(n=n, nb=10)\n", " diff.append(res.mean(axis=0) / n)\n", " ns.append(n)\n", "diff = numpy.array(diff)\n", "diff[:5]"]}, {"cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": ["%matplotlib inline"]}, {"cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["
"]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["import pandas\n", "df = pandas.DataFrame(diff, columns=[\"d2\", \"d3\"])\n", "df['N'] = ns\n", "df = df.set_index('N')\n", "df[\"ratio2/3\"] = df[\"d2\"] / df[\"d3\"]\n", "\n", "import matplotlib.pyplot as plt\n", "fig, ax = plt.subplots(1, 2, figsize=(10, 4))\n", "df[[\"d2\", \"d3\"]].plot(ax=ax[0])\n", "df[[\"ratio2/3\"]].plot(ax=ax[1])\n", "ax[0].set_title(\"d2, d3\\nErreur moyenne par valeur manquante\")\n", "ax[1].set_title(\"d2 / d3\");"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Plus il y a de valeurs manquantes, plus le ratio tend vers 1 car il y a moins d'informations pour compl\u00e9ter les valeurs manquantes autrement que par la moyenne. Il y a aussi plus souvent des couples de valeurs manquantes qui ne peuvent \u00eatre remplac\u00e9s que par la moyenne."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Q9 - 1 valeur manquante ?\n", "\n", "S'il n'y qu'une valeur manquante, peut-on sans changer le r\u00e9sultat se passer de tri pour avoir un co\u00fbt lin\u00e9aire ?"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Si la valeur manquante est dans la colonne 0, il suffit de chercher l'intervalle le plus petit qui encadre la valeur sur la colonne 1 puis de faire la moyenne des valeurs sur les deux valeurs sur la colonne 0."]}, {"cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([[10. , 11. ],\n", " [ 9. , 10. ],\n", " [ 8. , 9.5],\n", " [ 7. , 9. ],\n", " [ 6. , 8. ]])"]}, "execution_count": 15, "metadata": {}, "output_type": "execute_result"}], "source": ["def build_m3_just1(mat):\n", " for i in range(0, mat.shape[0]):\n", " if numpy.isnan(mat[i, 0]):\n", " pos = i, 0\n", " col = 1\n", " value = mat[i, 1]\n", " break\n", " if numpy.isnan(mat[i, 1]):\n", " pos = i, 1\n", " col = 0\n", " value = mat[i, 0]\n", " break\n", " \n", " imin, imax = None, None\n", " for i in range(0, mat.shape[0]):\n", " if i == pos[0]:\n", " continue\n", " if imin is None or mat[imin, col] < mat[i, col] <= value:\n", " imin = i\n", " if imax is None or mat[imax, col] > mat[i, col] >= value:\n", " imax = i\n", " mat = mat.copy()\n", " mat[pos] = (mat[imin, col] + mat[imax, col]) / 2\n", " return mat\n", "\n", "mat = numpy.array([[10, 11],\n", " [9, 10],\n", " [8, numpy.nan],\n", " [7, 9],\n", " [6, 8]])\n", "build_m3_just1(mat)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Un \u00e9l\u00e8ve a sugg\u00e9r\u00e9 le tri dichotomique qui n'est \u00e9videmment pas une option puisque la dichotomie n\u00e9cessite qu'une colonne soit tri\u00e9e au pr\u00e9alable et c'est justement ce qu'on cherche \u00e0 \u00e9viter."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Q10 - plus de deux colonnes ?\n", "\n", "Pour cette question, vous avez le choix entre impl\u00e9menter la solution que vous proposez \u00e0 la question pr\u00e9c\u00e9dente ou proposer une fa\u00e7on d'\u00e9tendre la m\u00e9thode dans le cas o\u00f9 il y a 3 dimensions."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Dans le cas de notre matrice, on utilise l'autre colonne pour ordonner les lignes. Avec plusieurs colonnes, il faudrait choisir la colonne la plus corr\u00e9l\u00e9e."]}, {"cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [{"data": {"text/html": ["