12 - Numpy Maths et Statistiques.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled9.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyO14Rb0gg3PL1KQURiAHPap",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MachineLearnia/Python-Machine-Learning/blob/master/12%20-%20Numpy%20Maths%20et%20Statistiques.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1CXrPX3b1Fqz",
        "colab_type": "text"
      },
      "source": [
        "# 12/30 Numpy : Mathématiques"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jnkYo8bz1e-P",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6_N90vFm1T7v",
        "colab_type": "text"
      },
      "source": [
        "## 1. Méthodes de bases (les plus utiles) de la classe ndarray"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d8cWapdZ1Cho",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 221
        },
        "outputId": "5aaafff2-6c19-4a6e-db40-0ad1fdba78b5"
      },
      "source": [
        "A = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "\n",
        "print(A.sum()) # effectue la somme de tous les éléments du tableau\n",
        "print(A.sum(axis=0)) # effectue la somme des colonnes (somme sur éléments des les lignes)\n",
        "print(A.sum(axis=1)) # effectue la somme des lignes (somme sur les éléments des colonnes)\n",
        "print(A.cumsum(axis=0)) # effectue la somme cumulée\n",
        " \n",
        "print(A.prod()) # effectue le produit\n",
        "print(A.cumprod()) # effectue le produit cumulé\n",
        " \n",
        "print(A.min()) # trouve le minimum du tableau\n",
        "print(A.max()) # trouve le maximum du tableau\n",
        " \n",
        "print(A.mean()) # calcule la moyenne\n",
        "print(A.std()) # calcule l'ecart type,\n",
        "print(A.var()) # calcule la variance"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "21\n",
            "[5 7 9]\n",
            "[ 6 15]\n",
            "[[1 2 3]\n",
            " [5 7 9]]\n",
            "720\n",
            "[  1   2   6  24 120 720]\n",
            "1\n",
            "6\n",
            "3.5\n",
            "1.707825127659933\n",
            "2.9166666666666665\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f2YyhT1a10_D",
        "colab_type": "text"
      },
      "source": [
        "Une méthode tres importante : la méthode **argsort()**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B4VpaKBC1gP5",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "ece0dc47-6e25-4467-8489-2853d84246ee"
      },
      "source": [
        "A = np.random.randint(0, 10, [5, 5]) # tableau aléatoire\n",
        "print(A)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[4 2 6 2 4]\n",
            " [7 7 4 0 1]\n",
            " [6 6 6 3 3]\n",
            " [2 0 7 7 3]\n",
            " [5 7 4 9 7]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2QQRptNH2CoJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "ca55206b-fdf7-412e-af1a-ffb6ae9658e2"
      },
      "source": [
        "print(A.argsort()) # retourne les index pour trier chaque ligne du tableau "
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1 3 0 4 2]\n",
            " [3 4 2 0 1]\n",
            " [3 4 0 1 2]\n",
            " [1 0 4 2 3]\n",
            " [2 0 1 4 3]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Th0JUW9F1z4O",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "789633ef-0cef-4a83-dbe1-12662c1f4165"
      },
      "source": [
        "print(A[:,0].argsort()) # retourne les index pour trier la colonne 0 de A"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[3 0 4 2 1]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7pbSRQAm2GBW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "2c9c6496-089f-4822-c509-6ff81ebd5b77"
      },
      "source": [
        "A = A[A[:,0].argsort(), :] # trie les colonnes du tableau selon la colonne 0.\n",
        "A"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[2, 0, 7, 7, 3],\n",
              "       [4, 2, 6, 2, 4],\n",
              "       [5, 7, 4, 9, 7],\n",
              "       [6, 6, 6, 3, 3],\n",
              "       [7, 7, 4, 0, 1]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NNIcngt72OHO",
        "colab_type": "text"
      },
      "source": [
        "## 2. Numpy Statistics\n",
        "Correlation de Pearson :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6JKPrFu52Gcj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "914d328d-2e39-4d6e-86a5-93f7868c5115"
      },
      "source": [
        "B = np.random.randn(3, 3) # nombres aléatoires 3x3\n",
        " \n",
        "# retourne la matrice de corrélation de B\n",
        "print(np.corrcoef(B))"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 1.         -0.63427277  0.99937797]\n",
            " [-0.63427277  1.         -0.66114251]\n",
            " [ 0.99937797 -0.66114251  1.        ]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gqrA5qDh2RpN",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "6c490485-2626-447d-91e4-a22e901c865c"
      },
      "source": [
        "# retourne la matrice de corrélation entre les lignes 0 et 1 de B\n",
        "print(np.corrcoef(B[:,0], B[:, 1]))"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1.         0.81847981]\n",
            " [0.81847981 1.        ]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WHndpMUN5dqP",
        "colab_type": "text"
      },
      "source": [
        "np.unique() :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DU4Gx07Q5gVs",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "93ce7095-3cff-429d-d31c-a25221459283"
      },
      "source": [
        "np.random.seed(0)\n",
        "A = np.random.randint(0, 10, [5,5])\n",
        "A"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[5, 0, 3, 3, 7],\n",
              "       [9, 3, 5, 2, 4],\n",
              "       [7, 6, 8, 8, 1],\n",
              "       [6, 7, 7, 8, 1],\n",
              "       [5, 9, 8, 9, 4]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GmkYmQUJ5qG8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "81ffe749-55a1-434c-ec96-60fdf579f9ab"
      },
      "source": [
        "np.unique(A)"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ax4tl32b2YYJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "54fbaa2d-44d1-450e-e773-be9a30277235"
      },
      "source": [
        "values, counts = np.unique(A, return_counts=True)\n",
        "\n",
        "for i, j in zip(values[counts.argsort()], counts[counts.argsort()]):\n",
        "    print(f'valeur {i} apparait {j}')"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "valeur 0 apparait 1\n",
            "valeur 2 apparait 1\n",
            "valeur 1 apparait 2\n",
            "valeur 4 apparait 2\n",
            "valeur 6 apparait 2\n",
            "valeur 3 apparait 3\n",
            "valeur 5 apparait 3\n",
            "valeur 9 apparait 3\n",
            "valeur 7 apparait 4\n",
            "valeur 8 apparait 4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E9A4AEs96YLs",
        "colab_type": "text"
      },
      "source": [
        "Calculs statistiques en présence de données manquates (NaN)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AQGnQU3x6XrI",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "baec5b01-99fb-4f4c-df49-b1253a1f5a07"
      },
      "source": [
        "A = np.random.randn(5, 5)\n",
        "A[0, 2] = np.nan # insere un NaN dans la matrice A\n",
        " \n",
        "print('ratio NaN/zise:', (np.isnan(A).sum()/A.size)) # calcule la proportion de NaN dans A\n",
        " \n",
        "print('moyenne sans NaN:', np.nanmean(A)) # calcule la moyenne de A en ignorant les NaN"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ratio NaN/zise: 0.04\n",
            "moyenne sans NaN: 0.1832816316588837\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SqhHhU7E6PtE",
        "colab_type": "text"
      },
      "source": [
        "## 3. Algebre Linéaire"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NDl2nFYr2ZAb",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "3ef70159-d729-4a17-b551-faabfeadd73d"
      },
      "source": [
        "A = np.ones((2,3))\n",
        "B = np.ones((3,3))\n",
        "\n",
        "print(A.T) # transposé de la matrice A (c'est un attribut de ndarray)"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1. 1.]\n",
            " [1. 1.]\n",
            " [1. 1.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mRiT3DCd6HGR",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "eac920ee-2bb9-4d35-f2f7-7344bdee52c1"
      },
      "source": [
        "print(A.dot(B)) # produit matriciel A.B"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[3. 3. 3.]\n",
            " [3. 3. 3.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qGIj8xxX7GwO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "a15c309c-5525-4e18-887c-68d6d2613d50"
      },
      "source": [
        "A = np.random.randint(0, 10, [3, 3])\n",
        " \n",
        "print('det=', np.linalg.det(A)) # calcule le determinant de A\n",
        "print('inv A:\\n', np.linalg.inv(A)) # calcul l'inverse de A"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "det= 61.00000000000001\n",
            "inv A:\n",
            " [[ 0.08196721  0.63934426 -0.60655738]\n",
            " [-0.13114754 -0.62295082  0.7704918 ]\n",
            " [ 0.21311475  0.26229508 -0.37704918]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d5EXW7GU7KbI",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        },
        "outputId": "57c52695-99ee-42cc-af95-0bb144d0c798"
      },
      "source": [
        "val, vec = np.linalg.eig(A)\n",
        "print('valeur propre:\\n', val) # valeur propre\n",
        "print('vecteur propre:\\n', vec) # vecteur propre"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "valeur propre:\n",
            " [ 8.91371956 -0.86320273  1.94948316]\n",
            "vecteur propre:\n",
            " [[-0.27183844 -0.6838339   0.39494311]\n",
            " [-0.4097407  -0.15279739 -0.73291062]\n",
            " [-0.87075623  0.71345929  0.55395123]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hROrpjBp7W5J",
        "colab_type": "text"
      },
      "source": [
        "## 4. Exercice et Solution\n",
        "\n",
        "Standardisez la matrice suivante, c'est a dire effectuez le calcul suivant :\n",
        "$A = \\frac{A - mean(A_{colonne})}{std(A_{colonne})}$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qPkMTrvq7LE_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "4ad8c37d-1696-4bc1-c02d-1df97177c62a"
      },
      "source": [
        "np.random.seed(0)\n",
        "A = np.random.randint(0, 100, [10, 5])\n",
        "A"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[44, 47, 64, 67, 67],\n",
              "       [ 9, 83, 21, 36, 87],\n",
              "       [70, 88, 88, 12, 58],\n",
              "       [65, 39, 87, 46, 88],\n",
              "       [81, 37, 25, 77, 72],\n",
              "       [ 9, 20, 80, 69, 79],\n",
              "       [47, 64, 82, 99, 88],\n",
              "       [49, 29, 19, 19, 14],\n",
              "       [39, 32, 65,  9, 57],\n",
              "       [32, 31, 74, 23, 35]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JlrzHIuk8OF0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "51a65093-7c60-462a-e794-6122d299ea9d"
      },
      "source": [
        "# SOLUTION\n",
        "D = (A - A.mean(axis=0)) / A.std(axis=0)\n",
        "D"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[-0.02206157,  0.        ,  0.13173823,  0.72539252,  0.10755798],\n",
              "       [-1.56637126,  1.61579632, -1.48676006, -0.33034307,  0.96802178],\n",
              "       [ 1.12513992,  1.84021247,  1.03508612, -1.14768676, -0.27965074],\n",
              "       [ 0.90452425, -0.35906585,  0.99744662,  0.0102168 ,  1.01104497],\n",
              "       [ 1.6104944 , -0.44883231, -1.33620208,  1.0659524 ,  0.32267393],\n",
              "       [-1.56637126, -1.21184724,  0.73397016,  0.7935045 ,  0.62383626],\n",
              "       [ 0.11030784,  0.76301493,  0.80924915,  1.81518411,  1.01104497],\n",
              "       [ 0.1985541 , -0.80789816, -1.56203905, -0.90929485, -2.17267111],\n",
              "       [-0.24267724, -0.67324847,  0.16937773, -1.24985473, -0.32267393],\n",
              "       [-0.55153918, -0.7181317 ,  0.50813319, -0.77307091, -1.26918412]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tHPZsh-V8TcK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "8e087346-6e31-43f9-f356-66a3ce45ffc7"
      },
      "source": [
        "print(D.mean(axis=0)) # les moyennes sont toutes = 0\n",
        "print(D.std(axis=0)) # les std sont tous = 1 "
      ],
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[-2.22044605e-17 -4.44089210e-17  0.00000000e+00 -1.22124533e-16\n",
            " -4.44089210e-17]\n",
            "[1. 1. 1. 1. 1.]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q0YF4PYo8Ylj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}