10 - Numpy (les Bases).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled7.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyOBDpBixGknnBtNmIz7Zvhf",
      "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/10%20-%20Numpy%20(les%20Bases).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kPpCo82Kj-HT"
      },
      "source": [
        "# 10/30 Numpy : Tableau ndarray"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1pmhE3K-j8uk"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ueEc8h86slN-"
      },
      "source": [
        "## 1. Générateurs de tableaux **ndarray**\n",
        "- générateur par défaut : **ndarray()**\n",
        "- générateur 1D : **np.linspace** et **np.arange()**\n",
        "- générateur ND : **np.zeros()**, **np.ones()**, **np.random.randn()** (ce sont les plus utiles)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FAALhYpise2W"
      },
      "source": [
        "A = np.array([1, 2, 3]) # générateur par défaut, qui permet de convertir des listes (ou autres objets) en tableau ndarray\n",
        "A = np.zeros((2, 3)) # tableau de 0 aux dimensions 2x3\n",
        "B = np.ones((2, 3)) # tableau de 1 aux dimensions 2x3\n",
        "C = np.random.randn(2, 3) # tableau aléatoire (distribution normale) aux dimensions 2x3\n",
        "D = np.random.rand(2, 3) # tableau aléatoire (distribution uniforme)\n",
        " \n",
        "E = np.random.randint(0, 10, [2, 3]) # tableau d'entiers aléatoires de 0 a 10 et de dimension 2x3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qlCQKYHvsij7"
      },
      "source": [
        "A = np.ones((2, 3), dtype=np.float16) # définit le type et la place a occuper sur la mémoire\n",
        "B = np.eye(4, dtype=np.bool) # créer une matrice identité et convertit les éléments en type bool."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2_wG1YYM3cKL"
      },
      "source": [
        "A = np.linspace(1,10, 10)\n",
        "B = np.arange(0, 10, 10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O0gPhrkatFCq"
      },
      "source": [
        "## 2. Attributs importants\n",
        "- size\n",
        "- shape"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "49om7hC7s7PY",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "11656a58-5b8c-4a61-df58-8092d792bbd7"
      },
      "source": [
        "A = np.zeros((2, 3)) # création d'un tableau de shape (2, 3)\n",
        " \n",
        "print(A.size) # le nombre d'éléments dans le tableau A\n",
        "print(A.shape) # les dimensions du tableau A (sous forme de Tuple)\n",
        " \n",
        "print(type(A.shape)) # voici la preuve que la shape est un tuple\n",
        " \n",
        "print(A.shape[0]) # le nombre d'éléments dans la premiere dimension de A"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "6\n",
            "(2, 3)\n",
            "<class 'tuple'>\n",
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LJxuYLLptW4U"
      },
      "source": [
        "## 3. Méthodes importantes\n",
        "- **reshape()** : pour redimensionner un tableau\n",
        "- **ravel()** : pour applatir un tableau (qu'il ne fasse plus qu'une dimension)\n",
        "- **squeeze()** : quand une dimension est égale a 1, cette dimension disparait\n",
        "- **concatenate()** : assemble 2 tableaux ensemble selon un axes (existe aussi en hstack et vstack)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nzys1OiQtTS1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "894bea04-06a6-4e23-e335-abe43764c7e0"
      },
      "source": [
        "A = np.zeros((2, 3)) # création d'un tableau de shape (2, 3)\n",
        " \n",
        "A = A.reshape((3, 2)) # redimensionne le tableau A (3 lignes, 2 colonnes)\n",
        "A.ravel() # Aplatit le tableau A (une seule dimension)\n",
        "A.squeeze() # élimine les dimensions \"1\" de A."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 0.],\n",
              "       [0., 0.],\n",
              "       [0., 0.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1sBGP0vxtlNT",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "7ad91082-e579-4084-c8a8-391f3e25d505"
      },
      "source": [
        "A = np.zeros((2, 3)) # création d'un tableau de shape (2, 3)\n",
        "B = np.ones((2, 3)) # création d'un tableau de shape (2, 3)\n",
        "\n",
        "np.concatenate((A, B), axis=0) # axe 0 : équivalent de np.vstack((A, B))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 0., 0.],\n",
              "       [0., 0., 0.],\n",
              "       [1., 1., 1.],\n",
              "       [1., 1., 1.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ped85c9YuN5t",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "3b5936d1-b344-40ef-950a-ca44e0c8c09a"
      },
      "source": [
        "np.concatenate((A, B), axis=1) # axe 1 : équivalent de np.hstack((A, B))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 0., 0., 1., 1., 1.],\n",
              "       [0., 0., 0., 1., 1., 1.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PBuUMz7Tu9jK"
      },
      "source": [
        "## 4. Exercice et Solutions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZBCmA3ZIuRVt"
      },
      "source": [
        "def initialisation(m, n):\n",
        "    # m : nombre de lignes\n",
        "    # n : nombre de colonnes\n",
        "    # retourne une matrice aléatoire (m, n+1)\n",
        "    # avec une colonne biais (remplie de \"1\") tout a droite\n",
        "\n",
        "    return X"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wm0Z6SqRuhJL",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "385c2ecd-c94d-474c-9365-a4adeac802a2"
      },
      "source": [
        "# SOLUTION\n",
        "def initialisation(m, n):\n",
        "    # m : nombre de lignes\n",
        "    # n : nombre de colonnes\n",
        "    # retourne une matrice aléatoire (m, n+1)\n",
        "    # avec une colonne biais (remplie de \"1\") tout a droite\n",
        "    X = np.random.randn(m, n)\n",
        "    X = np.concatenate((X, np.ones((X.shape[0], 1))), axis = 1)\n",
        "\n",
        "    return X\n",
        "\n",
        "initialisation(3, 4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[-0.10764065,  0.69827025, -1.12110256,  0.78840126,  1.        ],\n",
              "       [-0.68425126,  0.02373615,  1.47735478, -0.81758181,  1.        ],\n",
              "       [-2.8762856 , -0.40033763,  0.44811493,  1.13210525,  1.        ]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qg_S5VLTvBh0"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}